Get {@code numElements} out of the {@link CodecOutputList} and forward these through the pipeline.
4944
static void fireChannelRead(ChannelHandlerContext ctx, CodecOutputList msgs, int numElements) {
        for (int i = 0; i < numElements; i ++) {
            ctx.fireChannelRead(msgs.getUnsafe(i));
        }
    }
755265
public java.util.List<Pipeline> getPipelines() {
        if (pipelines == null) {
            pipelines = new com.amazonaws.internal.SdkInternalList<Pipeline>();
        }
        return pipelines;
    }
525835
public ProcessExecutor exitValues(int[] exitValues) {
    if (exitValues == null)
      return exitValueAny();
    // Convert int[] -> Integer[]
    Integer[] array = new Integer[exitValues.length];
    for (int i = 0; i < array.length; i++)
      array[i] = exitValues[i];
    return exitValues(array);
  }
508294
public Collection<ComponentBuilder> getResultProducingComponentBuilders() {
        final Collection<ComponentBuilder> componentBuilders = getComponentBuilders();

        return CollectionUtils.filter(componentBuilders, componentBuilder -> {
            final ComponentDescriptor<?> descriptor = componentBuilder.getDescriptor();
            return ReflectionUtils.is(descriptor.getComponentClass(), HasAnalyzerResult.class);
        });
    }
452892
private List<TInput> getInputs(final List<Integer> taskletIds) {

    final List<TInput> inputList = new ArrayList<>(taskletIds.size());

    for(final int taskletId : taskletIds) {
      inputList.add(taskletIdInputMap.get(taskletId));
    }

    return inputList;
  }
10469
public List<FlowEvent> getFlowEvents(FlowKey flowKey) throws IOException {
    byte[] startKey =
        Bytes.add(flowKeyConverter.toBytes(flowKey), Constants.SEP_BYTES);
    Scan scan = new Scan(startKey);
    scan.setFilter(new WhileMatchFilter(new PrefixFilter(startKey)));

    List<FlowEvent> results = new ArrayList<FlowEvent>();
    ResultScanner scanner = null;
    Table eventTable = null;
    try {
      eventTable = hbaseConnection
          .getTable(TableName.valueOf(Constants.FLOW_EVENT_TABLE));
      scanner = eventTable.getScanner(scan);
      for (Result r : scanner) {
        FlowEvent event = createEventFromResult(r);
        if (event != null) {
          results.add(event);
        }
      }
    } finally {
      try {
        if (scanner != null) {
          scanner.close();
        }
      } finally {
        if (eventTable != null) {
          eventTable.close();
        }
      }
    }
    return results;
  }
344018
public ArrayList castToNumberList(ArrayList childNodeList) // was NumericValue
  {
    if (tc.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.entry(cclass, "castToNumberList", childNodeList);
 
    ArrayList numberList = new ArrayList();
    
    if(childNodeList != null)
    {
      Iterator iterNode = childNodeList.iterator();
      
      while(iterNode.hasNext())
      {
        String strValue = getStringFromNode(iterNode.next());
        
        // Cast the string to a Number
        Number num = EvaluatorImpl.castToNumber(strValue);
        if (tc.isAnyTracingEnabled() && tc.isDebugEnabled())
          tc.debug(cclass, "Add number to list: ", num);  
        numberList.add(num);
      }              
    }
    
    if (tc.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.exit(cclass, "castToNumberList", numberList);    
    return numberList;
  }
159815
private List<ParseTree> filterSpaceTokens(List<ParseTree> inputArrayList) {
        List<ParseTree> ret = new ArrayList<ParseTree>(inputArrayList.size());
        for (ParseTree item : inputArrayList) {
            if (!(item instanceof TerminalNode) || ((TerminalNodeImpl) item).getSymbol().getType() != CSSLexer.S) {
                ret.add(item);
            }
        }
        return ret;
    }
900890
public List<ExpressionMapping> getInputOnlyExpressionMappings() {
        List<ExpressionMapping> list = new LinkedList<ExpressionMapping>();
        for (ExpressionMapping em : _inputExpressionMappings) {
            if (em.getOutput() == null) {
                list.add(em);
            }
        }
        return list;
    }
734218
@Requires({
    "processingEnv != null",
    "element != null",
    "annotation != null"
  })
  @Ensures("result != null")
  public static List<Long> getLineNumbers(ProcessingEnvironment processingEnv,
      Element element, AnnotationMirror annotation) {
    Trees treeUtils = Trees.instance(processingEnv);
    if (treeUtils == null) {
      return Collections.emptyList();
    }

    TreePath path = treeUtils.getPath(element, annotation);
    if (path == null) {
      return Collections.emptyList();
    }

    CompilationUnitTree unitTree = path.getCompilationUnit();
    LineMap lineMap = unitTree.getLineMap();
    SourcePositions positions = treeUtils.getSourcePositions();

    AnnotationTree annotationTree = (AnnotationTree) path.getLeaf();
    AssignmentTree assignTree =
        (AssignmentTree) annotationTree.getArguments().get(0);
    ExpressionTree exprTree = assignTree.getExpression();

    ArrayList<Long> lines = new ArrayList<Long>();
    if (exprTree.getKind() == Kind.STRING_LITERAL) {
      long pos = positions.getStartPosition(unitTree, exprTree);
      lines.add(lineMap.getLineNumber(pos));
    } else {
      NewArrayTree valuesTree = (NewArrayTree) exprTree;
      for (ExpressionTree valueTree : valuesTree.getInitializers()) {
        long pos = positions.getStartPosition(unitTree, valueTree);
        lines.add(lineMap.getLineNumber(pos));
      }
    }

    return lines;
  }
791669
@SuppressWarnings({"rawtypes", "unchecked"})
    public static List getCloneList(List sourceList) {
        if (null == sourceList) {
            return null;
        }
        List targetList = new ArrayList();
        for (int i = 0; i < sourceList.size(); i++) {
            Object target = null;
            Object source = sourceList.get(i);
            try {
                Constructor con = source.getClass().getConstructor();
                target = con.newInstance();
                PropertyUtils.copyProperties(target, source);
            } catch (Exception e) {
                logger.error("clone object exception object class:" + source.getClass(), e);
            }
            targetList.add(target);
        }
        return targetList;
    }
194808
private Map<Optional<Executor>, List<ExecutableFlow>> getFlowToExecutorMap() {
    final HashMap<Optional<Executor>, List<ExecutableFlow>> exFlowMap =
        new HashMap<>();

    for (final Pair<ExecutionReference, ExecutableFlow> runningFlow : this.runningExecutions.get()
        .values()) {
      final ExecutionReference ref = runningFlow.getFirst();
      final ExecutableFlow flow = runningFlow.getSecond();
      final Optional<Executor> executor = ref.getExecutor();

      // We can set the next check time to prevent the checking of certain
      // flows.
      if (ref.getNextCheckTime() >= DateTime.now().getMillis()) {
        continue;
      }

      List<ExecutableFlow> flows = exFlowMap.get(executor);
      if (flows == null) {
        flows = new ArrayList<>();
        exFlowMap.put(executor, flows);
      }

      flows.add(flow);
    }

    return exFlowMap;
  }
315709
public List<FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>> getAllOutboundParameter()
   {
      List<FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>> list = new ArrayList<FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>>();
      List<Node> nodeList = childNode.get("outbound-parameter");
      for(Node node: nodeList)
      {
         FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>  type = new FacesConfigFlowDefinitionFlowCallOutboundParameterTypeImpl<FacesConfigFlowDefinitionFlowCallType<T>>(this, "outbound-parameter", childNode, node);
         list.add(type);
      }
      return list;
   }
1244383
@Override
	public Iterable<OptimizerNode> getPredecessors() {
		List<OptimizerNode> allPredecessors = new ArrayList<OptimizerNode>();

		for (DagConnection dagConnection : getIncomingConnections()) {
			allPredecessors.add(dagConnection.getSource());
		}
		
		for (DagConnection conn : getBroadcastConnections()) {
			allPredecessors.add(conn.getSource());
		}
		
		return allPredecessors;
	}
12563
public Map<ComponentJob, AnalyzerResult> getUnsafeResultElements() {
        if (_unsafeResultElements == null) {
            _unsafeResultElements = new LinkedHashMap<>();
            final Map<ComponentJob, AnalyzerResult> resultMap = _analysisResult.getResultMap();
            for (final Entry<ComponentJob, AnalyzerResult> entry : resultMap.entrySet()) {
                final AnalyzerResult analyzerResult = entry.getValue();
                try {
                    SerializationUtils.serialize(analyzerResult, new NullOutputStream());
                } catch (final SerializationException e) {
                    _unsafeResultElements.put(entry.getKey(), analyzerResult);
                }
            }
        }
        return _unsafeResultElements;
    }
262380
public <E> List<InlineDiffChunk<E>> inline(List<E> previous, List<E> next)
    {
        setError(null);

        try {
            return this.inlineDiffDisplayer.display(this.diffManager.diff(previous, next, null));
        } catch (DiffException e) {
            setError(e);
            return null;
        }
    }
789231
public <T> Collection<T> startWorking(Callable<T>[] callables) 
	 {
		    List<Future<T>> list = new ArrayList<Future<T>>();
		    
		    for (int i = 0; i < callables.length; i++) 
		    {
		    	list.add(executor.submit(callables[i]));
		    }
		    
		   
		    ArrayList<T> resultList = new ArrayList<T>(callables.length);
		    
		    // Now retrieve the result
		    T output;
		    for (Future<T> future : list) 
		    {
		      try 
		      {
		    	  output = future.get();
		    	  if(output != null)
		    		resultList.add(output);
		      } 
		      catch (InterruptedException e) 
		      {
		        throw new SystemException(e);
		      } 
		      catch (ExecutionException e) 
		      {
		    	  throw new SystemException(e);
		      }
		    }
		    
		     
		  return resultList;
	 }