Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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.commons.jocl; import org.xml.sax.Attributes; import org.xml.sax.InputSource; import org.xml.sax.Locator; import org.xml.sax.SAXException; import org.xml.sax.XMLReader; import org.xml.sax.helpers.DefaultHandler; import org.xml.sax.helpers.XMLReaderFactory; import java.lang.reflect.InvocationTargetException; import java.io.InputStream; import java.io.Reader; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.util.Collection; import java.util.List; import java.util.ArrayList; // to do: // + add support for strings as CDATA (makes multiline strings easier, for example) // ? some kind of support for invoking methods? /** * A {@link org.xml.sax.ContentHandler} * for the Java Object Configuration Language. * <p> * JOCL provides an XML syntax for constructing arbitrary Java * {@link java.lang.Object} instances. It does not define a full * XML document type (there's no root element), but rather an * XML fragment describing the {@link java.lang.Object <tt>Object</tt>s} to be * constructed. * <p> * In a JOCL fragment, one may define a series of objects using * the <tt>object</tt> element. A trivial example is: * <pre> <object class="java.util.Date"/></pre> * which constructs an instance of <tt>java.util.Date</tt> * using the no-argument constructor. * <p> * After a "root-level" <tt><object></tt> element has been processed * (that is, once {@link #endElement(java.lang.String,java.lang.String,java.lang.String)} * has been invoked by the {@link XMLReader}), it will be appended to a list of <tt>Object</tt>s * maintained by the <tt>JOCLContentHandler</tt>. * <p> * (See {@link #size}, * {@link #clear}, * {@link #clear(int)}, * {@link #getType(int)}, * {@link #getValue(int)}, * {@link #getTypeArray}, * and * {@link #getValueArray}.) * <p> * You can list multiple <tt>object</tt> elements in a fragment. For example, * after processing the JOCL fragment: * <pre> <object class="java.util.Date"/> * <object class="java.util.Date"/></pre> * The {@link #getTypeArray} method * will return an array composed * of two instances of <tt>java.util.Date</tt>. The sequence of * {@link java.lang.Object <tt>Object</tt>s} in the array * will correspond to the sequence of <tt><object></tt> elements in the JOCL fragment. * <p> * As we've seen, when used with no child-elements, the <tt><object></tt> * tag will cause the no-argument constructor of the specified class to be invoked. * It is also possible to nest <tt><object></tt> tags to provide arguments * for the constructor. * For example, the fragment: * <pre> <object class="mypackage.Foo"> * <object class="mypackage.Bar"/> * </object></pre> * will add an instance of <tt>mypackage.Foo</tt> to the object list, constructed via * <tt>new mypackage.Foo(new mypackage.Bar())</tt>. * <p> * There is a special syntax available creating primitive values and arguments, * as well as for constructing {@link java.lang.String <tt>String</tt>}s. Some examples: * <p> * <pre> <byte value="3"/> * <boolean value="false"/> * <char value="c"/> * <double value="3.14159"/> * <float value="3.14"/> * <int value="17"/> * <long value="1700000"/> * <short value="1"/> * <string value="The quick brown fox..."/></pre> * <p> * When invoked at the "root" level (that is, with no <tt><object></tt> parent), * this will cause the corresponding "object wrapper" to be added to the list of * {@link java.lang.Object <tt>Object</tt>}s. The {@link #getType type} for these * objects will reflect the proper primitive type, however. When invoked with an * <tt><object></tt> parent, these will be treated as primitive arguments to the * specified {@link java.lang.Object <tt>Object</tt>}'s constructor. For example, while: * <p> * <pre> <int value="5"/> * <int value="26"/> * <int value="100"/></pre> * <p> * results in three {@link java.lang.Integer} instances being added to the * list of values, with types corresponding to {@link java.lang.Integer}, the fragment: * <p> * <pre> <int value="5"/> * <int value="26"/> * <int value="100"/></pre> * <p> * results in three {@link java.lang.Integer} instances being added to the * list of values, with types corresponding to {@link java.lang.Integer#TYPE}. * <p> * Hence if you want to invoke the <tt>mypackage.Foo(java.lang.Integer,java.lang.Integer,java.lang.Integer)</tt> * constructor, use: * <pre> <object class="mypackage.Foo"/> * <object class="java.lang.Integer"><int value="5"/></object> * <object class="java.lang.Integer"><int value="26"/></object> * <object class="java.lang.Integer"><int value="100"/></object> * </object></pre> * <p> * If you want to invoke the <tt>mypackage.Foo(int,int,int)</tt> * constructor, use: * <pre> <object class="mypackage.Foo"/> * <int value="5"/> * <int value="26"/> * <int value="100"/> * </object></pre> * <p> * If you'd like to creat a <tt>null</tt> object, use: * <pre> <object class="mypackage.Bar" null="true"/></pre> * <p> * Here's a simple but complete example: * <pre> <?xml version="1.0"?> * <arbitrary-root xmlns="http://apache.org/xml/xmlns/jakarta/commons/jocl"> * <string value="Hello World!"/> * <string/> * <boolean/> * <boolean value="true"/> * <byte value="1"/> * <short value="1"/> * <int value="1"/> * <long value="1"/> * <float value="1.0"/> * <double value="1.0"/> * <object class="java.util.Date"/> * <object class="java.util.Date"> * <int value="1"/> * <int value="1"/> * <int value="1"/> * </object> * </arbitrary-root></pre> * <p> * Formally, a DTD for the JOCL grammar is as follows: * <p> * <pre> * <!ELEMENT object (object|array|collection|list|byte|boolean|char|double|float|int|long|short|string)*> * <!ATTLIST object * class CDATA #REQUIRED * null (true|false) "false"> * * <!ELEMENT byte EMPTY> * <!ATTLIST byte value CDATA #REQUIRED> * * <!ELEMENT boolean EMPTY> * <!ATTLIST boolean value (true|false) #REQUIRED> * * <!ELEMENT char EMPTY> * <!ATTLIST char value CDATA #REQUIRED> * * <!ELEMENT double EMPTY> * <!ATTLIST double value CDATA #REQUIRED> * * <!ELEMENT float EMPTY> * <!ATTLIST float value CDATA #REQUIRED> * * <!ELEMENT int EMPTY> * <!ATTLIST int value CDATA #REQUIRED> * * <!ELEMENT long EMPTY> * <!ATTLIST long value CDATA #REQUIRED> * * <!ELEMENT short EMPTY> * <!ATTLIST short value CDATA #REQUIRED> * * <!ELEMENT string EMPTY> * <!ATTLIST string value CDATA #REQUIRED> * </pre> * <p> * This class can also be used as a base class for {@link org.xml.sax.ContentHandler}s * that include JOCL as part of their grammar. Simply extend this class, and override the * {@link #startElement}, * {@link #characters}, * and {@link #endElement} methods to handle * your tags, and invoke the method of the parent class (i.e., <tt>super.<i>XXX</i></tt> for * elements and data that you don't handle. * <p> * A number of static methods are available for simply reading a list of objects from * a {@link InputStream}, {@link Reader} or {@link InputSource}. * <p> * <b>Note that this class is not synchronized.</b> * <p> * @author Rodney Waldhoff * @version $Revision: 883416 $ $Date: 2009-11-23 12:12:14 -0500 (Mon, 23 Nov 2009) $ */ public class JOCLContentHandler extends DefaultHandler { //--- Static Methods --------------------------------------------- /** * A simple tester method. Reads a JOCL document from standard in * and prints a list of the objects created to standard out. * (Use the <tt>org.xml.sax.driver</tt> system property to specify * an {@link XMLReader}. */ public static void main(String[] args) throws Exception { JOCLContentHandler jocl = JOCLContentHandler.parse(System.in, null); for (int i = 0; i < jocl.size(); i++) { System.out.println("<" + jocl.getType(i) + ">\t" + jocl.getValue(i)); } } /** * Parses a JOCL document from the specified file, using the * {@link XMLReader} specified by the <tt>org.xml.sax.driver</tt> * property. * The returned {@link JOCLContentHandler} will contain the * list of objects described by the file. * @param f a {@link File} containing the JOCL document * @return a {@link JOCLContentHandler} containing the list of objects described by the JOCL document */ public static JOCLContentHandler parse(File f) throws SAXException, FileNotFoundException, IOException { return JOCLContentHandler.parse(new FileInputStream(f), null); } /** * Parses a JOCL document from the specified {@link Reader}, using the * {@link XMLReader} specified by the <tt>org.xml.sax.driver</tt> * property. * The returned {@link JOCLContentHandler} will contain the * list of objects described by the file. * @param in a {@link Reader} containing the JOCL document * @return a {@link JOCLContentHandler} containing the list of objects described by the JOCL document */ public static JOCLContentHandler parse(Reader in) throws SAXException, IOException { return JOCLContentHandler.parse(new InputSource(in), null); } /** * Parses a JOCL document from the specified {@link InputStream}, using the * {@link XMLReader} specified by the <tt>org.xml.sax.driver</tt> * property. * The returned {@link JOCLContentHandler} will contain the * list of objects described by the file. * @param in a {@link InputStream} containing the JOCL document * @return a {@link JOCLContentHandler} containing the list of objects described by the JOCL document */ public static JOCLContentHandler parse(InputStream in) throws SAXException, IOException { return JOCLContentHandler.parse(new InputSource(in), null); } /** * Parses a JOCL document from the specified {@link InputSource}, using thethe * {@link XMLReader} specified by the <tt>org.xml.sax.driver</tt> * property. * The returned {@link JOCLContentHandler} will contain the * list of objects described by the file. * @param in a {@link InputSource} containing the JOCL document * @return a {@link JOCLContentHandler} containing the list of objects described by the JOCL document */ public static JOCLContentHandler parse(InputSource in) throws SAXException, IOException { return JOCLContentHandler.parse(in, null); } /** * Parses a JOCL document from the specified file, using the * {@link XMLReader} specified by the <tt>org.xml.sax.driver</tt> * property. * The returned {@link JOCLContentHandler} will contain the * list of objects described by the file. * @param f a {@link File} containing the JOCL document * @param reader the {@link XMLReader} to use to parse the file * @return a {@link JOCLContentHandler} containing the list of objects described by the JOCL document */ public static JOCLContentHandler parse(File f, XMLReader reader) throws SAXException, FileNotFoundException, IOException { return JOCLContentHandler.parse(new FileInputStream(f), reader); } /** * Parses a JOCL document from the specified {@link Reader}, using the specified * {@link XMLReader}. * The returned {@link JOCLContentHandler} will contain the * list of objects described by the file. * @param in a {@link Reader} containing the JOCL document * @param reader the {@link XMLReader} to use to parse the document * @return a {@link JOCLContentHandler} containing the list of objects described by the JOCL document */ public static JOCLContentHandler parse(Reader in, XMLReader reader) throws SAXException, IOException { return JOCLContentHandler.parse(new InputSource(in), reader); } /** * Parses a JOCL document from the specified {@link InputStream}, using the specified * {@link XMLReader}. * The returned {@link JOCLContentHandler} will contain the * list of objects described by the file. * @param in a {@link InputStream} containing the JOCL document * @param reader the {@link XMLReader} to use to parse the document * @return a {@link JOCLContentHandler} containing the list of objects described by the JOCL document */ public static JOCLContentHandler parse(InputStream in, XMLReader reader) throws SAXException, IOException { return JOCLContentHandler.parse(new InputSource(in), reader); } /** * Parses a JOCL document from the specified {@link InputSource}, using the * specified {@link XMLReader}. * The returned {@link JOCLContentHandler} will contain the * list of objects described by the file. * @param in a {@link InputSource} containing the JOCL document * @param reader the {@link XMLReader} to use to parse the document * @return a {@link JOCLContentHandler} containing the list of objects described by the JOCL document */ public static JOCLContentHandler parse(InputSource in, XMLReader reader) throws SAXException, IOException { JOCLContentHandler jocl = new JOCLContentHandler(); if (null == reader) { reader = XMLReaderFactory.createXMLReader(); } reader.setContentHandler(jocl); reader.parse(in); return jocl; } //--- Construtors ------------------------------------------------ /** * Equivalent to {@link #JOCLContentHandler(boolean,boolean,boolean,boolean) JOCLContentHandler(true,true,true,true)}. */ public JOCLContentHandler() { this(true, true, true, true); } /** * Construct a JOCLContentHandler. * @param emptyEltNS when <tt>true</tt> I should assume any element with an empty namespace is within the JOCL namespace * @param joclEltPrefix when <tt>true</tt> I should assume any element who's prefix is <tt>jocl:</tt> and who's namespace is empty is within the JOCL namespace * @param emptyAttrNS when <tt>true</tt> I should assume any attribute with an empty namespace is within the JOCL namespace * @param joclAttrPrefix when <tt>true</tt> I should assume any attribute who's prefix is <tt>jocl:</tt> and who's namespace is empty is within the JOCL namespace */ public JOCLContentHandler(boolean emptyEltNS, boolean joclEltPrefix, boolean emptyAttrNS, boolean joclAttrPrefix) { _acceptEmptyNamespaceForElements = emptyEltNS; _acceptJoclPrefixForElements = joclEltPrefix; _acceptEmptyNamespaceForAttributes = emptyAttrNS; _acceptJoclPrefixForAttributes = joclAttrPrefix; } //--- Public Methods - Accessing Objects ------------------------- /** * Returns the number of values and types in my list. * @return the number of values and types in my list. */ public int size() { return _typeList.size(); } /** * Clears all the values and types in my list. */ public void clear() { _typeList = new ArrayList(); _valueList = new ArrayList(); } /** * Removes the value/type pair at the specified index. */ public void clear(int i) { _typeList.remove(i); _valueList.remove(i); } /** * Returns the type of the object at the specified index. */ public Class getType(int i) { return (Class) (_typeList.get(i)); } /** * Returns the value of the object at the specified index. */ public Object getValue(int i) { return _valueList.get(i); } /** * Returns a shallow copy of my list of values. */ public Object[] getValueArray() { return _valueList.toArray(); } /** * Returns a shallow copy of my list of types. */ public Object[] getTypeArray() { return _typeList.toArray(); } //--- Public Methods - DocumentHandler --------------------------- public void startElement(String uri, String localName, String qname, Attributes attr) throws SAXException { try { if (isJoclNamespace(uri, localName, qname)) { if (ELT_OBJECT.equals(localName)) { String cname = getAttributeValue(ATT_CLASS, attr); String isnullstr = getAttributeValue(ATT_ISNULL, attr, "false"); boolean isnull = ("true".equalsIgnoreCase(isnullstr) || "yes".equalsIgnoreCase(isnullstr)); _cur = new ConstructorDetails(cname, _cur, isnull); } else if (ELT_ARRAY.equals(localName)) { _cur = new ConstructorDetails(Object[].class, _cur, false, true); } else if (ELT_COLLECTION.equals(localName)) { _cur = new ConstructorDetails(Collection.class, _cur, false, true); } else if (ELT_LIST.equals(localName)) { _cur = new ConstructorDetails(List.class, _cur, false, true); } else if (ELT_BOOLEAN.equals(localName)) { String valstr = getAttributeValue(ATT_VALUE, attr, "false"); boolean val = ("true".equalsIgnoreCase(valstr) || "yes".equalsIgnoreCase(valstr)); addObject(Boolean.TYPE, Boolean.valueOf(val)); } else if (ELT_BYTE.equals(localName)) { byte val = Byte.parseByte(getAttributeValue(ATT_VALUE, attr, "0")); addObject(Byte.TYPE, new Byte(val)); } else if (ELT_CHAR.equals(localName)) { char val = '\u0000'; String valstr = getAttributeValue(ATT_VALUE, attr); if (null == valstr) { val = '\u0000'; } else if (valstr.length() > 1) { throw new SAXException("if present, char value must be exactly one character long"); } else if (valstr.length() == 1) { val = valstr.charAt(0); } else if (valstr.length() == 0) { throw new SAXException("if present, char value must be exactly one character long"); } addObject(Character.TYPE, new Character(val)); } else if (ELT_DOUBLE.equals(localName)) { double val = Double.parseDouble(getAttributeValue(ATT_VALUE, attr, "0")); addObject(Double.TYPE, new Double(val)); } else if (ELT_FLOAT.equals(localName)) { float val = Float.parseFloat(getAttributeValue(ATT_VALUE, attr, "0")); addObject(Float.TYPE, new Float(val)); } else if (ELT_INT.equals(localName)) { int val = Integer.parseInt(getAttributeValue(ATT_VALUE, attr, "0")); addObject(Integer.TYPE, new Integer(val)); } else if (ELT_LONG.equals(localName)) { long val = Long.parseLong(getAttributeValue(ATT_VALUE, attr, "0")); addObject(Long.TYPE, new Long(val)); } else if (ELT_SHORT.equals(localName)) { short val = Short.parseShort(getAttributeValue(ATT_VALUE, attr, "0")); addObject(Short.TYPE, new Short(val)); } else if (ELT_STRING.equals(localName)) { String val = getAttributeValue(ATT_VALUE, attr); addObject("".getClass(), val); } else { // unrecognized JOCL element warning? } } } catch (NumberFormatException e) { throw new SAXException(e); } catch (ClassNotFoundException e) { throw new SAXException(e); } } public void endElement(String uri, String localName, String qname) throws SAXException { try { if (isJoclNamespace(uri, localName, qname)) { if (ELT_OBJECT.equals(localName) || ELT_ARRAY.equals(localName) || ELT_COLLECTION.equals(localName) || ELT_LIST.equals(localName)) { ConstructorDetails temp = _cur; _cur = _cur.getParent(); if (null == _cur) { _typeList.add(temp.getType()); _valueList.add(temp.createObject()); } else { _cur.addArgument(temp.getType(), temp.createObject()); } } /* else if(ELT_BOOLEAN.equals(localName)) { // nothing to do here } else if(ELT_BYTE.equals(localName)) { // nothing to do here } else if(ELT_CHAR.equals(localName)) { // nothing to do here } else if(ELT_DOUBLE.equals(localName)) { // nothing to do here } else if(ELT_FLOAT.equals(localName)) { // nothing to do here } else if(ELT_INT.equals(localName)) { // nothing to do here } else if(ELT_LONG.equals(localName)) { // nothing to do here } else if(ELT_SHORT.equals(localName)) { // nothing to do here } else if(ELT_STRING.equals(localName)) { // nothing to do here } else { // unrecognized JOCL element warning? } */ } } catch (Exception e) { throw new SAXException(e); } } public void setDocumentLocator(Locator locator) { _locator = locator; } //--- Protected Methods ------------------------------------------ /** * Returns <tt>true</tt> if the given attributes define an * element within the JOCL namespace (according to my current * configuration.) * * @see #_acceptEmptyNamespaceForElements * @see #_acceptJoclPrefixForElements */ protected boolean isJoclNamespace(String uri, String localname, String qname) { if (JOCL_NAMESPACE_URI.equals(uri)) { return true; } else if (_acceptEmptyNamespaceForElements && (null == uri || "".equals(uri))) { return true; } else if (_acceptJoclPrefixForElements && (null == uri || "".equals(uri)) && qname.startsWith(JOCL_PREFIX)) { return true; } else { return false; } } /** * Equivalent to {@link #getAttributeValue(java.lang.String,org.xml.sax.Attributes,java.lang.String) <tt>getAttributeValue(localname,attr,null)</tt>}. */ protected String getAttributeValue(String localname, Attributes attr) { return getAttributeValue(localname, attr, null); } /** * Returns the value of attribute with the given * <tt><i>localname</i></tt> within the JOCL * namespace from the given set of {@link Attributes}. * If no such attribute can be found, returns * <tt><i>implied</i></tt>. * * @param localname the unqualified name of the attribute to look for * @param attr the Attributes in which to find the value * @param implied the default value for the attribute * @return the value of attribute with the given * <tt><i>localname</i></tt> within the JOCL * namespace from the given set of {@link Attributes}. * If no such attribute can be found, returns * <tt><i>implied</i></tt>. */ protected String getAttributeValue(String localname, Attributes attr, String implied) { String val = attr.getValue(JOCL_NAMESPACE_URI, localname); if (null == val && _acceptEmptyNamespaceForAttributes) { val = attr.getValue("", localname); } if (null == val && _acceptJoclPrefixForAttributes) { val = attr.getValue("", JOCL_PREFIX + localname); } return (null == val ? implied : val); } /** * Add the specified object either to my type/value list, or * as an argument to the object I'm currently constructing. */ protected void addObject(Class type, Object val) { if (null == _cur) { _typeList.add(type); _valueList.add(val); } else { _cur.addArgument(type, val); } } //--- Protected Attributes --------------------------------------- /** * The JOCL namespace URI, <tt>http://apache.org/xml/xmlns/jakarta/commons/jocl</tt>. */ public static final String JOCL_NAMESPACE_URI = "http://apache.org/xml/xmlns/jakarta/commons/jocl"; /** * The default JOCL prefix, <tt>jocl:</tt>. */ public static final String JOCL_PREFIX = "jocl:"; /** * A list of the types ({@link Class}es) already created via the parse. */ protected ArrayList _typeList = new ArrayList(); /** * A list of the values ({@link Object}s) already created via the parse. */ protected ArrayList _valueList = new ArrayList(); /** * The object I'm currently working on. */ protected ConstructorDetails _cur = null; /** * When <tt>true</tt>, I will treat elements with an * empty namespace URI as part of the JOCL namespace. * * @see #JOCL_NAMESPACE_URI */ protected boolean _acceptEmptyNamespaceForElements = true; /** * When <tt>true</tt>, I will treat elements with the * {@link #JOCL_PREFIX} but no namespace URI as being * mapped to the jocl namespace. * * @see #JOCL_PREFIX * @see #JOCL_NAMESPACE_URI */ protected boolean _acceptJoclPrefixForElements = true; /** * When <tt>true</tt>, I will treat attributes with an * empty namespace URI as part of the JOCL namespace. * * @see #JOCL_NAMESPACE_URI */ protected boolean _acceptEmptyNamespaceForAttributes = true; /** * When <tt>true</tt>, I will treat attributes with the * {@link #JOCL_PREFIX} but no namespace URI as being * mapped to the jocl namespace. * * @see #JOCL_PREFIX * @see #JOCL_NAMESPACE_URI */ protected boolean _acceptJoclPrefixForAttributes = true; /** My {@link Locator}. */ protected Locator _locator = null; /** The name of the "object" element. */ protected static final String ELT_OBJECT = "object"; /** The name of the "array" element. * @since 1.2.2 */ protected static final String ELT_ARRAY = "array"; /** The name of the "collection" element. * @since 1.2.2 */ protected static final String ELT_COLLECTION = "collection"; /** The name of the "list" element. * @since 1.2.2 */ protected static final String ELT_LIST = "list"; /** The name of the "object" element's "class" attribute. */ protected static final String ATT_CLASS = "class"; /** The name of the "object" element's "isnull" attribute. */ protected static final String ATT_ISNULL = "null"; /** The name of the "boolean" element. */ protected static final String ELT_BOOLEAN = "boolean"; /** The name of the "byte" element. */ protected static final String ELT_BYTE = "byte"; /** The name of the "char" element. */ protected static final String ELT_CHAR = "char"; /** The name of the "double" element. */ protected static final String ELT_DOUBLE = "double"; /** The name of the "float" element. */ protected static final String ELT_FLOAT = "float"; /** The name of the "int" element. */ protected static final String ELT_INT = "int"; /** The name of the "long" element. */ protected static final String ELT_LONG = "long"; /** The name of the "short" element. */ protected static final String ELT_SHORT = "short"; /** The name of the "string" element. */ protected static final String ELT_STRING = "string"; /** The name of the "value" attribute. */ protected static final String ATT_VALUE = "value"; static class ConstructorDetails { private ConstructorDetails _parent = null; private Class _type = null; private ArrayList _argTypes = null; private ArrayList _argValues = null; private boolean _isnull = false; private boolean _isgroup = false; public ConstructorDetails(String classname, ConstructorDetails parent) throws ClassNotFoundException { this(Class.forName(classname), parent, false, false); } public ConstructorDetails(String classname, ConstructorDetails parent, boolean isnull) throws ClassNotFoundException { this(Class.forName(classname), parent, isnull, false); } /** * @since 1.3 */ public ConstructorDetails(String classname, ConstructorDetails parent, boolean isnull, boolean isgroup) throws ClassNotFoundException { this(Class.forName(classname), parent, isnull, isgroup); } /** * @since 1.3 */ public ConstructorDetails(Class type, ConstructorDetails parent, boolean isnull, boolean isgroup) { _parent = parent; _type = type; _argTypes = new ArrayList(); _argValues = new ArrayList(); _isnull = isnull; _isgroup = isgroup; } public void addArgument(Object value) { addArgument(value.getClass(), value); } public void addArgument(Class type, Object val) { if (_isnull) { throw new NullPointerException("can't add arguments to null instances"); } _argTypes.add(type); _argValues.add(val); } public Class getType() { return _type; } public ConstructorDetails getParent() { return _parent; } public Object createObject() throws InstantiationException, IllegalAccessException, InvocationTargetException { if (_isnull) { return null; } else if (_isgroup) { if (_type.equals(Object[].class)) { return _argValues.toArray(); } else if (_type.equals(Collection.class) || _type.equals(List.class)) { return _argValues; } else { throw new IllegalStateException("implementation error: unhandled _type:" + _type); } } else { Class k = getType(); Class[] argtypes = (Class[]) _argTypes.toArray(new Class[0]); Object[] argvals = _argValues.toArray(); return ConstructorUtil.invokeConstructor(k, argtypes, argvals); } } } }