/** * Specify a default root object to resolve against. * <p>Default is none, expecting an object argument at evaluation time. * @see org.springframework.expression.Expression#getValue(EvaluationContext) * @see org.springframework.expression.Expression#getValue(EvaluationContext, Object) */ public Builder withRootObject(Object rootObject) { this.rootObject = new TypedValue(rootObject); return this; }
public IntLiteral(String payload, int startPos, int endPos, int value) { super(payload, startPos, endPos); this.value = new TypedValue(value); this.exitTypeDescriptor = "I"; }
public RealLiteral(String payload, int startPos, int endPos, double value) { super(payload, startPos, endPos); this.value = new TypedValue(value); this.exitTypeDescriptor = "D"; }
public FloatLiteral(String payload, int startPos, int endPos, float value) { super(payload, startPos, endPos); this.value = new TypedValue(value); this.exitTypeDescriptor = "F"; }
/** * Access the given target object by resolving the given property name against the given target * environment. */ @Override public TypedValue read(EvaluationContext context, @Nullable Object target, String name) throws AccessException { Assert.state(target instanceof Environment, "Target must be of type Environment"); return new TypedValue(((Environment) target).getProperty(name)); }
@Override public TypedValue read(EvaluationContext context, @Nullable Object target, String name) throws AccessException { Assert.state(target instanceof BeanFactory, "Target must be of type BeanFactory"); return new TypedValue(((BeanFactory) target).getBean(name)); }
@Override public TypedValue read(EvaluationContext context, @Nullable Object target, String name) throws AccessException { Assert.state(target instanceof BeanExpressionContext, "Target must be of type BeanExpressionContext"); return new TypedValue(((BeanExpressionContext) target).getObject(name)); }
@Override public TypedValue getValue() { Object arrayElement = accessArrayElement(this.array, this.index); return new TypedValue(arrayElement, this.typeDescriptor.elementTypeDescriptor(arrayElement)); }
@Override public TypedValue read(EvaluationContext context, @Nullable Object target, String name) throws AccessException { Object implicitVar = resolveImplicitVariable(name); if (implicitVar != null) { return new TypedValue(implicitVar); } return new TypedValue(this.pageContext.findAttribute(name)); }
@Override public TypedValue getValue() { if (this.index >= this.target.length()) { throw new SpelEvaluationException(getStartPosition(), SpelMessage.STRING_INDEX_OUT_OF_BOUNDS, this.target.length(), this.index); } return new TypedValue(String.valueOf(this.target.charAt(this.index))); }
@Override @Nullable public <T> T getValue(@Nullable Class<T> expectedResultType) throws EvaluationException { Object value = getValue(); return ExpressionUtils.convertTypedValue(null, new TypedValue(value), expectedResultType); }
@Override @Nullable public <T> T getValue(Object rootObject, @Nullable Class<T> desiredResultType) throws EvaluationException { Object value = getValue(rootObject); return ExpressionUtils.convertTypedValue(null, new TypedValue(value), desiredResultType); }
@Override @Nullable public <T> T getValue(Object rootObject, @Nullable Class<T> desiredResultType) throws EvaluationException { Object value = getValue(rootObject); return ExpressionUtils.convertTypedValue(null, new TypedValue(value), desiredResultType); }
@Override @Nullable public <T> T getValue(EvaluationContext context, @Nullable Class<T> expectedResultType) throws EvaluationException { Object value = getValue(context); return ExpressionUtils.convertTypedValue(context, new TypedValue(value), expectedResultType); }
@Override @Nullable public <T> T getValue(EvaluationContext context, Object rootObject, @Nullable Class<T> desiredResultType) throws EvaluationException { Object value = getValue(context,rootObject); return ExpressionUtils.convertTypedValue(context, new TypedValue(value), desiredResultType); }
public StringLiteral(String payload, int startPos, int endPos, String value) { super(payload, startPos, endPos); String valueWithinQuotes = value.substring(1, value.length() - 1); valueWithinQuotes = StringUtils.replace(valueWithinQuotes, "''", "'"); valueWithinQuotes = StringUtils.replace(valueWithinQuotes, "\"\"", "\""); this.value = new TypedValue(valueWithinQuotes); this.exitTypeDescriptor = "Ljava/lang/String"; }
public TypedValue operate(Operation op, @Nullable Object left, @Nullable Object right) throws EvaluationException { OperatorOverloader overloader = this.relatedContext.getOperatorOverloader(); if (overloader.overridesOperation(op, left, right)) { Object returnValue = overloader.operate(op, left, right); return new TypedValue(returnValue); } else { String leftType = (left == null ? "null" : left.getClass().getName()); String rightType = (right == null? "null" : right.getClass().getName()); throw new SpelEvaluationException(SpelMessage.OPERATOR_NOT_SUPPORTED_BETWEEN_TYPES, op, leftType, rightType); } }
@Override public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException { if (!name.equals("flibbles")) { throw new RuntimeException("Assertion Failed! name should be flibbles"); } return new TypedValue(flibbles); }
@Override public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException { Map<?,?> map = (Map<?,?>) target; Object value = map.get(name); if (value == null && !map.containsKey(name)) { throw new MapAccessException(name); } return new TypedValue(value); }
@Test public void testRootObjectConstructor() { EvaluationContext ctx = getContext(); // TypedValue root = ctx.getRootObject(); // supplied should override root on context ExpressionState state = new ExpressionState(ctx,new TypedValue("i am a string")); TypedValue stateRoot = state.getRootContextObject(); assertEquals(String.class, stateRoot.getTypeDescriptor().getType()); assertEquals("i am a string", stateRoot.getValue()); }