KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > commons > el > FunctionInvocation


1 /*
2  * The Apache Software License, Version 1.1
3  *
4  * Copyright (c) 1999 The Apache Software Foundation. All rights
5  * reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  * notice, this list of conditions and the following disclaimer.
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright
15  * notice, this list of conditions and the following disclaimer in
16  * the documentation and/or other materials provided with the
17  * distribution.
18  *
19  * 3. The end-user documentation included with the redistribution, if
20  * any, must include the following acknowlegement:
21  * "This product includes software developed by the
22  * Apache Software Foundation (http://www.apache.org/)."
23  * Alternately, this acknowlegement may appear in the software itself,
24  * if and wherever such third-party acknowlegements normally appear.
25  *
26  * 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
27  * Foundation" must not be used to endorse or promote products derived
28  * from this software without prior written permission. For written
29  * permission, please contact apache@apache.org.
30  *
31  * 5. Products derived from this software may not be called "Apache"
32  * nor may "Apache" appear in their names without prior written
33  * permission of the Apache Group.
34  *
35  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
36  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
37  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
38  * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
41  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
42  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
43  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
44  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
45  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
46  * SUCH DAMAGE.
47  * ====================================================================
48  *
49  * This software consists of voluntary contributions made by many
50  * individuals on behalf of the Apache Software Foundation. For more
51  * information on the Apache Software Foundation, please see
52  * <http://www.apache.org/>.
53  *
54  */
55
56 package org.apache.commons.el;
57
58 import java.util.List JavaDoc;
59 import java.util.Map JavaDoc;
60 import java.util.Iterator JavaDoc;
61 import java.lang.reflect.*;
62 import javax.servlet.jsp.el.ELException JavaDoc;
63 import javax.servlet.jsp.el.VariableResolver JavaDoc;
64 import javax.servlet.jsp.el.FunctionMapper JavaDoc;
65
66 /**
67  *
68  * <p>Represents a function call.</p>
69  *
70  * @author Shawn Bayern (in the style of Nathan's other classes)
71  **/
72
73 public class FunctionInvocation
74   extends Expression
75 {
76   //-------------------------------------
77 // Properties
78 //-------------------------------------
79 // property index
80
81   private String JavaDoc functionName;
82   private List JavaDoc argumentList;
83   public String JavaDoc getFunctionName() { return functionName; }
84   public void setFunctionName(String JavaDoc f) { functionName = f; }
85   public List JavaDoc getArgumentList() { return argumentList; }
86   public void setArgumentList(List JavaDoc l) { argumentList = l; }
87
88   //-------------------------------------
89 /**
90    * Constructor
91    **/
92   public FunctionInvocation (String JavaDoc functionName, List JavaDoc argumentList)
93   {
94     this.functionName = functionName;
95     this.argumentList = argumentList;
96   }
97
98   //-------------------------------------
99 // Expression methods
100 //-------------------------------------
101 /**
102    * Returns the expression in the expression language syntax
103    **/
104   public String JavaDoc getExpressionString ()
105   {
106     StringBuffer JavaDoc b = new StringBuffer JavaDoc();
107     b.append(functionName);
108     b.append("(");
109     Iterator JavaDoc i = argumentList.iterator();
110     while (i.hasNext()) {
111       b.append(((Expression) i.next()).getExpressionString());
112       if (i.hasNext())
113         b.append(", ");
114     }
115     b.append(")");
116     return b.toString();
117   }
118
119
120   //-------------------------------------
121 /**
122    *
123    * Evaluates by looking up the name in the VariableResolver
124    **/
125   public Object JavaDoc evaluate (VariableResolver JavaDoc pResolver,
126               FunctionMapper JavaDoc functions,
127                           Logger pLogger)
128     throws ELException JavaDoc
129   {
130
131     // if the Map is null, then the function is invalid
132 if (functions == null)
133       pLogger.logError(Constants.UNKNOWN_FUNCTION, functionName);
134
135     // normalize function name
136 String JavaDoc prefix = null;
137     String JavaDoc localName = null;
138     int index = functionName.indexOf( ':' );
139     if (index == -1) {
140       prefix = "";
141       localName = functionName;
142     } else {
143       prefix = functionName.substring( 0, index );
144       localName = functionName.substring( index + 1 );
145     }
146
147     // ensure that the function's name is mapped
148 Method target = (Method) functions.resolveFunction(prefix, localName);
149     if (target == null)
150       pLogger.logError(Constants.UNKNOWN_FUNCTION, functionName);
151
152     // ensure that the number of arguments matches the number of parameters
153 Class JavaDoc[] params = target.getParameterTypes();
154     if (params.length != argumentList.size())
155       pLogger.logError(Constants.INAPPROPRIATE_FUNCTION_ARG_COUNT,
156                functionName, new Integer JavaDoc(params.length),
157                new Integer JavaDoc(argumentList.size()));
158
159     // now, walk through each parameter, evaluating and casting its argument
160 Object JavaDoc[] arguments = new Object JavaDoc[argumentList.size()];
161     for (int i = 0; i < params.length; i++) {
162       // evaluate
163 arguments[i] = ((Expression) argumentList.get(i)).evaluate(pResolver,
164                                  functions,
165                                  pLogger);
166       // coerce
167 arguments[i] = Coercions.coerce(arguments[i], params[i], pLogger);
168     }
169
170     // finally, invoke the target method, which we know to be static
171 try {
172       return (target.invoke(null, arguments));
173     } catch (InvocationTargetException ex) {
174       pLogger.logError(Constants.FUNCTION_INVOCATION_ERROR,
175             ex.getTargetException(),
176             functionName);
177       return null;
178     } catch (Exception JavaDoc ex) {
179       pLogger.logError(Constants.FUNCTION_INVOCATION_ERROR, ex, functionName);
180       return null;
181     }
182   }
183
184   //-------------------------------------
185 }
186
Popular Tags