Returns an Expression of a non-null {@link SoyValueProvider} providing this value.
978215
public Expression boxAsSoyValueProvider() {
    if (soyType().equals(NullType.getInstance())) {
      if (delegate == NULL || delegate == NULL_BOXED) {
        return FieldRef.NULL_PROVIDER.accessor();
      }
      // otherwise this expression might have side effects,  evaluate it as a statement then return
      // the NULL_PROVIDER
      return toStatement().then(FieldRef.NULL_PROVIDER.accessor());
    }
    if (delegate.isNonNullable()) {
      // Every SoyValue is-a SoyValueProvider, so if it is non-null
      return box();
    }
    if (isBoxed()) {
      return new Expression(
          BytecodeUtils.SOY_VALUE_PROVIDER_TYPE, delegate.features().plus(Feature.NON_NULLABLE)) {
        @Override
        protected void doGen(CodeBuilder adapter) {
          Label end = new Label();
          delegate.gen(adapter);
          adapter.dup();
          adapter.ifNonNull(end);
          adapter.pop();
          FieldRef.NULL_PROVIDER.accessStaticUnchecked(adapter);
          adapter.mark(end);
        }
      };
    }
    return new Expression(
        BytecodeUtils.SOY_VALUE_PROVIDER_TYPE, delegate.features().plus(Feature.NON_NULLABLE)) {
      @Override
      protected void doGen(CodeBuilder adapter) {
        Label end = new Label();
        delegate.gen(adapter);
        adapter.dup();
        Label nonNull = new Label();
        adapter.ifNonNull(nonNull);
        adapter.pop(); // pop the null value and replace with the nullprovider
        FieldRef.NULL_PROVIDER.accessStaticUnchecked(adapter);
        adapter.goTo(end);
        adapter.mark(nonNull);
        doBox(adapter, soyRuntimeType);
        adapter.mark(end);
      }
    };
  }
1185517
public javax.el.ValueExpression getAlpha() {
		return (javax.el.ValueExpression) getStateHelper().eval(PropertyKeys.alpha);
	}
1229573
public StringExpression stringValue() {
        if (stringCast == null) {
            stringCast = Expressions.stringOperation(Ops.STRING_CAST, mixin);
        }
        return stringCast;
    }
128166
@NonNull
    public ArrayExpressionSatisfies in(@NonNull Expression expression) {
        if (expression == null) {
            throw new IllegalArgumentException("expression cannot be null.");
        }
        return new ArrayExpressionSatisfies(type, variable, expression);
    }
423313
final public Expression ValuePrefix() throws ParseException {
  Expression ret;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case INTEGER_LITERAL:
    case FLOATING_POINT_LITERAL:
    case STRING_LITERAL:
    case TRUE:
    case FALSE:
    case NULL:
      ret = Literal();
      break;
    case LPAREN:
      jj_consume_token(LPAREN);
      ret = Expression();
      jj_consume_token(RPAREN);
      break;
    default:
      jj_la1[27] = jj_gen;
      if (jj_2_1(2147483647)) {
        ret = FunctionInvocation();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case IDENTIFIER:
          ret = NamedValue();
          break;
        default:
          jj_la1[28] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    }
      {if (true) return ret;}
    throw new Error("Missing return statement in function");
  }
544617
protected String getRowHeaderValueAsString(final FacesContext context) {
        final ValueExpression veRowHeader = getRowHeaderValueExpression();
        final Object value = veRowHeader.getValue(context.getELContext());
        if (value == null) {
            return Constants.EMPTY_STRING;
        }
        else {
            return value.toString();
        }
    }
1203070
public final Optional<Expression> getSoyTypeAssertion(
      Expression value, String valueName, Generator codeGenerator) {
    Optional<Expression> typeAssertion = getTypeAssertion(value, codeGenerator);
    if (!typeAssertion.isPresent()) {
      return Optional.absent();
    }

    return Optional.of(
        SOY_ASSERTS_ASSERT_TYPE.call(
            typeAssertion.get(), stringLiteral(valueName), value, stringLiteral(typeExpr())));
  }
356149
private SoyValueProvider lazyEval(final ExprNode expr, final SoyNode node) {
    return new SoyAbstractCachingValueProvider() {
      @Override
      protected SoyValue compute() {
        return eval(expr, node);
      }

      @Override
      public RenderResult status() {
        return RenderResult.done();
      }
    };
  }
616686
public Class getType(FacesContext context) throws EvaluationException,
            PropertyNotFoundException {
            
        if (context == null) {
	        throw new NullPointerException("FacesContext -> null");
        }
        Class result = null;
        try {
            result = valueExpression.getType(context.getELContext());
        } catch (javax.el.PropertyNotFoundException pnfe) {
            throw new PropertyNotFoundException(pnfe);
        } catch (ELException elex) {
            throw new EvaluationException(elex);
        } 
        return result;
    }
305701
public Expression getFromExpression() {
        if (_fromExpression == null && _from != null) {
            _fromExpression = ExpressionFactory.INSTANCE.create(_from, null, _propertyResolver);
        }
        return _fromExpression;
    }
1358582
private ExpressionEvaluator getExpressionEvaluator()
    {
        if (ee == null)
            ee = ExpressionEvaluatorFactory.getInstance();

        assert(ee != null);
        return ee;
    }
1278699
@Nonnull
  public static Value evalExpression(@Nonnull final String expression, @Nonnull final PreprocessorContext context) {
    try {
      final ExpressionTree tree = ExpressionParser.getInstance().parse(expression, context);
      return evalTree(tree, context);
    } catch (IOException unexpected) {
      throw context.makeException("[Expression]Wrong expression format detected [" + expression + ']', unexpected);
    }
  }
523107
@Override
    public <Y> Expression<Y> nullif(Expression<Y> arg0, Expression<?> arg1)
    {
        // TODO Auto-generated method stub
        return null;
    }
263473
@Override
  @Nonnull
  protected final SoyValue compute() {
    try {
      if (!future.isDone()) {
        futureBlockCallback.get().beforeBlock();
      }
      return SoyValueConverter.INSTANCE.convert(future.get()).resolve();
    } catch (ExecutionException e) {
      throw new SoyFutureException(e.getCause());
    } catch (Throwable e) {
      throw new SoyFutureException(e);
    }
  }
129481
protected String putExpressionAttributeValue(AttributeValue expressionAttributeValue) {
        String expressionAttributeValueKey = getExpressionAttributeValuePrefix() + expressionAttributeValueCounter++;

        expressionAttributeValues.put(expressionAttributeValueKey, expressionAttributeValue);

        return expressionAttributeValueKey;
    }
293494
final public ReturnExpressionBuilder<T> returnExp() {
    final int sourceLineNumber = builder.getSourceLineNumber();
    return new ReturnExpressionBuilder<T>(new ExpressionHandler<T>() {
      public T handleExpression(Expression e) {
        return statementHandler().handleStatement(new ReturnStatement(sourceLineNumber, e));
      }
    });
  }
46688
private SoyValue visitNullSafeNode(ExprNode node) {
    SoyValue value = visitNullSafeNodeRecurse(node);
    // Transform null sentinel into a normal null value.
    if (value == NullSafetySentinel.INSTANCE) {
      return NullData.INSTANCE;
    }
    return value;
  }