Append a media expression to the list.

@param aMediaExpression
The media expression to be added. May not be <code>null</code>.
@return this
961343
@Nonnull
  public CSSMediaQuery addMediaExpression (@Nonnull final CSSMediaExpression aMediaExpression)
  {
    ValueEnforcer.notNull (aMediaExpression, "MediaExpression");

    m_aMediaExpressions.add (aMediaExpression);
    return this;
  }
1373840
public static Expression createExpressionForField(FieldExtension fieldExtension) {
        if (StringUtils.isNotEmpty(fieldExtension.getExpression())) {
            ExpressionManager expressionManager = Context.getProcessEngineConfiguration().getExpressionManager();
            return expressionManager.createExpression(fieldExtension.getExpression());
        } else {
            return new FixedValue(fieldExtension.getStringValue());
        }
    }
353568
AppendableExpression setSanitizedContentDirectionality(Dir contentDir) {
    return withNewDelegate(
        delegate.invoke(SET_SANITIZED_CONTENT_DIRECTIONALITY, BytecodeUtils.constant(contentDir)),
        true);
  }
621203
public static String embed(final String expression, final char trigger) {
        return new StringBuilder().append(trigger).append('{').append(strip(expression)).append('}').toString();
    }
839991
private ExpressionStatement createAddSuppressedStatement(String primaryExcName, String suppressedExcName) {
        MethodCallExpression addSuppressedMethodCallExpression =
                new MethodCallExpression(
                        new VariableExpression(primaryExcName),
                        "addSuppressed",
                        new ArgumentListExpression(Collections.singletonList(new VariableExpression(suppressedExcName))));
        addSuppressedMethodCallExpression.setImplicitThis(false);
        addSuppressedMethodCallExpression.setSafe(true);

        return new ExpressionStatement(addSuppressedMethodCallExpression);
    }
731786
public static Expression arrayPrepend(String expression, Expression value) {
        return arrayPrepend(x(expression), value);
    }
276855
final public AstCompositeExpression CompositeExpression() throws ParseException {
                                                                     /*@bgen(jjtree) CompositeExpression */
  AstCompositeExpression jjtn000 = new AstCompositeExpression(JJTCOMPOSITEEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_1:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LITERAL_EXPRESSION:
        case START_DYNAMIC_EXPRESSION:
        case START_DEFERRED_EXPRESSION:
          ;
          break;
        default:
          jj_la1[0] = jj_gen;
          break label_1;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case START_DEFERRED_EXPRESSION:
          DeferredExpression();
          break;
        case START_DYNAMIC_EXPRESSION:
          DynamicExpression();
          break;
        case LITERAL_EXPRESSION:
          LiteralExpression();
          break;
        default:
          jj_la1[1] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jj_consume_token(0);
                                   jjtree.closeNodeScope(jjtn000, true);
                                   jjtc000 = false;
                                   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
    throw new Error("Missing return statement in function");
  }
285669
AppendableExpression appendChar(Expression exp) {
    return withNewDelegate(delegate.invoke(APPEND_CHAR, exp), true);
  }
332619
function(){
                /*
                 * media_query
                 *   : [ONLY | NOT]? S* media_type S* [ AND S* expression ]*
                 *   | expression [ AND S* expression ]*
                 *   ;
                 */
                var tokenStream = this._tokenStream,
                    type        = null,
                    ident       = null,
                    token       = null,
                    expressions = [];
                if (tokenStream.match(Tokens.IDENT)){
                    ident = tokenStream.token().value.toLowerCase();

                    //since there's no custom tokens for these, need to manually check
                    if (ident !== "only" && ident !== "not"){
                        tokenStream.unget();
                        ident = null;
                    } else {
                        token = tokenStream.token();
                    }
                }
               
                this._readWhitespace();

                if (tokenStream.peek() === Tokens.IDENT){
                    type = this._media_type();
                    if (token === null){
                        token = tokenStream.token();
                    }
                } else if (tokenStream.peek() === Tokens.LPAREN){
                    if (token === null){
                        token = tokenStream.LT(1);
                    }
                    expressions.push(this._media_expression());
                }

                if (type === null && expressions.length === 0){
                    return null;
                } else {
                    this._readWhitespace();
                    while (tokenStream.match(Tokens.IDENT)){
                        if (tokenStream.token().value.toLowerCase() !== "and"){
                            this._unexpectedToken(tokenStream.token());
                        }
                        this._readWhitespace();
                        expressions.push(this._media_expression());
                    }
                }
                return new MediaQuery(ident, type, expressions, token.startLine, token.startCol);
            }
560978
@Override
  protected void pushExpression( Expression e )
  {
    assert e != null;
    maybeVerifyDoubleLiterals( e );
    _stack.push( e );
  }
1311971
public static <T> AppendingFactoryExpression<T> appending(Expression<T> base, Expression<?>... rest) {
        return new AppendingFactoryExpression<T>(base, rest);
    }
505672
public function addSelectExpression(string ...$expression) : self
    {
        $this->selectExpressions = array_merge($this->selectExpressions, $expression);

        return $this;
    }
285602
public void addUnionExpression(final INodeReadTrx mTransaction) {

        assert getPipeStack().size() >= 2;

        final AbsAxis mOperand2 = getPipeStack().pop().getExpr();
        final AbsAxis mOperand1 = getPipeStack().pop().getExpr();
        if (getPipeStack().empty() || getExpression().getSize() != 0) {
            addExpressionSingle();
        }
        getExpression().add(
            new DupFilterAxis(mTransaction, new UnionAxis(mTransaction, mOperand1, mOperand2)));
    }
325160
public static MaterialAddResult materialAdd(String accessToken,
                                                MediaType type, InputStream inputStream) {
        HttpPost httpPost = new HttpPost(BASE_URI + "/shakearound/material/add");
        byte[] data;
        try {
            data = StreamUtils.copyToByteArray(inputStream);
        } catch (IOException e) {
            logger.error("", e);
            throw new RuntimeException(e);
        }

        MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder
                .create().addBinaryBody("media", data, ContentType.DEFAULT_BINARY, "temp." + type.fileSuffix());
        HttpEntity reqEntity = multipartEntityBuilder
                .addTextBody(PARAM_ACCESS_TOKEN, API.accessToken(accessToken))
                .addTextBody("type", type.uploadType()).build();
        httpPost.setEntity(reqEntity);

        return LocalHttpClient.executeJsonResult(httpPost,
                MaterialAddResult.class);
    }
435834
public static Expression arrayPrepend(Expression expression, Expression value) {
        return x("ARRAY_PREPEND(" + value.toString() + ", " + expression.toString() + ")");
    }
1053938
@Nonnull
  public CSSDeclaration setExpression (@Nonnull final CSSExpression aExpression)
  {
    m_aExpression = ValueEnforcer.notNull (aExpression, "Expression");
    return this;
  }
89072
void maybeExposeExpression(Node expression) {
    // If the expression needs to exposed.
    int i = 0;
    while (DecompositionType.DECOMPOSABLE == canExposeExpression(expression)) {
      exposeExpression(expression);
      i++;
      if (i > MAX_ITERATIONS) {
        throw new IllegalStateException(
            "DecomposeExpression depth exceeded on:\n" + expression.toStringTree());
      }
    }
  }