FileDocCategorySizeDatePackage
FunctionInvocation.javaAPI DocGlassfish v2 API5855Sat May 05 19:17:26 BST 2007org.apache.taglibs.standard.lang.jstl

FunctionInvocation

public class FunctionInvocation extends Expression

Represents a function call.

author
Shawn Bayern (in the style of Nathan's other classes)

(Omit source code)

Fields Summary
private String
functionName
private List
argumentList
Constructors Summary
public FunctionInvocation(String functionName, List argumentList)
Constructor

    this.functionName = functionName;
    this.argumentList = argumentList;
Methods Summary
public java.lang.Objectevaluate(java.lang.Object pContext, VariableResolver pResolver, java.util.Map functions, java.lang.String defaultPrefix, Logger pLogger)
Evaluates by looking up the name in the VariableResolver


    // if the Map is null, then the function is invalid
    if (functions == null)
      pLogger.logError(Constants.UNKNOWN_FUNCTION, functionName);

    // normalize function name against default prefix
    String functionName = this.functionName;
    if (functionName.indexOf(":") == -1) {
      if (defaultPrefix == null)
        pLogger.logError(Constants.UNKNOWN_FUNCTION, functionName);
      functionName = defaultPrefix + ":" + functionName;
    }

    // ensure that the function's name is mapped
    Method target = (Method) functions.get(functionName);
    if (target == null)
      pLogger.logError(Constants.UNKNOWN_FUNCTION, functionName);

    // ensure that the number of arguments matches the number of parameters
    Class[] params = target.getParameterTypes();
    if (params.length != argumentList.size())
        pLogger.logError(Constants.INAPPROPRIATE_FUNCTION_ARG_COUNT,
                         Integer.valueOf(params.length),
                         Integer.valueOf(argumentList.size()));

    // now, walk through each parameter, evaluating and casting its argument
    Object[] arguments = new Object[argumentList.size()];
    for (int i = 0; i < params.length; i++) {
      // evaluate
      arguments[i] = ((Expression) argumentList.get(i)).evaluate(pContext,
								 pResolver,
								 functions,
								 defaultPrefix,
								 pLogger);
      // coerce
      arguments[i] = Coercions.coerce(arguments[i], params[i], pLogger);
    }

    // finally, invoke the target method, which we know to be static
    try {
      return (target.invoke(null, arguments));
    } catch (InvocationTargetException ex) {
      pLogger.logError(Constants.FUNCTION_INVOCATION_ERROR,
			ex.getTargetException(),
			functionName);
      return null;
    } catch (Exception ex) {
      pLogger.logError(Constants.FUNCTION_INVOCATION_ERROR, ex, functionName);
      return null;
    }
public java.util.ListgetArgumentList()

 return argumentList;
public java.lang.StringgetExpressionString()
Returns the expression in the expression language syntax

    StringBuffer b = new StringBuffer();
    b.append(functionName);
    b.append("(");
    Iterator i = argumentList.iterator();
    while (i.hasNext()) {
      b.append(((Expression) i.next()).getExpressionString());
      if (i.hasNext())
        b.append(", ");
    }
    b.append(")");
    return b.toString();
public java.lang.StringgetFunctionName()

 return functionName;
public voidsetArgumentList(java.util.List l)

 argumentList = l;
public voidsetFunctionName(java.lang.String f)

 functionName = f;