jakarta.el.MethodExpression Maven / Gradle / Ivy

/*
 * Copyright (c) 1997, 2019 Oracle and/or its affiliates and others.
 * All rights reserved.
 * Copyright 2004 The Apache Software Foundation
 *
 * Licensed 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.
 */

package jakarta.el;

/**
 * An Expression that refers to a method on an object.
 *
 * 
 * The {@link ExpressionFactory#createMethodExpression} method can be used to parse an expression string and
 * return a concrete instance of MethodExpression that encapsulates the parsed expression. The
 * {@link FunctionMapper} is used at parse time, not evaluation time, so one is not needed to evaluate an expression
 * using this class. However, the {@link ELContext} is needed at evaluation time.
 * 
 *
 * 
 * The {@link #getMethodInfo} and {@link #invoke} methods will evaluate the expression each time they are called. The
 * {@link ELResolver} in the ELContext is used to resolve the top-level variables and to determine the
 * behavior of the . and [] operators. For any of the two methods, the
 * {@link ELResolver#getValue} method is used to resolve all properties up to but excluding the last one. This
 * provides the base object on which the method appears. If the base object is null, a
 * PropertyNotFoundException must be thrown. At the last resolution, the final property is
 * then coerced to a String, which provides the name of the method to be found. A method matching the name
 * and expected parameters provided at parse time is found and it is either queried or invoked (depending on the method
 * called on this MethodExpression).
 * 
 *
 * 
 * See the notes about comparison, serialization and immutability in the {@link Expression} javadocs.
 *
 * @see ELResolver
 * @see Expression
 * @see ExpressionFactory
 * @since Jakarta Server Pages 2.1
 */
public abstract class MethodExpression extends Expression {

    private static final long serialVersionUID = -1151639017737837708L;

    // Evaluation

    /**
     * Evaluates the expression relative to the provided context, and returns information about the actual referenced
     * method.
     *
     * @param context The context of this evaluation
     * @return an instance of MethodInfo containing information about the method the expression evaluated to.
     * @throws NullPointerException if context is null
     * @throws PropertyNotFoundException if one of the property resolutions failed because a specified variable or property
     * does not exist or is not readable.
     * @throws MethodNotFoundException if no suitable method can be found.
     * @throws ELException if an exception was thrown while performing property or variable resolution. The thrown exception
     * must be included as the cause property of this exception, if available.
     */
    public abstract MethodInfo getMethodInfo(ELContext context);

    /**
     * If a String literal is specified as the expression, returns the String literal coerced to the expected return type of
     * the method signature. An ELException is thrown if expectedReturnType is void or if the
     * coercion of the String literal to the expectedReturnType yields an error (see Section "1.18 Type
     * Conversion" of the Jakarta Expression Language specification).
     *
     * If not a String literal, 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.
     *
     * Any parameters passed to this method is ignored if isLiteralText() or isParmetersProvided() is true.
     *
     * @param context The context of this evaluation.
     * @param params The parameters to pass to the method, or null if no parameters.
     * @return the result of the method invocation (null if the method has a void return type).
     * @throws NullPointerException if context is null
     * @throws PropertyNotFoundException if one of the property resolutions failed because a specified variable or property
     * does not exist or is not readable.
     * @throws MethodNotFoundException if no suitable method can be found.
     * @throws ELException if a String literal is specified and expectedReturnType of the MethodExpression is void or if the
     * coercion of the String literal to the expectedReturnType yields an error (see Section "1.18 Type Conversion").
     * @throws ELException if an exception was thrown while performing property or variable resolution. The thrown exception
     * must be included as the cause property of this exception, if available. If the exception thrown is an
     * InvocationTargetException, extract its cause and pass it to the ELException
     * constructor.
     */
    public abstract Object invoke(ELContext context, Object[] params);

    /**
     * Return whether this MethodExpression was created with parameters.
     *
     * 
     * This method must return true if and only if parameters are specified in the EL, using the
     * expr-a.expr-b(...) syntax.
     *
     * @return true if the MethodExpression was created with parameters, false otherwise.
     * 
     * @since Jakarta Expression Language 2.2
     */
    public boolean isParametersProvided() {
        return false;
    }

    /**
     * Use isParametersProvided instead.
     *
     * @return true if the MethodExpression was created with parameters, false otherwise.
     */
    @Deprecated
    public boolean isParmetersProvided() {
        return isParametersProvided();
    }
}