| /* |
| * Copyright 2004,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 org.apache.bsf.util; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Modifier; |
| |
| import org.apache.bsf.BSFEngine; |
| import org.apache.bsf.BSFException; |
| import org.apache.bsf.BSFManager; |
| |
| /** |
| * This class contains utilities that language integrators can use |
| * when implementing the BSFEngine interface. |
| * |
| * @author Sanjiva Weerawarana |
| * @author Sam Ruby |
| * @author Rony G. Flatscher (added addEventListenerReturningEventInfos) |
| */ |
| public class EngineUtils { |
| // the BSF class loader that knows how to load from the a specific |
| // temp directory |
| static BSFClassLoader bsfCL; |
| |
| // ---rgf, 2003-02-13, determine whether changing accessibility of Methods is possible |
| static boolean bMethodHasSetAccessible=false; |
| static { |
| Class mc=Method.class; // get the "Method" class object |
| Class arg[]={boolean.class}; // define an array with the primitive "boolean" pseudo class object |
| try { |
| mc.getMethod("setAccessible", arg ); // is this method available? |
| bMethodHasSetAccessible=true; // no exception, hence method exists |
| } |
| catch (Exception e) |
| { |
| bMethodHasSetAccessible=false;// exception occurred, hence method does not exist |
| } |
| } |
| |
| |
| /** |
| * Add a script as a listener to some event coming out of an object. The |
| * first two args identify the src of the event and the event set |
| * and the rest identify the script which should be run when the event |
| * fires. |
| * |
| * @param bean event source |
| * @param eventSetName name of event set from event src to bind to |
| * @param filter filter for events |
| * @param engine BSFEngine which can run this script |
| * @param manager BSFManager of the above engine |
| * @param source (context info) the source of this expression |
| * (e.g., filename) |
| * @param lineNo (context info) the line number in source for expr |
| * @param columnNo (context info) the column number in source for expr |
| * @param script the script to execute when the event occurs |
| * |
| * @exception BSFException if anything goes wrong while running the script |
| */ |
| public static void addEventListener (Object bean, String eventSetName, |
| String filter, BSFEngine engine, |
| BSFManager manager, String source, |
| int lineNo, int columnNo, |
| Object script) throws BSFException { |
| BSFEventProcessor ep = new BSFEventProcessor (engine, manager, filter, |
| source, lineNo, columnNo, |
| script); |
| |
| try { |
| ReflectionUtils.addEventListener (bean, eventSetName, ep); |
| } catch (Exception e) { |
| e.printStackTrace (); |
| throw new BSFException (BSFException.REASON_OTHER_ERROR, |
| "ouch while adding event listener: " |
| + e, e); |
| } |
| } |
| |
| |
| /** |
| * Add a script as a listener to some event coming out of an object. The |
| * first two args identify the src of the event and the event set |
| * and the rest identify the script which should be run when the event |
| * fires. The processing will use the engine's apply() method. |
| * |
| * @param bean event source |
| * @param eventSetName name of event set from event src to bind to |
| * @param filter filter for events |
| * @param engine BSFEngine which can run this script |
| * @param manager BSFManager of the above engine |
| * @param source (context info) the source of this expression (e.g., filename) |
| * @param lineNo (context info) the line number in source for expr |
| * @param columnNo (context info) the column number in source for expr |
| * @param script the script to execute when the event occurs |
| * @param dataFromScriptingEngine |
| * this contains any object supplied by the scripting engine and gets sent |
| * back with the supplied script, if the event occurs. |
| * This could be used e.g. for indicating to the scripting engine which |
| * scripting engine object/routine/function/procedure |
| * should be ultimately informed of the event occurrence. |
| * |
| * @exception BSFException if anything goes wrong while running the script |
| */ |
| public static void addEventListenerReturningEventInfos ( Object bean, |
| String eventSetName, |
| String filter, |
| BSFEngine engine, |
| BSFManager manager, |
| String source, |
| int lineNo, |
| int columnNo, |
| Object script, |
| Object dataFromScriptingEngine |
| ) throws BSFException |
| { |
| BSFEventProcessorReturningEventInfos ep = |
| new BSFEventProcessorReturningEventInfos (engine, |
| manager, |
| filter, |
| source, |
| lineNo, |
| columnNo, |
| script, |
| dataFromScriptingEngine |
| ); |
| |
| try { |
| ReflectionUtils.addEventListener (bean, eventSetName, ep); |
| } catch (Exception e) { |
| e.printStackTrace (); |
| throw new BSFException (BSFException.REASON_OTHER_ERROR, |
| "ouch while adding event listener: " |
| + e, e); |
| } |
| } |
| |
| /** |
| * Finds and invokes a method with the given signature on the given |
| * bean. The signature of the method that's invoked is first taken |
| * as the types of the args, but if that fails, this tries to convert |
| * any primitive wrapper type args to their primitive counterparts |
| * to see whether a method exists that way. If it does, done. |
| * |
| * @param bean the object on which to invoke the method |
| * @param methodName name of the method |
| * @param args arguments to be given to the method |
| * |
| * @return the result of invoking the method, if any |
| * |
| * @exception BSFException if something goes wrong |
| */ |
| public static Object callBeanMethod (Object bean, String methodName, |
| Object[] args) throws BSFException { |
| Class[] argTypes = null; |
| // determine arg types. note that a null argtype |
| // matches any object type |
| |
| if (args != null) { |
| argTypes = new Class[args.length]; |
| for (int i = 0; i < args.length; i++) { |
| argTypes[i] = (args[i] == null) ? null : args[i].getClass (); |
| } |
| } |
| |
| // we want to allow a static call to occur on an object, similar |
| // to what Java allows. So isStaticOnly is set to false. |
| boolean isStaticOnly = false; |
| Class beanClass = (bean instanceof Class) ? (Class)bean : |
| bean.getClass (); |
| |
| // now try to call method with the right signature |
| try { |
| Method m; |
| try { |
| m = MethodUtils.getMethod (beanClass, methodName, argTypes, |
| isStaticOnly); |
| } catch (NoSuchMethodException e) { |
| // ok, so that didn't work - now try converting any primitive |
| // wrapper types to their primitive counterparts |
| try { |
| // if args is null the NullPointerException will get caught |
| // below and the right thing'll happen .. ugly but works |
| for (int i = 0; i < args.length; i++) { |
| if (args[i] instanceof Number) |
| { |
| if (args[i] instanceof Byte) argTypes[i] = byte.class; |
| else if (args[i] instanceof Integer) argTypes[i] = int.class; |
| else if (args[i] instanceof Long) argTypes[i] = long.class; |
| else if (args[i] instanceof Float) argTypes[i] = float.class; |
| else if (args[i] instanceof Double ) argTypes[i] = double.class; |
| else if (args[i] instanceof Short ) argTypes[i] = short.class; |
| } |
| else if (args[i] instanceof Boolean) argTypes[i] = boolean.class; |
| else if (args[i] instanceof Character) argTypes[i] = char.class; |
| } |
| |
| m = MethodUtils.getMethod (beanClass, methodName, argTypes, |
| isStaticOnly); |
| } catch (Exception e2) { |
| // throw the original |
| throw e; |
| } |
| } |
| |
| // call it, and return the result |
| try { |
| return m.invoke (bean, args); |
| } |
| catch (Exception e) // 2003-02-23, --rgf, maybe an IllegalAccessException? |
| { |
| if (e instanceof IllegalAccessException && |
| bMethodHasSetAccessible && |
| Modifier.isPublic(m.getModifiers()) ) // if a public method allow access to it |
| { |
| m.setAccessible(true); // allow unconditional access to method |
| return m.invoke (bean, args); |
| } |
| // re-throw the exception |
| throw e; |
| } |
| |
| } catch (Exception e) { |
| // something went wrong while invoking method |
| Throwable t = (e instanceof InvocationTargetException) ? |
| ((InvocationTargetException)e).getTargetException () : |
| null; |
| throw new BSFException (BSFException.REASON_OTHER_ERROR, |
| "method invocation failed: " + e + |
| ((t==null) ? "" : |
| (" target exception: " + t)), t); |
| } |
| } |
| |
| /** |
| * Creates a new bean. The signature of the constructor that's invoked |
| * is first taken as the types of the args, but if that fails, this tries |
| * to convert any primitive wrapper type args to their primitive |
| * counterparts to see whether a method exists that way. If it does, done. |
| * |
| * @param className fully qualified name of class to instantiate |
| * @param args array of constructor args (or null if none) |
| * |
| * @return the created bean |
| * |
| * @exception BSFException if something goes wrong (@see |
| * org.apache.cs.util.MethodUtils for the real |
| * exceptions that can occur). |
| */ |
| public static Object createBean (String className, Object args[]) |
| throws BSFException { |
| Bean obj; |
| Class[] argTypes = null; |
| |
| if (args != null) { |
| argTypes = new Class[args.length]; |
| for (int i = 0; i < args.length; i++) { |
| argTypes[i] = (args[i] != null) ? args[i].getClass () : null; |
| } |
| } |
| |
| try { |
| try { |
| obj = ReflectionUtils.createBean (null, className, |
| argTypes, args); |
| return obj.value; |
| } catch (NoSuchMethodException me) { |
| // ok, so that didn't work - now try converting any primitive |
| // wrapper types to their primitive counterparts |
| try { |
| // if args is null the NullPointerException will get caught |
| // below and the right thing'll happen .. ugly but works |
| for (int i = 0; i < args.length; i++) { |
| if (args[i] instanceof Number) |
| argTypes[i] = byte.class; |
| else if (args[i] instanceof Boolean) |
| argTypes[i] = boolean.class; |
| else if (args[i] instanceof Character) |
| argTypes[i] = char.class; |
| } |
| obj = ReflectionUtils.createBean (null, className, |
| argTypes, args); |
| return obj.value; |
| } catch (Exception e) { |
| // throw the previous exception |
| throw me; |
| } |
| } |
| } catch (Exception e) { |
| throw new BSFException (BSFException.REASON_OTHER_ERROR, |
| e.getMessage (), e); |
| } |
| } |
| |
| /** |
| * Given a class return the type signature string fragment for it. |
| * That is, return "I" for int, "J" for long, ... etc.. |
| * |
| * @param cl class object for whom the signature fragment is needed. |
| * |
| * @return the string representing the type signature |
| */ |
| public static String getTypeSignatureString (Class cl) { |
| if (cl.isPrimitive ()) { |
| if (cl == boolean.class) |
| return "Z"; |
| else if (cl == byte.class) |
| return "B"; |
| else if (cl == char.class) |
| return "C"; |
| else if (cl == short.class) |
| return "S"; |
| else if (cl == int.class) |
| return "I"; |
| else if (cl == long.class) |
| return "J"; |
| else if (cl == float.class) |
| return "F"; |
| else if (cl == double.class) |
| return "D"; |
| else |
| return "V"; |
| } else { |
| StringBuffer sb = new StringBuffer ("L"); |
| sb.append (cl.getName ()); |
| sb.append (";"); |
| return sb.toString().replace ('.', '/'); |
| } |
| } |
| |
| /** |
| * Load a class using the class loader of given manager. If that fails |
| * try using a class loader that loads from the tempdir of the manager. |
| * |
| * @param mgr BSFManager who's classLoader and tempDir props are |
| * consulted |
| * @param name name of the class to load |
| * |
| * @return the loaded class |
| * |
| * @exception BSFException if something goes wrong. |
| */ |
| public static Class loadClass (BSFManager mgr, String name) |
| throws BSFException { |
| ClassLoader classLoader = mgr.getClassLoader (); |
| |
| try { |
| return (classLoader == null) ? |
| // Class.forName (name) |
| Thread.currentThread().getContextClassLoader().loadClass (name) |
| : classLoader.loadClass (name); |
| } catch (ClassNotFoundException e) { |
| // try to load it from the temp dir using my own class loader |
| try { |
| if (bsfCL == null) |
| bsfCL = new BSFClassLoader (); |
| bsfCL.setTempDir (mgr.getTempDir ()); |
| return bsfCL.loadClass (name); |
| } catch (ClassNotFoundException e2) { |
| throw new BSFException (BSFException.REASON_OTHER_ERROR, |
| "unable to load class '" + name + "':" + e, e); |
| } |
| } |
| } |
| } |
