Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 /* Generated By:JJTree: Do not edit this line. AstValue.java */
 
 package org.apache.el.parser;
 
 import static org.jboss.web.ELMessages.MESSAGES;
 
 
 

Author(s):
Jacob Hookom [jacob@hookom.net]
Version:
$Id: AstValue.java 2004 2012-03-26 14:37:14Z remy.maucherat@jboss.com $
 
 public final class AstValue extends SimpleNode {
 
     private static final boolean IS_SECURITY_ENABLED =
         (System.getSecurityManager() != null);
 
     protected static final boolean COERCE_TO_ZERO;
 
     static {
         if () {
              = AccessController.doPrivileged(
                     new PrivilegedAction<Boolean>(){
                         @Override
                         public Boolean run() {
                             return Boolean.valueOf(System.getProperty(
                                     "org.apache.el.parser.COERCE_TO_ZERO",
                                     "true"));
                         }
 
                     }
             ).booleanValue();
         } else {
              = Boolean.valueOf(System.getProperty(
                     "org.apache.el.parser.COERCE_TO_ZERO",
                     "true")).booleanValue();
         }
     }
 
     protected static class Target {
         protected Object base;
 
         protected Object property;
     }
 
     public AstValue(int id) {
         super(id);
     }
 
     @Override
     public Class<?> getType(EvaluationContext ctxthrows ELException {
         Target t = getTarget(ctx);
         ctx.setPropertyResolved(false);
         Class<?> result = ctx.getELResolver().getType(ctxt.baset.property);
         if (!ctx.isPropertyResolved()) {
             throw new PropertyNotFoundException(.errorResolving(t.baset.property));
         }
         return result;
     }
 
     private final Target getTarget(EvaluationContext ctxthrows ELException {
         // evaluate expr-a to value-a
         Object base = this.[0].getValue(ctx);
 
         // if our base is null (we know there are more properties to evaluate)
         if (base == null) {
             throw new PropertyNotFoundException(.errorResolvingIdentifierType(this.[0].getImage()));
         }
        // set up our start/end
        Object property = null;
        int propCount = this.jjtGetNumChildren();
        if (propCount > 2 &&
                this.jjtGetChild(propCount - 1) instanceof AstMethodParameters) {
            // Method call with paramaters.
            propCount-=2;
        } else {
            propCount--;
        }
        int i = 1;
        // evaluate any properties before our target
        ELResolver resolver = ctx.getELResolver();
        if (propCount > 1) {
            while (base != null && i < propCount) {
                property = this.[i].getValue(ctx);
                ctx.setPropertyResolved(false);
                base = resolver.getValue(ctxbaseproperty);
                i++;
            }
            // if we are in this block, we have more properties to resolve,
            // but our base was null
            if (base == null || property == null) {
                throw new PropertyNotFoundException(.errorResolvingProperty(property));
            }
        }
        property = this.[i].getValue(ctx);
        if (property == null) {
            throw new PropertyNotFoundException(.errorResolvingProperty(this.[i]));
        }
        Target t = new Target();
        t.base = base;
        t.property = property;
        return t;
    }
    @Override
    public Object getValue(EvaluationContext ctxthrows ELException {
        Object base = this.[0].getValue(ctx);
        int propCount = this.jjtGetNumChildren();
        int i = 1;
        Object suffix = null;
        ELResolver resolver = ctx.getELResolver();
        while (base != null && i < propCount) {
            suffix = this.[i].getValue(ctx);
            if (i + 1 < propCount &&
                    (this.[i+1] instanceof AstMethodParameters)) {
                AstMethodParameters mps =
                    (AstMethodParametersthis.[i+1];
                // This is a method
                base = resolver.invoke(ctxbasesuffixnull,
                        mps.getParameters(ctx));
                i+=2;
            } else {
                // This is a property
                if (suffix == null) {
                    return null;
                }
                ctx.setPropertyResolved(false);
                base = resolver.getValue(ctxbasesuffix);
                i++;
            }
        }
        if (!ctx.isPropertyResolved()) {
            throw new PropertyNotFoundException(.errorResolving(basesuffix));
        }
        return base;
    }
    @Override
    public boolean isReadOnly(EvaluationContext ctxthrows ELException {
        Target t = getTarget(ctx);
        ctx.setPropertyResolved(false);
        boolean result =
            ctx.getELResolver().isReadOnly(ctxt.baset.property);
        if (!ctx.isPropertyResolved()) {
            throw new PropertyNotFoundException(.errorResolving(t.baset.property));
        }
        return result;
    }
    @Override
    public void setValue(EvaluationContext ctxObject value)
            throws ELException {
        Target t = getTarget(ctx);
        ctx.setPropertyResolved(false);
        ELResolver resolver = ctx.getELResolver();
        // coerce to the expected type
        Class<?> targetClass = resolver.getType(ctxt.baset.property);
        if ( == true
                || !isAssignable(valuetargetClass)) {
            resolver.setValue(ctxt.baset.property,
                    ELSupport.coerceToType(valuetargetClass));
        } else {
            resolver.setValue(ctxt.baset.propertyvalue);
        }
        if (!ctx.isPropertyResolved()) {
            throw new PropertyNotFoundException(.errorResolving(t.baset.property));
        }
    }
    private boolean isAssignable(Object valueClass<?> targetClass) {
        if (targetClass == null) {
            return false;
        } else if (value != null && targetClass.isPrimitive()) {
            return false;
        } else if (value != null && !targetClass.isInstance(value)) {
            return false;
        }
        return true;
    }
    @Override
    // Interface el.parser.Node uses raw types (and is auto-generated)
            @SuppressWarnings("rawtypes"Class[] paramTypes)
            throws ELException {
        Target t = getTarget(ctx);
        Method m = ReflectionUtil.getMethod(
                t.baset.propertyparamTypesnull);
        return new MethodInfo(m.getName(), m.getReturnType(), m
                .getParameterTypes());
    }
    @Override
    // Interface el.parser.Node uses a raw type (and is auto-generated)
    public Object invoke(EvaluationContext ctx,
            @SuppressWarnings("rawtypes"Class[] paramTypes,
            Object[] paramValuesthrows ELException {
        Target t = getTarget(ctx);
        Method m = null;
        Object[] values = null;
        Class<?>[] types = null;
        if (isParametersProvided()) {
            values = ((AstMethodParametersthis.jjtGetChild(
                    this.jjtGetNumChildren() - 1)).getParameters(ctx);
            types = getTypesFromValues(values);
        } else {
            values = paramValues;
            types = paramTypes;
        }
        m = ReflectionUtil.getMethod(t.baset.propertytypesvalues);
        // Handle varArgs and any co-ercion required
        values = convertArgs(valuesm);
        Object result = null;
        try {
            result = m.invoke(t.basevalues);
        } catch (IllegalAccessException iae) {
            throw new ELException(iae);
        } catch (IllegalArgumentException iae) {
            throw new ELException(iae);
        } catch (InvocationTargetException ite) {
            Throwable cause = ite.getCause();
            if (cause instanceof ThreadDeath) {
                throw (ThreadDeathcause;
            }
            if (cause instanceof VirtualMachineError) {
                throw (VirtualMachineErrorcause;
            }
            throw new ELException(cause);
        }
        return result;
    }
    private Object[] convertArgs(Object[] srcMethod m) {
        Class<?>[] types = m.getParameterTypes();
        if (types.length == 0) {
            return new Object[0];
        }
        int paramCount = types.length;
        Object[] dest = new Object[paramCount];
        for (int i = 0; i < paramCount - 1; i++) {
            dest[i] = ELSupport.coerceToType(src[i], types[i]);
        }
        if (m.isVarArgs()) {
            Object[] varArgs = (Object[]) Array.newInstance(
                    m.getParameterTypes()[paramCount - 1].getComponentType(),
                    src.length - (paramCount - 1));
            for (int i = 0; i < src.length - (paramCount - 1); i ++) {
                varArgs[i] = ELSupport.coerceToType(src[paramCount - 1 + i],
                        types[paramCount - 1].getComponentType());
            }
            dest[paramCount - 1] = varArgs;
        } else {
            dest[paramCount - 1] = ELSupport.coerceToType(
                    src[paramCount - 1], types[paramCount - 1]);
        }
        return dest;
    }
    private Class<?>[] getTypesFromValues(Object[] values) {
        if (values == null) {
            return null;
        }
        Class<?> result[] = new Class<?>[values.length];
        for (int i = 0; i < values.lengthi++) {
            if (values[i] == null) {
                result[i] = null;
            } else {
                result[i] = values[i].getClass();
            }
        }
        return result;
    }


    

Since:
EL 2.2
    @Override
        // Check this is a reference to a base and a property
        if (this..length > 2 &&
                this.jjtGetChild(2) instanceof AstMethodParameters) {
            // This is a method call
            return null;
        }
        Target t = getTarget(ctx);
        return new ValueReference(t.baset.property);
    }


    

Since:
EL 2.2
    @Override
    public boolean isParametersProvided() {
        // Assumption is that method parameters, if present, will be the last
        // child
        int len = .;
        if (len > 2) {
            if (this.jjtGetChild(len - 1) instanceof AstMethodParameters) {
                return true;
            }
        }
        return false;
    }
New to GrepCode? Check out our FAQ X