public MethodExpressionImpl() 
{
        super();
}

 public MethodExpressionImpl(String expr,
    Node node,
    FunctionMapper fnMapper,
    VariableMapper varMapper,
    Class expectedType,
    Class[] paramTypes) 
{
        super();
        this.expr = expr;
        this.node = node;
        this.fnMapper = fnMapper;
        this.varMapper = varMapper;
        this.expectedType = expectedType;
        this.paramTypes = paramTypes;
}

Parameters:

expr -

node -

fnMapper -

expectedType -

paramTypes -

 public boolean equals(Object obj) 
{
        return (obj instanceof MethodExpressionImpl && obj.hashCode() == this
                .hashCode());
}

Determines whether the specified object is equal to this Expression.

The result is true if and only if the argument is not null, is an Expression object that is the of the same type (ValueExpression or MethodExpression), and has an identical parsed representation.

Note that two expressions can be equal if their expression Strings are different. For example, ${fn1:foo()} and ${fn2:foo()} are equal if their corresponding FunctionMappers mapped fn1:foo and fn2:foo to the same method.

 public String getExpressionString() 
{
        return this.expr;
}

Returns the original String used to create this Expression, unmodified.

This is used for debugging purposes but also for the purposes of comparison (e.g. to ensure the expression in a configuration file has not changed).

This method does not provide sufficient information to re-create an expression. Two different expressions can have exactly the same expression string but different function mappings. Serialization should be used to save and restore the state of an Expression.

 public MethodInfo getMethodInfo(ELContext context) throws MethodNotFoundException, PropertyNotFoundException, ELException 
{
        Node n = this.getNode();
        EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
                this.varMapper);
        return n.getMethodInfo(ctx, this.paramTypes);
}

Evaluates the expression relative to the provided context, and returns information about the actual referenced method.

 public int hashCode() 
{
        return this.expr.hashCode();
}

Returns the hash code for this Expression.

See the note in the #equals method on how two expressions can be equal if their expression Strings are different. Recall that if two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result. Implementations must take special note and implement hashCode correctly.

 public Object invoke(ELContext context,
    Object[] params) throws MethodNotFoundException, PropertyNotFoundException, ELException 
{
        EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
                this.varMapper);
        return this.getNode().invoke(ctx, this.paramTypes, params);
}

Evaluates the expression relative to the provided context, invokes the method that was found using the supplied parameters, and returns the result of the method invocation.

 public boolean isLiteralText() 
{
        return false;
}

 public  void readExternal(ObjectInput in) throws ClassNotFoundException, IOException 
{
        this.expr = in.readUTF();
        String type = in.readUTF();
        if (!"".equals(type)) {
            this.expectedType = ReflectionUtil.forName(type);
        }
        this.paramTypes = ReflectionUtil.toTypeArray(((String[]) in
                .readObject()));
        this.fnMapper = (FunctionMapper) in.readObject();
        this.varMapper = (VariableMapper) in.readObject();
}

 public  void writeExternal(ObjectOutput out) throws IOException 
{
        out.writeUTF(this.expr);
        out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
                : "");
        out.writeObject(ReflectionUtil.toTypeNameArray(this.paramTypes));
        out.writeObject(this.fnMapper);
        out.writeObject(this.varMapper);
}