/** * Transforms the input Class object to a result by instantiation. * * @param input the input object to transform * @return the transformed result */ public Object transform(Object input) { try { if (input is java.lang.Class == false) { throw new FunctorException( "InstantiateTransformer: Input object was not an is Class, it was a " + (input == null ? "null object" : input.getClass().getName())); } java.lang.reflect.Constructor con = ((java.lang.Class)input).getConstructor(iParamTypes); return(con.newInstance(iArgs)); } catch (java.lang.NoSuchMethodException) { throw new FunctorException("InstantiateTransformer: The constructor must exist and be public "); } catch (java.lang.InstantiationException ex) { throw new FunctorException("InstantiateTransformer: InstantiationException", ex); } catch (java.lang.IllegalAccessException ex) { throw new FunctorException("InstantiateTransformer: Constructor must be public", ex); } catch (java.lang.reflect.InvocationTargetException ex) { throw new FunctorException("InstantiateTransformer: Constructor threw an exception", ex); } }
/** * Find the Constructor for the class specified. */ private void findConstructor() { try { iConstructor = iClassToInstantiate.getConstructor(iParamTypes); } catch (java.lang.NoSuchMethodException) { throw new java.lang.IllegalArgumentException("InstantiateFactory: The constructor must exist and be public "); } }
/* * Tries to find a suitable constructor and instantiate a new Permission * with specified parameters. * * @param targetType class of expected Permission instance * @param targetName name of expected Permission instance * @param targetActions actions of expected Permission instance * @return a new Permission instance * @throws IllegalArgumentException if no suitable constructor found * @throws Exception any exception thrown by Constructor.newInstance() */ public static java.security.Permission instantiatePermission(java.lang.Class targetType, String targetName, String targetActions) {//throws Exception { // let's guess the best order for trying constructors java.lang.Class[][] argTypes = null; Object[][] args = null; if (targetActions != null) { argTypes = new java.lang.Class[][] { TWO_ARGS, ONE_ARGS, NO_ARGS }; args = new Object[][] { new Object [] { targetName, targetActions }, new Object [] { targetName }, new Object [] {} }; } else if (targetName != null) { argTypes = new java.lang.Class[][] { ONE_ARGS, TWO_ARGS, NO_ARGS }; args = new Object[][] { new Object [] { targetName }, new Object [] { targetName, targetActions }, new Object [] {} }; } else { argTypes = new java.lang.Class[][] { NO_ARGS, ONE_ARGS, TWO_ARGS }; args = new Object[][] { new Object [] {}, new Object [] { targetName }, new Object [] { targetName, targetActions } }; } // finally try to instantiate actual permission for (int i = 0; i < argTypes.Length; i++) { try { java.lang.reflect.Constructor ctor = targetType.getConstructor(argTypes[i]); return((java.security.Permission)ctor.newInstance(args[i])); } catch (java.lang.NoSuchMethodException ignore) { } } throw new java.lang.IllegalArgumentException("No suitable constructors found in permission class : " + targetType + ". Zero, one or two-argument constructor is expected"); }
/** * Converts the given value to the given type. First, reflection is * is used to find a public constructor declared by the given class * that takes one argument, which must be the precise type of the * given value. If such a constructor is found, a new object is * created by passing the given value to that constructor, and the * newly constructed object is returned.<P> * * If no such constructor exists, and the given type is a primitive * type, then the given value is converted to a string using its * {@link Object#toString() toString()} method, and that string is * parsed into the correct primitive type using, for instance, * {@link Integer#valueOf(String)} to convert the string into an * <code>int</code>.<P> * * If no special constructor exists and the given type is not a * primitive type, this method returns the original value. * * @param newType the type to convert the value to * @param value the value to convert * @return the converted value * @throws NumberFormatException if newType is a primitive type, and * the string representation of the given value cannot be converted * to that type * @throws InstantiationException if the constructor found with * reflection raises it * @throws InvocationTargetException if the constructor found with * reflection raises it * @throws IllegalAccessException never * @throws IllegalArgumentException never */ protected Object convertType(java.lang.Class newType, Object value) { //throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { // try call constructor java.lang.Class[] types = { value.getClass() }; try { java.lang.reflect.Constructor constructor = newType.getConstructor(types); Object[] arguments = { value }; return(constructor.newInstance(arguments)); } catch (java.lang.NoSuchMethodException) { // try using the transformers Transformer transformer = getTypeTransformer(newType); if (transformer != null) { return(transformer.transform(value)); } return(value); } }
/** * Find the Constructor for the class specified. */ private void findConstructor() { try { iConstructor = iClassToInstantiate.getConstructor(iParamTypes); } catch (java.lang.NoSuchMethodException ex) { throw new java.lang.IllegalArgumentException("InstantiateFactory: The constructor must exist and be public "); } }