<p>expressionsListToResolve.</p>

@return a {@link java.util.List} object.
18507
public List<String> expressionsListToResolve()
    {
        String[] parts = expression.trim().split( "\\s+" );
        List<String> expressionsList = new ArrayList<String>();

        withDots( expressionsList, parts );
        noDots( expressionsList, parts );
        asIs( expressionsList, parts );

        return expressionsList;
    }
324953
public String getList() {
    String result = "";
    int i = 1;

    for (String s : mReps.keySet()) {
      result += (i++) + ". key='" + s + "', value='" + mReps.get(s) + "'\n";
    }

    return result;
  }
335811
public List<T> values() {
        List<T> result = new ArrayList<T>();
        for (Iterator<T> itr = iterator(); itr.hasNext(); ) {
            result.add(itr.next());
        }
        return result;
    }
1220114
private List<Object> eval(Iterable<ExpressionContext> expressions) {

    List<Object> results = new ArrayList<Object>();

    for (ExpressionContext expression : expressions) {
      results.add(eval(expression));
    }

    return results;
  }
239346
public List<AbstractExpression> bindingToIndexedExpression(
            AbstractExpression expr) {
        // Defer the result construction for as long as possible on the
        // assumption that this function mostly gets applied to eliminate
        // negative cases.
        if (m_type != expr.m_type) {
            // The only allowed difference in expression types is between a
            // parameter and its original constant value.
            // That's handled in the independent override.
            return null;
        }

        // From here, this is much like the straight equality check,
        // except that this function and "equals" must each call themselves
        // in their recursions.

        // Delegating to this factored-out component of the "equals"
        // implementation eases simultaneous refinement of both methods.
        if ( ! hasEqualAttributes(expr)) {
            return null;
        }
        // The derived classes have verified that any added attributes
        // are identical.

        // Check that the presence, or lack, of children is the same
        if ((expr.m_left == null) != (m_left == null)) {
            return null;
        }
        if ((expr.m_right == null) != (m_right == null)) {
            return null;
        }
        if ((expr.m_args == null) != (m_args == null)) {
            return null;
        }

        // Check that the children identify themselves as matching
        List<AbstractExpression> leftBindings = null;
        if (m_left != null) {
            leftBindings = m_left.bindingToIndexedExpression(expr.m_left);
            if (leftBindings == null) {
                return null;
            }
        }
        List<AbstractExpression> rightBindings = null;
        if (m_right != null) {
            rightBindings = m_right.bindingToIndexedExpression(expr.m_right);
            if (rightBindings == null) {
                return null;
            }
        }
        List<AbstractExpression> argBindings = null;
        if (m_args != null) {
            if (m_args.size() != expr.m_args.size()) {
                return null;
            }
            argBindings = new ArrayList<>();
            int ii = 0;
            // iterate the args lists in parallel, binding pairwise
            for (AbstractExpression rhs : expr.m_args) {
                AbstractExpression lhs = m_args.get(ii++);
                List<AbstractExpression> moreBindings =
                        lhs.bindingToIndexedExpression(rhs);
                if (moreBindings == null) { // fail on any non-match
                    return null;
                }
                argBindings.addAll(moreBindings);
            }
        }

        // It's a match, so gather up the details.
        // It's rare (if even possible) for the same bound parameter to get
        // listed twice, so don't worry about duplicate entries, here.
        // That should not cause any issue for the caller.
        List<AbstractExpression> result = new ArrayList<>();
        if (leftBindings != null) { // null here can only mean no left child
            result.addAll(leftBindings);
        }
        if (rightBindings != null) { // null here can only mean no right child
            result.addAll(rightBindings);
        }
        if (argBindings != null) { // null here can only mean no args
            result.addAll(argBindings);
        }
        return result;
    }
382312
public List<S> execute(List<S> solutionList) throws JMetalException {
    if (null == solutionList) {
      throw new JMetalException("The solution list is null");
    } else if (solutionList.isEmpty()) {
        throw new JMetalException("The solution list is empty") ;
    }  else if (solutionList.size() < solutionsToSelect) {
      throw new JMetalException("The population size ("+solutionList.size()+") is smaller than" +
              "the solutions to selected ("+solutionsToSelect+")")  ;
    }

    Ranking<S> ranking = new DominanceRanking<S>(dominanceComparator);
    ranking.computeRanking(solutionList) ;

    return crowdingDistanceSelection(ranking);
  }
406371
public java.util.List<CustomKeyStoresListEntry> getCustomKeyStores() {
        if (customKeyStores == null) {
            customKeyStores = new com.amazonaws.internal.SdkInternalList<CustomKeyStoresListEntry>();
        }
        return customKeyStores;
    }
908232
public java.util.List<Location> getLocations() {
        if (locations == null) {
            locations = new com.amazonaws.internal.SdkInternalList<Location>();
        }
        return locations;
    }
1113052
public List<String> listEscapeJava(final List<?> target) {
        if (target == null) {
            return null;
        }
        final List<String> result = new ArrayList<String>(target.size() + 2);
        for (final Object element : target) {
            result.add(escapeJava(element));
        }
        return result;
    }
1105179
@Override public Double evaluate(Evaluate solutionList) {
    if (solutionList == null) {
      throw new JMetalException("The solution list is null") ;
    }
    return er(new ArrayFront(solutionList), referenceParetoFront);
  }
1215050
public List<T> getEntireList() {
		InnerList iList = ref.get();
		return iList != null ? iList.getList() : null;
	}
601603
public <T> List<T> asList() {
		String cacheKey = null;
		
		// is the result of the query cached?
		if (isCacheable() && transaction == null) {
			cacheKey = getCacheKey();
			List<Key> keys = getCacheManager().get(cacheNamespace, cacheKey);
			if (keys != null) {
				if (isKeysOnly()) {
					return (List) keys;
				} else {
					final Map<Key, T> values = entityManager.get(keys);
					return Lists.transform(keys, new Function<Key, T>() {

						@Override
						public T apply(Key key) {
							return values.get(key);
						}
						
					});
				}
			}
		}
		
		// execute the query
		List<T> result = Lists.newArrayList((Iterable<T>) asIterable());
		if (isCacheable()) {
			Collection<Key> keys = isKeysOnly()? result : Collections2.transform(result, new EntityToKeyFunction(classMetadata.getPersistentClass()));
			populateCache(cacheKey, Lists.newArrayList(keys));
		}
		return result;
	}
586157
public final hqlParser.exprList_return exprList() throws RecognitionException {
		hqlParser.exprList_return retval = new hqlParser.exprList_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token f=null;
		Token f2=null;
		Token TRAILING287=null;
		Token LEADING288=null;
		Token BOTH289=null;
		Token COMMA291=null;
		Token AS294=null;
		ParserRuleReturnScope expression290 =null;
		ParserRuleReturnScope expression292 =null;
		ParserRuleReturnScope expression293 =null;
		ParserRuleReturnScope identifier295 =null;
		ParserRuleReturnScope expression296 =null;

		CommonTree f_tree=null;
		CommonTree f2_tree=null;
		CommonTree TRAILING287_tree=null;
		CommonTree LEADING288_tree=null;
		CommonTree BOTH289_tree=null;
		CommonTree COMMA291_tree=null;
		CommonTree AS294_tree=null;

		try {
			// hql.g:669:2: ( ( TRAILING | LEADING | BOTH )? ( expression ( ( COMMA ! expression )+ |f= FROM expression | AS ! identifier )? |f2= FROM expression )? )
			// hql.g:669:4: ( TRAILING | LEADING | BOTH )? ( expression ( ( COMMA ! expression )+ |f= FROM expression | AS ! identifier )? |f2= FROM expression )?
			{
			root_0 = (CommonTree)adaptor.nil();


			// hql.g:669:4: ( TRAILING | LEADING | BOTH )?
			int alt103=4;
			switch ( input.LA(1) ) {
				case TRAILING:
					{
					alt103=1;
					}
					break;
				case LEADING:
					{
					alt103=2;
					}
					break;
				case BOTH:
					{
					alt103=3;
					}
					break;
			}
			switch (alt103) {
				case 1 :
					// hql.g:669:5: TRAILING
					{
					TRAILING287=(Token)match(input,TRAILING,FOLLOW_TRAILING_in_exprList3375);
					TRAILING287_tree = (CommonTree)adaptor.create(TRAILING287);
					adaptor.addChild(root_0, TRAILING287_tree);

					TRAILING287.setType( IDENT );
					}
					break;
				case 2 :
					// hql.g:670:10: LEADING
					{
					LEADING288=(Token)match(input,LEADING,FOLLOW_LEADING_in_exprList3388);
					LEADING288_tree = (CommonTree)adaptor.create(LEADING288);
					adaptor.addChild(root_0, LEADING288_tree);

					LEADING288.setType( IDENT );
					}
					break;
				case 3 :
					// hql.g:671:10: BOTH
					{
					BOTH289=(Token)match(input,BOTH,FOLLOW_BOTH_in_exprList3401);
					BOTH289_tree = (CommonTree)adaptor.create(BOTH289);
					adaptor.addChild(root_0, BOTH289_tree);

					BOTH289.setType( IDENT );
					}
					break;

			}

			// hql.g:673:4: ( expression ( ( COMMA ! expression )+ |f= FROM expression | AS ! identifier )? |f2= FROM expression )?
			int alt106=3;
			int LA106_0 = input.LA(1);
			if ( (LA106_0==ALL||LA106_0==ANY||LA106_0==AVG||LA106_0==BNOT||LA106_0==CASE||LA106_0==COLON||LA106_0==COUNT||LA106_0==ELEMENTS||LA106_0==EMPTY||LA106_0==EXISTS||LA106_0==FALSE||LA106_0==IDENT||LA106_0==INDICES||LA106_0==MAX||(LA106_0 >= MIN && LA106_0 <= MINUS)||LA106_0==NOT||(LA106_0 >= NULL && LA106_0 <= NUM_LONG)||LA106_0==OPEN||(LA106_0 >= PARAM && LA106_0 <= PLUS)||LA106_0==QUOTED_String||LA106_0==SOME||LA106_0==SUM||LA106_0==TRUE) ) {
				alt106=1;
			}
			else if ( (LA106_0==FROM) ) {
				alt106=2;
			}
			switch (alt106) {
				case 1 :
					// hql.g:674:5: expression ( ( COMMA ! expression )+ |f= FROM expression | AS ! identifier )?
					{
					pushFollow(FOLLOW_expression_in_exprList3425);
					expression290=expression();
					state._fsp--;

					adaptor.addChild(root_0, expression290.getTree());

					// hql.g:674:16: ( ( COMMA ! expression )+ |f= FROM expression | AS ! identifier )?
					int alt105=4;
					switch ( input.LA(1) ) {
						case COMMA:
							{
							alt105=1;
							}
							break;
						case FROM:
							{
							alt105=2;
							}
							break;
						case AS:
							{
							alt105=3;
							}
							break;
					}
					switch (alt105) {
						case 1 :
							// hql.g:674:18: ( COMMA ! expression )+
							{
							// hql.g:674:18: ( COMMA ! expression )+
							int cnt104=0;
							loop104:
							while (true) {
								int alt104=2;
								int LA104_0 = input.LA(1);
								if ( (LA104_0==COMMA) ) {
									alt104=1;
								}

								switch (alt104) {
								case 1 :
									// hql.g:674:19: COMMA ! expression
									{
									COMMA291=(Token)match(input,COMMA,FOLLOW_COMMA_in_exprList3430);
									pushFollow(FOLLOW_expression_in_exprList3433);
									expression292=expression();
									state._fsp--;

									adaptor.addChild(root_0, expression292.getTree());

									}
									break;

								default :
									if ( cnt104 >= 1 ) break loop104;
									EarlyExitException eee = new EarlyExitException(104, input);
									throw eee;
								}
								cnt104++;
							}

							}
							break;
						case 2 :
							// hql.g:675:9: f= FROM expression
							{
							f=(Token)match(input,FROM,FOLLOW_FROM_in_exprList3448);
							f_tree = (CommonTree)adaptor.create(f);
							adaptor.addChild(root_0, f_tree);

							pushFollow(FOLLOW_expression_in_exprList3450);
							expression293=expression();
							state._fsp--;

							adaptor.addChild(root_0, expression293.getTree());

							f.setType( IDENT );
							}
							break;
						case 3 :
							// hql.g:676:9: AS ! identifier
							{
							AS294=(Token)match(input,AS,FOLLOW_AS_in_exprList3462);
							pushFollow(FOLLOW_identifier_in_exprList3465);
							identifier295=identifier();
							state._fsp--;

							adaptor.addChild(root_0, identifier295.getTree());

							}
							break;

					}

					}
					break;
				case 2 :
					// hql.g:677:7: f2= FROM expression
					{
					f2=(Token)match(input,FROM,FOLLOW_FROM_in_exprList3479);
					f2_tree = (CommonTree)adaptor.create(f2);
					adaptor.addChild(root_0, f2_tree);

					pushFollow(FOLLOW_expression_in_exprList3481);
					expression296=expression();
					state._fsp--;

					adaptor.addChild(root_0, expression296.getTree());

					f2.setType( IDENT );
					}
					break;

			}

			}

			retval.stop = input.LT(-1);

			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);


			    assert false : "PLEASE CHECK THAT IT WORKS !!!";
			    CommonTree root = (CommonTree) adaptor.create( EXPR_LIST, "exprList" );
			    root.addChild( retval.getTree() );
			    retval.tree = root ;
			   //IASTNode root = (IASTNode) adaptor.Create(EXPR_LIST, "exprList");
			   //root.AddChild((IASTNode)retval.Tree);
			   //retval.Tree = root;

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
773917
List<? extends E> list() {
		List<E> result = new ArrayList<E>();
		while (hasNext()) {
			result.add(next());
		}
		return result;
	}
1005807
public final java.util.List<String> expressionList() throws RecognitionException {
		java.util.List<String> exprs = null;


		ParserRuleReturnScope f =null;
		ParserRuleReturnScope s =null;

		 exprs = new java.util.ArrayList<String>();
		try {
			// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:680:3: (f= expression ( COMMA s= expression )* )
			// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:680:7: f= expression ( COMMA s= expression )*
			{
			pushFollow(FOLLOW_expression_in_expressionList4122);
			f=expression();
			state._fsp--;
			if (state.failed) return exprs;
			if ( state.backtracking==0 ) { exprs.add( (f!=null?input.toString(f.start,f.stop):null) ); }
			// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:681:7: ( COMMA s= expression )*
			loop88:
			while (true) {
				int alt88=2;
				int LA88_0 = input.LA(1);
				if ( (LA88_0==COMMA) ) {
					alt88=1;
				}

				switch (alt88) {
				case 1 :
					// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:681:8: COMMA s= expression
					{
					match(input,COMMA,FOLLOW_COMMA_in_expressionList4133); if (state.failed) return exprs;
					pushFollow(FOLLOW_expression_in_expressionList4137);
					s=expression();
					state._fsp--;
					if (state.failed) return exprs;
					if ( state.backtracking==0 ) { exprs.add( (s!=null?input.toString(s.start,s.stop):null) ); }
					}
					break;

				default :
					break loop88;
				}
			}

			}

		}

		catch (RecognitionException re) {
		    throw re;
		}

		finally {
			// do for sure before leaving
		}
		return exprs;
	}
674396
List<JCExpressionStatement> forUpdate() {
        return moreStatementExpressions(token.pos,
                                        parseExpression(),
                                        new ListBuffer<JCExpressionStatement>()).toList();
    }
502405
@Override
    public List<T> getList() {
        if (isCacheEnabled) {
            if (cachedResult == null) {
                cachedResult = makeUnmodifiableUniqueList();
            }
            return cachedResult;
        } else {
            return makeUnmodifiableUniqueList();
        }
    }