DomConfigFactory.java

Violations

Source code

/*
 * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
 */
package biz.hammurapi.config;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;

import biz.hammurapi.config.adapters.File2InputStreamConfigurableAdapter;
import biz.hammurapi.config.adapters.InputStream2DomConfigurableAdapter;
import biz.hammurapi.config.adapters.URL2InputStreamConfigurableAdapter;
import biz.hammurapi.convert.ConvertingService;
import biz.hammurapi.convert.DuckConverterFactory;
import biz.hammurapi.xml.dom.DOMUtils;


/**
 * Creates and configures objects from DOM {@link org.w3c.dom.Element} (XML file).
 * DOM Element can be read from InputStream, File or URL.
 * Instantiation and configuration happens as follows:<P/>
 * <B>Instantiation</B>
 * <ul>
 * 	<li>If there is no <code>'type'</code> attribute then type defaults to
 * {@link java.lang.String} and text of the element will be returned.
 * E.g. &lt;name&gt;Pavel&lt;/name&gt; will yield string 'Pavel'. <code>'type'</code>
 * attribute name can be changed through {@link biz.hammurapi.config.DomConfigInfo#setCodeExpression(String)}
 * method. Create {@link biz.hammurapi.config.DomConfigInfo}, change code expression and then
 * use {@link #DomConfigFactory(DomConfigInfo)} to instantiate DomConfigFactory.
 * </li>
 *
 * <li>Otherwise class specified in <code>'type'</code> attribute will be loaded and
 * verified by classAcceptor (if any)</li>
 *
 * <li>If there is no nested <code>'constructor'</code>' element and element text is blank then default
 * constructor will be used</li>
 *
 * <li>If there is no nested <code>'constructor'</code>' element and element text is not blank then constructor which takes a single argument of type
 * java.lang.String will be used</li>
 *
 * <li>If there is nested <code>'constructor'</code> element then <code>'arg'</code> elements of
 * <code>'constructor'</code> element are iterated to create a list of arguments.
 * Arguments are constructed in the same way as described here. <code>'arg'</code> element
 * also supports <code>'context-ref'</code> attribute. If this attribute is set argument
 * value will be taken from context entry set by {@link DomConfigFactory#setContextEntry(String, Object)} method
 * </li>
 * </ul>
 * <P/>
 *
 * <B>Configuration</B>
 * <ul>
 * <li>If element has attribute <code>'url'</code> and instantiated object (instance)
 * is instance of {@link biz.hammurapi.config.URLConfigurable} then {@link biz.hammurapi.config.URLConfigurable#configure(URL, Map)}
 * is invoked to configure instance</li>
 *
 * <li>If element has attribute <code>'file'</code> and instance
 * is instance of {@link biz.hammurapi.config.FileConfigurable} then {@link biz.hammurapi.config.FileConfigurable#configure(File, Map)}
 * is invoked to configure instance</li>
 *
 * <li>If instance is instance of
 * {@link biz.hammurapi.config.InputStreamConfigurable}
 * then <ul>
 * 	<li>If element has attribute <code>'url'</code> then that url is opened as InsputStream</li>
 * 	<li>If element has attribute <code>'file'</code> then that file is opened as InputStream</li>
 * 	<li>If element has attribute <code>'resource'</code> then that resource is opened as InputStream.
 * Instance's class is used to obtain resource which allows to use relative resource names.</li>
 * </ul>
 * then that InputStream is passed to
 * {@link biz.hammurapi.config.InputStreamConfigurable#configure(InputStream, Map)}
 * to configure instance. If none of aforementioned attributes is present then ConfigurationException is thrown.</li>
 *
 * <li>If instance is instance of {@link biz.hammurapi.config.DomConfigurable} then
 * <ul>
 * 	<li>If element has attribute <code>'url'</code> then that url is opened as InsputStream and parsed to DOM tree</li>
 * 	<li>If element has attribute <code>'file'</code> then that file is opened as InputStream and parsed to DOM tree</li>
 * 	<li>If element has attribute <code>'resource'</code> then that resource is opened as InputStream and parsed to DOM tree.
 * 	Instance's class is used to obtain resource which allows to use relative resource names.</li>
 * </ul>
 * then that parsed document is passed to {@link biz.hammurapi.config.DomConfigurable#configure(Node, Context, ClassLoader)}.
 * If none of the aforementioned attributes is present then element itself is passed to
 * {@link biz.hammurapi.config.DomConfigurable#configure(Node, Context, ClassLoader)}</li>
 *
 * <li>If instance is instance of {@link biz.hammurapi.config.Parameterizable} then
 * 	<ul>
 * 	<li>If there are subelements <code>'parameter'</code> with attribute <code>'name'</code>
 * 	then value of <code>'name'</code> is used as parameter name</li>
 * 	<li>Otherwise names of nested elements used as parameter names</li>
 * 	</ul>
 *  Parameter values are evaluated in the same way as <code>'arg'</code> elements for
 * constructors.
 * 	{@link biz.hammurapi.config.Parameterizable#setParameter(String, Object)} is invoked for each of parameter elements.
 *
 *  {@link biz.hammurapi.config.Parameterizable#setParameter(String, Object)} is also invoked for context entries
 * with names which did not match with parameter names. E.g. if there are two context entries 'age' and 'name' and parameter
 * 'name' then setParameter("name", <I>value of parameter 'name'</I>) will be invoked and after that
 * setParameter("age", <I>value of context entry 'age'</I>) will be invoked.
 * </li>
 *
 * <li>If instance is instance of {@link biz.hammurapi.config.StringConfigurable} then element text is passed to
 * {@link StringConfigurable#configure(String, Map)} method</li>
 *
 * <li>If instance is instance of {@link java.util.Map} then <code>'entry'</code> subelements are iterated; <code>'key'</code>
 * (Configurable through {@link biz.hammurapi.config.DomConfigInfo}) and <code>'value'</code>
 * (Configurable through {@link biz.hammurapi.config.DomConfigInfo}) subelements are evaluated in the same way as
 * <code>'arg'</code> constructors subelements and put to instance by {@link java.util.Map#put(java.lang.Object, java.lang.Object)}</li>
 *
 * <li>If instance is instance of {@link java.util.Collection} then <code>'element'</code> subelements are iterated, elements
 * are istantiated in the same way as constructor arguments and then placed into instance by invoking {@link java.util.Collection#add(java.lang.Object)}
 * method.</li>
 *
 * <li>If none of above conditions are met then reflection is used to inject values into instance fields/properties in a similar way as parameters for
 * {@link biz.hammurapi.config.Parameterizable} are set. Special note about injection: If field type or setter parameter type (target type) is compatible with
 * instantiated value then the value is used as is. Otherwise if target type is compatible with source XML Element then the element is used. If value is instance of
 * {@link biz.hammurapi.config.Wrapper} and wrapper's master is compatible with the target type then the master is used. If wrapper is also a component then its setOwner() and start() methods
 * are invoked before obtaining master. If none of aforementioned conditions are true then value is converted to target type.
 * using {@link biz.hammurapi.convert.CompositeConverter}.</li>
 *
 * <li>If object acceptor is not null then its {@link biz.hammurapi.config.ObjectAcceptor#accept(Object)} is invoked
 * to validate that object has been constructed and configured correctly</li>
 *
 * <li>If instance is instance of {@link biz.hammurapi.config.Validatable} then {@link biz.hammurapi.config.Validatable#validate()} is
 * invoked for the instance to validate itself.
 * </ul>
 *
 * <B>Examples</B>
 * <OL>
 * <li><CODE>&lt;name&gt;Pavel&lt;/name&gt;</CODE> will yield java.lang.String with value 'Pavel'</li>
 * <li><CODE>&lt;age type="java.lang.Integer"&gt;33&lt;/age&gt;</CODE> will yield java.lang.Integer with value '33'</li>
 * <li><CODE>&lt;config type="org.myself.myproject.MyConfig" url="http://myproject.myself.org/MyConfig.xml"/&gt;</CODE> will load
 * configuration from URL and configure MyConfig object</li>
 * <li><PRE>&lt;config type="org.myself.myproject.MyParameterizableConfig"&gt;
 *     &lt;parameter name="pi" type="java.lang.Double"&gt;3.14159&lt;/parameter&gt;
 * &lt;/config&gt;</PRE> will create MyParameterizableConfig object and then invoke its setParameter() method if MyParameterizableConfig
 * implements {@link biz.hammurapi.config.Parameterizable} or invoke setPi() method if there is such method. In lenient mode
 * nothing will happen if there is no setPi() method. Otherwise exception will be thrown.</li>
 * <li><PRE>&lt;config type="org.myself.myproject.MyParameterizableConfig"&gt;
 *     &lt;pi type="java.lang.Double"&gt;3.14159&lt;/pi&gt;
 * &lt;/config&gt;</PRE> same as above.</li>
 * </OL>
 *
 * It is recommended to use XML Beans generated classes instead of this factory.
 *
 * @author Pavel Vlasov
 * @version $Revision: 1.12 $
 */
public class DomConfigFactory {
	public static final String XML_EXTENSION = ".xml";
	public static final String CONFIG_RESOURCE_PREFIX = "META-INF/config/";
	
	public static final String RESOURCE_PREFIX = "resource:";
	public static final String CLASS_LOADER = ClassLoader.class.getName();
	public static final String CODE_EXPRESSION = "@type";
	public static final String MAP_KEY_EXPRESSION = "key";
	public static final String MAP_VALUE_EXPRESSION = "value";	
	
	private static final String CONTEXT_REF = "context-ref";
	public static final Map PRIMITIVES;
	private Context context;
	
	static {
		Map primitives=new HashMap();
		primitives.put("boolean", Boolean.TYPE);
		primitives.put("byte", Byte.TYPE);
		primitives.put("char", Character.TYPE);
		primitives.put("double", Double.TYPE);
		primitives.put("float", Float.TYPE);
		primitives.put("int", Integer.TYPE);
		primitives.put("long", Long.TYPE);
		primitives.put("short", Short.TYPE);		
		PRIMITIVES=Collections.unmodifiableMap(primitives);
	}
	
	private ClassLoader classLoader;

	/**
	 * Default constructor
	 */
	public DomConfigFactory() {
		super();
	}

	/**
	 * Default constructor
	 */
	public DomConfigFactory(Context context) {
		super();
		this.context=context;
	}

	public DomConfigFactory(ClassLoader classLoader) {		
		super();
		this.classLoader=classLoader;
	}
	
	public DomConfigFactory(ClassLoader classLoader, Context context) {		
		super();
		this.classLoader=classLoader;
		this.context=context;
	}
		
	/**
	 * Creates object. Same as create(node, null, null)
	 * @param node
	 * @return
	 * @throws ConfigurationException
	 */
	public Object create(Node node) throws ConfigurationException {
		return create(node, null, null);
	}
	
	/**
	 * Parses file and returns object. Same as create(file, xPath, null, null)
	 * @param file XML configuration file
	 * @param xPath XPath expression, can be null
	 * @return configured object
	 */
	public Object create(File file, String xPath) throws ConfigurationException, IOException {
		return create(file, xPath, null, null);
	}
	
	/**
	 * Parses file and returns object
	 * @param file XML configuration file
	 * @param xPath XPath expression, can be null
	 * @param classAcceptor Class acceptor, validates that class about to be instantiated is 'the right one'
	 * @param objectAcceptor Object acceptor, validates instantiated object.
	 * @return Configured object
	 */
	public Object create(File file, String xPath, ClassAcceptor classAcceptor, ObjectAcceptor objectAcceptor) throws ConfigurationException, IOException {
		try {
			Node node = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(file).getDocumentElement();
			if (xPath!=null) {
				node=DOMUtils.selectSingleNode(node, xPath);
			}			
			return create(node, classAcceptor, objectAcceptor);
		} catch (Exception e) {
			throw new ConfigurationException(e);
		}
	}
	
	/**
	 * Same as create(in, xPath, null, null)
	 * @param in Input stream
	 * @param xPath XPath expression, can be null
	 * @return Configured object
	 * @throws ConfigurationException
	 * @throws IOException
	 */
	public Object create(InputStream in, String xPath) throws ConfigurationException, IOException {
		return create(in, xPath, null, null);
	}
	
	/**
	 * Creates and configures object from InputStream
	 * @param in Input stream
	 * @param xPath XPath expression, can be null
	 * @param classAcceptor
	 * @param objectAcceptor
	 * @return Configured object
	 * @throws ConfigurationException
	 * @throws IOException
	 */
	public Object create(InputStream in, String xPath, ClassAcceptor classAcceptor, ObjectAcceptor objectAcceptor) throws ConfigurationException, IOException {
		try {
			Node node = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(in).getDocumentElement();
			if (xPath!=null) {
				node=DOMUtils.selectSingleNode(node, xPath);
			}
			return create(node, classAcceptor, objectAcceptor);
		} catch (Exception e) {
			throw new ConfigurationException(e);
		}		
	}
	
	/**
	 * Same as create(in, xPath, null, null)
	 * @param in Reader
	 * @param xPath XPath expression, can be null
	 * @return Configured object
	 * @throws ConfigurationException
	 * @throws IOException
	 */
	public Object create(Reader in, String xPath) throws ConfigurationException, IOException {
		return create(in, xPath, null, null);
	}
	
	/**
	 * Creates and configures object from InputStream
	 * @param in Reader
	 * @param xPath XPath expression, can be null
	 * @param classAcceptor
	 * @param objectAcceptor
	 * @return Configured object
	 * @throws ConfigurationException
	 * @throws IOException
	 */
	public Object create(Reader in, String xPath, ClassAcceptor classAcceptor, ObjectAcceptor objectAcceptor) throws ConfigurationException, IOException {
		try {
			Node node = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new InputSource(in)).getDocumentElement();
			if (xPath!=null) {
				node=DOMUtils.selectSingleNode(node, xPath);
			}
			return create(node, classAcceptor, objectAcceptor);
		} catch (Exception e) {
			throw new ConfigurationException(e);
		}		
	}
	
	/**
	 * Same as create(url, xPath, null, null)
	 * @param url URL to read configuration from
	 * @param xPath XPath expression, can be null
	 * @return Configured object
	 * @throws ConfigurationException
	 * @throws IOException
	 */
	public Object create(URL url, String xPath) throws ConfigurationException, IOException {
		return create(url, xPath, null, null);
	}
	
	/**
	 * Creates and configures object from URL
	 * @param url Url
	 * @param xPath XPath expression, can be null
	 * @param classAcceptor
	 * @param objectAcceptor
	 * @return Configured object
	 * @throws ConfigurationException
	 * @throws IOException
	 */
	public Object create(URL url, String xPath, ClassAcceptor classAcceptor, ObjectAcceptor objectAcceptor) throws ConfigurationException, IOException {
		try {
			Node node = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(url.openStream()).getDocumentElement();
			if (xPath!=null) {
				node=DOMUtils.selectSingleNode(node, xPath);
			}			
			return create(node, classAcceptor, objectAcceptor);
		} catch (Exception e) {
			throw new ConfigurationException(e);
		}		
	}
	
	/**
	 * Creates and configures object
	 * @param node
	 * @param classAcceptor
	 * @param objectAcceptor
	 * @param cxpa Cached XPath API to accelerate XPath expressions evaluation.
	 * @return Configured object
	 * @throws ConfigurationException
	 */
	public Object create(Node node, ClassAcceptor classAcceptor, ObjectAcceptor objectAcceptor) throws ConfigurationException {		
		try {			
			String className=DOMUtils.eval(node, CODE_EXPRESSION).toString();			
			if (className.trim().length()==0) {
				if (classAcceptor!=null) {
					classAcceptor.accept(String.class);
				}
				return DOMUtils.eval(node, "text()").toString();
			} 
			
			Class clazz = forName(className);
			if (classAcceptor!=null) {
				classAcceptor.accept(clazz);
			}
			
			Object instance;
			Node constructorNode=DOMUtils.selectSingleNode(node, "constructor");
			if (constructorNode==null) {
				String body=DOMUtils.eval(node, "text()").toString().trim();
				if (body.length()==0 || DomConfigurable.class.isAssignableFrom(clazz)) {
					instance=clazz.newInstance();
				} else {
					Constructor c=clazz.getConstructor(new Class[] {String.class});
					instance=c.newInstance(new Object[] {body});
				}
			} else {
				NodeList argList=DOMUtils.selectNodeList(constructorNode, "arg");
				Class[] argTypes=new Class[argList.getLength()];
				for (int i=0; i<argList.getLength(); i++) {
					String argTypeName=DOMUtils.eval(argList.item(i), CODE_EXPRESSION).toString();
					if (argTypeName.trim().length()==0) {
						argTypes[i]=String.class;						
					} else {
						argTypes[i]=(Class) PRIMITIVES.get(argTypeName);
						if (argTypes[i]==null) {
							argTypes[i]=forName(argTypeName);
						}
					}
				}								
				
				Constructor constructor=clazz.getConstructor(argTypes);
				Object[] args=new Object[argList.getLength()];
				for (int i=0; i<argList.getLength(); i++) {
					Element argElement = ((Element) argList.item(i));
					if (argTypes[i].isPrimitive()) {
						args[i] = ConvertingService.convert(
								DOMUtils.eval(argList.item(i), "text()").toString(),
								argTypes[i]);							
					} else if (argElement.hasAttribute(CONTEXT_REF)) {
						args[i]=context.get(argElement.getAttribute(CONTEXT_REF));
					} else {
						args[i]=create(argList.item(i),null,null);
					}
				}
				instance=constructor.newInstance(args);
			}
					
			if (hasAttribute(node, "url") && instance instanceof URLConfigurable) {
				((URLConfigurable) instance).configure(new URL(((Element) node).getAttribute("url")), context, classLoader);
			} else if (hasAttribute(node, "file") && instance instanceof FileConfigurable) {
				((FileConfigurable) instance).configure(new File(((Element) node).getAttribute("file")), context, classLoader);
			} else if (instance instanceof InputStreamConfigurable) {
				if (hasAttribute(node, "url")) {
					new URL2InputStreamConfigurableAdapter((InputStreamConfigurable) instance).configure(new URL(((Element) node).getAttribute("url")), context, classLoader);
				} else if (hasAttribute(node, "file")) {
					new File2InputStreamConfigurableAdapter((InputStreamConfigurable) instance).configure(new File(((Element) node).getAttribute("file")), context, classLoader);
				} else if (hasAttribute(node, "resource")) {					
					((InputStreamConfigurable) instance).configure(clazz.getResourceAsStream(((Element) node).getAttribute("resource")), context, classLoader);
				} else {
					throw new ConfigurationException("Cannot configure "+instance.getClass().getName());
				}
			} else if (instance instanceof DomConfigurable) { // Dom configurable

				if (hasAttribute(node, "url")) {
					new URL2InputStreamConfigurableAdapter(
						new InputStream2DomConfigurableAdapter(
							(DomConfigurable) instance)).configure(new URL(((Element) node).getAttribute("url")), context, classLoader);
				} else if (hasAttribute(node, "file")) {
					new File2InputStreamConfigurableAdapter(
						new InputStream2DomConfigurableAdapter(
							(DomConfigurable) instance)).configure(new File(((Element) node).getAttribute("file")), context, classLoader);
				} else if (hasAttribute(node, "resource")) {					
						new InputStream2DomConfigurableAdapter((DomConfigurable) instance).configure(getClass().getResourceAsStream(((Element) node).getAttribute("resource")), context, classLoader);
				} else {
					((DomConfigurable) instance).configure(node, context, classLoader);
				}
			} else if (instance instanceof Parameterizable) { // Parameterizable

				Map localContext=new HashMap();
				
				if (DOMUtils.selectSingleNode(node, "parameter[@name]")==null) { 
					// Use element names as parameter names

					NodeList nl=node.getChildNodes();
					for (int i=0; i<nl.getLength(); i++) {
						if (nl.item(i) instanceof Element) {
							String parameterName = nl.item(i).getNodeName();							
							((Parameterizable) instance).setParameter(parameterName, getValue((Element) nl.item(i)));
							localContext.remove(parameterName);
						}
					}
				} else {
					NodeList nl=DOMUtils.selectNodeList(node, "parameter[@name]");
					for (int i=0, l=nl.getLength(); i<l; ++i) {
						Element paramElement = (Element) nl.item(i);
						String parameterName = paramElement.getAttribute("name");
						((Parameterizable) instance).setParameter(parameterName, getValue(paramElement));
						localContext.remove(parameterName);
					} 
				}				
				
				Iterator it=localContext.entrySet().iterator();
				while (it.hasNext()) {
					Map.Entry entry=(Map.Entry) it.next();
					((Parameterizable) instance).setParameter((String) entry.getKey(), entry.getValue());
				}
			} else if (instance instanceof StringConfigurable) { // String configurable

				((StringConfigurable) instance).configure(DOMUtils.eval(node, "text()").toString(), context);
			} else if (instance instanceof Map) { // Map

				NodeList nl=DOMUtils.selectNodeList(node, "entry");
				for (int i=0, l=nl.getLength(); i<l; ++i) {
					Element entryElement = (Element) nl.item(i);
					((Map) instance).put(getValue((Element) DOMUtils.selectSingleNode(entryElement,MAP_KEY_EXPRESSION)),
						getValue((Element) DOMUtils.selectSingleNode(entryElement,MAP_VALUE_EXPRESSION)));
				}				
			} else if (instance instanceof Collection) { // Collection

				NodeList nl=DOMUtils.selectNodeList(node, "element");
				for (int i=0, l=nl.getLength(); i<l; ++i) {
					Element element = (Element) nl.item(i);
					((Collection) instance).add(getValue(element));
				}								
			} else {
				Map toInject=new HashMap();
				Context localContext=new MapContext(toInject, context);
				
				if (DOMUtils.selectSingleNode(node, "parameter[@name]")==null) { 
					// Use element names as parameter names

					NodeList nl=node.getChildNodes();
					for (int i=0; i<nl.getLength(); i++) {
						if (nl.item(i) instanceof Element) {
							String name = nl.item(i).getNodeName();							
							Element element = (Element) nl.item(i);
							Object existing = toInject.get(name);
							if (existing==null) {
								toInject.put(name, getInjectEntry(element));
							} else if (existing instanceof InjectEntryCollection) {
								((Collection) existing).add(getInjectEntry(element));
							} else {
								Collection col = new InjectEntryCollection();
								col.add(existing);
								col.add(getInjectEntry(element));
								toInject.put(name, col);
							}
						}
					}
				} else {
					NodeList nl =DOMUtils.selectNodeList(node, "parameter[@name]");
					for (int i=0, l=nl.getLength(); i<l; ++i) {
						Element paramElement = (Element) nl.item(i);
						String name = paramElement.getAttribute("name");
						Object existing = toInject.get(name);
						if (existing==null) {
							toInject.put(name, getInjectEntry(paramElement));
						} else if (existing instanceof InjectEntryCollection) {
							((Collection) existing).add(getInjectEntry(paramElement));
						} else {
							Collection col = new InjectEntryCollection();
							col.add(existing);
							col.add(getInjectEntry(paramElement));
							toInject.put(name, col);
						}
					} 
				}
				
				inject(instance, localContext);
			}
			
			if (objectAcceptor!=null) {
				objectAcceptor.accept(instance);
			}
			
			if (instance instanceof Validatable) {
				((Validatable) instance).validate();
			}
						
			return instance;
		} catch (Exception e) {
			throw new ConfigurationException(e);
		}
	}
	
	/**
	 * Marker class
	 * @author Tatyana Konukova
	 *
	 */
	private static class InjectEntryCollection extends ArrayList {
		
	}
	
	/**
	 * Holder for element and its instantiation.
	 * @author Pavel Vlasov
	 * @revision $Revision$
	 */
	private class InjectEntry {
		Element element;
		Object instance;
		
		/**
		 * @param element
		 * @param instance
		 */
		public InjectEntry(Element element, Object instance) {
			super();
			this.element = element;
			this.instance = instance;
		}
				
	}

    /**
	 * @param className
	 * @return
	 * @throws ClassNotFoundException
	 */
	private Class forName(String className) throws ClassNotFoundException {
		return classLoader==null ? Class.forName(className) : classLoader.loadClass(className);
	}

	/**
	 * Converts instantiated value to InjectEntry
	 * @param cxpa
	 * @param parameterElement
	 * @return
	 * @throws ConfigurationException
	 */
	private InjectEntry getInjectEntry(Element parameterElement) throws ConfigurationException {
		return new InjectEntry(parameterElement, getValue(parameterElement));
	}
	
	/**
	 * @param cxpa
	 * @param parameterElement
	 * @return
	 * @throws ConfigurationException
	 */
	private Object getValue(Element parameterElement) throws ConfigurationException {
		if (parameterElement.hasAttribute(CONTEXT_REF)) {
			return context.get((parameterElement).getAttribute(CONTEXT_REF));
		}
		
		return create(parameterElement,null,null);
	}
	
	
	/**
	 * Converts InjectEntry to target class.
	 * Takes into account wrappers and org.w3c.Element
	 * @param entry
	 * @param targetClass
	 * @return
	 */
	private static Object getValue(Object value, Class targetClass, Object owner) {
		
		if (value==null) {
			return null;
		}
		
		if (value instanceof InjectEntryCollection) {
			return value;
		}
		
		if (value instanceof InjectEntry) {
			InjectEntry injectEntry=(InjectEntry) value;
			
			// If instance is already compatible - return instance.

			if (targetClass.isInstance(injectEntry.instance)) {
				return injectEntry.instance;
			}
			
			// If element is compatible - return element

			if (targetClass.isInstance(injectEntry.element)) {
				return injectEntry.element;
			}
			
			// If is Wrapper and master is compatible - return master

			if (injectEntry.instance instanceof Wrapper) {			
				//Start wrapper if it is also a component.

				if (injectEntry.instance instanceof Component) {
					try {
						Component component = (Component) injectEntry.instance;
						component.setOwner(owner);
						component.start();
					} catch (ConfigurationException e) {
						throw new RuntimeConfigurationException("Could not start wrapper component "+injectEntry.instance.getClass().getName()+": "+e, e);
					}
				}
				Object master=((Wrapper) injectEntry.instance).getMaster();
				if (targetClass.isInstance(master)) {
					return master;
				}
			}
	
			// The last resort - use converter.

			return ConvertingService.convert(injectEntry.instance, targetClass);
		}
		
		// If instance is already compatible - return instance.

		if (targetClass.isInstance(value)) {
			return value;
		}
			
		// The last resort - use converter.

		return ConvertingService.convert(value, targetClass);
	}

	/**
     * Sets property (field or through setter or appender) using reflection.
     * This method can inject single or multiple values from the context to the instance
     * using setXXX(argType arg), setXXX(argType[] arg), setXXX(Collection args), or
     * addXXX(argType arg). For multi-value injections the context shall return collection,
     * array, or iterator instance from its get() method.
	 * @param instance
     * @param context Source of data to inject.
	 */
	public static void inject(Object instance, Context context) throws ConfigurationException {
		Method[] ma=instance.getClass().getMethods();
		
		Set usedKeys = new HashSet();
		LinkedList setters = new LinkedList();
		LinkedList appenders = new LinkedList();
		for (int i=0; i<ma.length; i++) {
			if (Modifier.isPublic(ma[i].getModifiers()) && ma[i].getParameterTypes().length==1) {
				if (ma[i].getName().startsWith("set")) {
					setters.add(ma[i]);
				} else if (ma[i].getName().startsWith("add")) {
					appenders.add(ma[i]);
				}
			}
		}
		
		// Injection of single values using setters.

		Method[] sa = (Method[]) setters.toArray(new Method[setters.size()]);
		for (int i=0; i<sa.length; ++i) {
			Method m=sa[i];
			if (m!=null) {
				String methodName = m.getName();
				int methodIndex = i;
				int methodNameLength = methodName.length();
				Class pt = m.getParameterTypes()[0];
				String key=methodNameLength==3 ? pt.getName() : (Character.toLowerCase(methodName.charAt(3)) + (methodNameLength<5 ? "" : methodName.substring(4)));
				if (!usedKeys.contains(key)) {
					Object value=getValue(context.get(key), pt, instance);
					
					// Take single value.

					if (value instanceof InjectEntryCollection) {
						if (!((Collection) value).isEmpty() && !pt.isArray()) {
							value = getValue(((InjectEntryCollection) value).get(0), pt, instance);
						} else {
							value = null;
						}
					}
									
					if (value!=null) {
						for (int j=0; j<sa.length; ++j) {
							Method m2=sa[j];
							if (m2!=null && m2.getName().equals(m.getName()) && pt.isAssignableFrom(m2.getParameterTypes()[0])) {
								m=m2;
								methodIndex=j;
							}
						}
						
						try {
							m.invoke(instance, new Object[] {value});
						} catch (Exception e) {
							throw new ConfigurationException(e);
						}
						
						usedKeys.add(key);
						setters.remove(m);
						sa[methodIndex]=null;
					}			
				}
			}
		}
		
		// Injection of single values using appenders.

		Method[] aa = (Method[]) appenders.toArray(new Method[appenders.size()]);
		for (int i=0; i<aa.length; ++i) {
			Method m=aa[i];
			if (m!=null) {
				String methodName = m.getName();
				int methodIndex = i;
				int methodNameLength = methodName.length();
				Class pt = m.getParameterTypes()[0];
				String key=methodNameLength==3 ? pt.getName() : (Character.toLowerCase(methodName.charAt(3)) + (methodNameLength<5 ? "" : methodName.substring(4)));
				if (!usedKeys.contains(key)) {
					Object cValue = context.get(key);
					Object value=getValue(cValue, pt, instance);
											
					if (value!=null && !(value instanceof InjectEntryCollection)) {
						for (int j=0; j<aa.length; ++j) {
							Method m2=aa[j];
							if (m2!=null && m2.getName().equals(m.getName()) && pt.isAssignableFrom(m2.getParameterTypes()[0])) {
								m=m2;
								methodIndex=j;
							}
						}
						
						try {
							m.invoke(instance, new Object[] {value});
						} catch (Exception e) {
							throw new ConfigurationException(e);
						}
						
						usedKeys.add(key);
						appenders.remove(m);
						aa[methodIndex] = null;
					}			
				}
			}
		}
		
		// Injection of multiple values using appenders.

		Iterator ait = appenders.iterator();
		while (ait.hasNext()) {
			Method m=(Method) ait.next();
			String methodName = m.getName();
			int methodNameLength = methodName.length();
			Class pt = m.getParameterTypes()[0];
			String key=methodNameLength==3 ? pt.getName() : (Character.toLowerCase(methodName.charAt(3)) + (methodNameLength<5 ? "" : methodName.substring(4)));
			if (!usedKeys.contains(key)) {
				Object val=context.get(key);
				Iterator vit = null;
				if (val instanceof Iterator) {
					vit = (Iterator) val;
				} else if (val instanceof Collection) {
					vit = ((Collection) val).iterator();
				} else if (val!=null && val.getClass().isArray()) {
					Collection col = new ArrayList();
					for (int i=0, l=Array.getLength(val); i<l; ++i) {
						col.add(Array.get(val, i));
					}
					vit = col.iterator();
				}
				
				if (vit!=null) {
					usedKeys.add(key);
					while (vit.hasNext()) {
						Object value = getValue(vit.next(), pt, instance);
						if (value!=null) {				
							try {
								m.invoke(instance, new Object[] {value});
							} catch (Exception e) {
								throw new ConfigurationException(e);
							}
						}
					}			
					ait.remove();
				}
			}
		}
								
		// Injection of multiple values using setters which take collections.

		Iterator sit=setters.iterator();
		while (sit.hasNext()) {
			Method m=(Method) sit.next();
			String methodName = m.getName();
			int methodNameLength = methodName.length();
			Class pt = m.getParameterTypes()[0];
			String key=methodNameLength==3 ? pt.getName() : (Character.toLowerCase(methodName.charAt(3)) + (methodNameLength<5 ? "" : methodName.substring(4)));
			if (!usedKeys.contains(key) && pt.isAssignableFrom(ArrayList.class)) {
				List values = new ArrayList();
				
				Object val=context.get(key);
				if (val instanceof Iterator) {
					Iterator vit = (Iterator) val;
					while (vit.hasNext()) {
						values.add(getValue(vit.next(), Object.class, instance));
					}
					
				} else if (val instanceof Collection) {
					Iterator vit = ((Collection) val).iterator();
					while (vit.hasNext()) {
						values.add(getValue(vit.next(), Object.class, instance));
					}
				} else if (val!=null && val.getClass().isArray()) {
					for (int i=0, l=Array.getLength(val); i<l; ++i) {
						values.add(Array.get(val, i));
					}
				} else {
					Object vl = getValue(val, Object.class, instance);
					if (vl!=null) {
						values.add(vl);
					}
				}
				
				if (!values.isEmpty()) {
					try {
						m.invoke(instance, new Object[] {values});
						usedKeys.add(key);
					} catch (Exception e) {
						throw new ConfigurationException(e);
					}
				}
				sit.remove();
			}
		}
		
		// Injection of multiple values using setters which take arrays.

		sit=setters.iterator();
		while (sit.hasNext()) {
			Method m=(Method) sit.next();
			String methodName = m.getName();
			int methodNameLength = methodName.length();
			Class pt = m.getParameterTypes()[0];
			String key=methodNameLength==3 ? pt.getName() : (Character.toLowerCase(methodName.charAt(3)) + (methodNameLength<5 ? "" : methodName.substring(4)));
			if (!usedKeys.contains(key) && pt.isArray()) {
				List values = new ArrayList();
				
				Object val=context.get(key);
				Class componentType = pt.getComponentType();
				if (val instanceof Iterator) {
					Iterator vit = (Iterator) val;
					while (vit.hasNext()) {
						values.add(getValue(vit.next(), componentType, instance));
					}
				} else if (val instanceof Collection) {
					Iterator vit = ((Collection) val).iterator();
					while (vit.hasNext()) {
						values.add(getValue(vit.next(), componentType, instance));
					}
				} else if (val!=null && val.getClass().isArray()) {
					for (int i=0, l=Array.getLength(val); i<l; ++i) {
						values.add(Array.get(val, i));
					}
				} else {
					Object vl = getValue(val, componentType, instance);
					if (vl!=null) {
						values.add(vl);
					}
				}
				
				if (!values.isEmpty()) {
					try {
						Object array = Array.newInstance(componentType, values.size());
						Iterator vit = values.iterator();
						for (int i=0; vit.hasNext(); ++i) {
							Array.set(array, i, vit.next());
						}
						m.invoke(instance, new Object[] {array});
						usedKeys.add(key);
					} catch (Exception e) {
						throw new ConfigurationException(e);
					}
				}
				sit.remove();
			}
		}
		
		// Injection of first of multiple values using setters.

		sit = setters.iterator();
		while (sit.hasNext()) {
			Method m=(Method) sit.next();
			String methodName = m.getName();
			int methodNameLength = methodName.length();
			Class pt = m.getParameterTypes()[0];
			String key=methodNameLength==3 ? pt.getName() : (Character.toLowerCase(methodName.charAt(3)) + (methodNameLength<5 ? "" : methodName.substring(4)));
			if (!usedKeys.contains(key)) {
				Object val=context.get(key);
				Iterator vit = null;
				if (val instanceof Iterator) {
					vit = (Iterator) val;
				} else if (val instanceof Collection) {
					vit = ((Collection) val).iterator();
				} else if (val!=null && val.getClass().isArray()) {
					Collection col = new ArrayList();
					for (int i=0, l=Array.getLength(val); i<l; ++i) {
						col.add(Array.get(val, i));
					}
					vit = col.iterator();
				}
				
				if (vit!=null) {
					usedKeys.add(key);
					while (vit.hasNext()) {
						Object value = getValue(vit.next(), pt, instance);
						if (value!=null) {				
							try {
								m.invoke(instance, new Object[] {value});
							} catch (Exception e) {
								throw new ConfigurationException(e);
							}
							break;
						}
					}			
					sit.remove();
				}
			}
		}
		
		
		Field[] fa=instance.getClass().getFields();
		for (int i=0; i<fa.length; i++) {
			if (Modifier.isPublic(fa[i].getModifiers()) && usedKeys.add(fa[i].getName())) {
				try {
					Object value=getValue(context.get(fa[i].getName()), fa[i].getType(), instance);
					if (value!=null) {
						fa[i].set(instance, value);
					}
				} catch (IllegalArgumentException e) {
					throw new ConfigurationException(e);
				} catch (IllegalAccessException e) {
					throw new ConfigurationException(e);
				}
			}
		}
	}
	
	/**
     * @param node
     * @return
     */
    private boolean hasAttribute(Node node, String attribute) {
        return node instanceof Element && ((Element) node).hasAttribute(attribute);
    }  
        
	public static void main(final String[] args) {
		final long start=System.currentTimeMillis();
		if (args.length==0) {
			System.err.println("Usage: java <options> "+DomConfigFactory.class.getName()+" <configuration URL> [<additional parameters>]");
			System.exit(1);
		}
		
		final boolean stopInHook = "yes".equalsIgnoreCase(System.getProperty("biz.hammurapi.config.DomConfigFactory:shutdownHook"));
		final Object[] oa = {null};
		
		if (stopInHook) {
			Runtime.getRuntime().addShutdownHook(
					new Thread() {
						public void run() {
							if (oa[0] instanceof Component) {
								try {							
									((Component) oa[0]).stop();
								} catch (ConfigurationException e) {
									System.err.println("Could not properly stop "+oa[0]);
									e.printStackTrace();
								}
								System.out.println("Total execution time: "+((System.currentTimeMillis()-start)/1000)+" sec.");
							}
						}
					});			
		}
						
		RestartCommand run = new RestartCommand() {
			
			int attempt;
			
			public void run() {
				try {
					if (attempt > 0) {	
						long restartDelay = getRestartDelay();
						System.out.print("Restarting in "+restartDelay+" milliseconds. Attempt " + (attempt+1));
						try {
							Thread.sleep(restartDelay);
						} catch (InterruptedException ie) {
							ie.printStackTrace();
							System.exit(4);
						}
					}
					
					++attempt;
					
					DomConfigFactory factory=new DomConfigFactory();
					
					if (args[0].startsWith("url:")) {
						oa[0] = factory.create(new URL(args[0].substring("url:".length())), null);
					} else if (args[0].startsWith(RESOURCE_PREFIX)) {
						InputStream stream = DomConfigFactory.class.getClassLoader().getResourceAsStream(args[0].substring(RESOURCE_PREFIX.length()));
						if (stream==null) {
							System.err.println("Resource does not exist.");
							System.exit(1);
						}
						oa[0] = factory.create(stream, null);
					} else {
						File file = new File(args[0]);
						if (!file.exists()) {
							System.err.println("File does not exist or not a file.");
							System.exit(1);
						}
						if (!file.isFile()) {
							System.err.println("Not a file.");
							System.exit(1);
						}
						oa[0] = factory.create(file, null);
					}

					if (oa[0] instanceof Component) {
						((Component) oa[0]).start();
					}
					
					if (oa[0] instanceof Restartable) {
						((Restartable) oa[0]).setRestartCommand(this);
					}
					
					try {
						if (oa[0] instanceof Context) {
							Context container=(Context) oa[0];
							for (int i=1; i<args.length; i++) {
								Object toExecute=container.get(args[i]);
								if (toExecute instanceof Command) {
									((Command) toExecute).execute(args);
								} else if (toExecute==null) {						
									System.err.print("[WARN] Name not found: " +args[i]);
								} else {
									System.err.print("[WARN] Not executable: (" +args[i]+") "+toExecute.getClass().getName());						
								}
							}					
						} else if (oa[0] instanceof Command) {
							((Command) oa[0]).execute(args);
						}
					} finally {			
						if (oa[0] instanceof Component) {
							if (!stopInHook) {
								((Component) oa[0]).stop();
							}
						}
					}
				} catch (MalformedURLException e) {
					System.err.println("Bad configuration URL: "+args[0]);
					System.exit(2);
				} catch (Exception e) {
					e.printStackTrace();
					if (attempt > 1) {	
						if (oa[0] instanceof Component) {
							try {
								((Component) oa[0]).stop();
							} catch (Exception ex) {
								System.err.println("Cannot stop component before restart: "+e);
								ex.printStackTrace();
							}
						}
						new Thread(this, "Restart thread "+getAttempt()).start(); // Use a new thread to avoid stack overflowing in the case of too many attempts.

					} else {					
						System.exit(3);
					}
				}
			}

			public int getAttempt() {
				return attempt;
			}

			public long getRestartDelay() {
				String rd = System.getProperty(RESTART_DELAY_PROPERTY);
				if (rd!=null) {
					try {
						return Long.parseLong(rd);
					} catch (NumberFormatException e) {
						// Ignore

					}
				}
				
				return DEFAULT_RESTART_DELAY;
			}
		};
		
		run.run();
		
	}
	
	/**
	 * Loads providers for a given service. Providers are loaded anew at every
	 * invocation of this method.
	 * @param <T>
	 * @param service Service class.
	 * @param classLoader Class loader
	 * @return Iterator of providers of given class.
	 * @throws ConfigurationException
	 */
	public static Iterator loadProviders(final Class service, final ClassLoader classLoader) {
		final String resName = CONFIG_RESOURCE_PREFIX+service.getName()+XML_EXTENSION;
		return new Iterator() {
			
			private Enumeration resources;
			DomConfigFactory factory;
			
			private synchronized Enumeration getResources() {
				if (resources==null) {
					try {
						if (classLoader==null) {// System classes

							ClassLoader alternativeClassLoader = DuckConverterFactory.getChildClassLoader(service.getClassLoader(), this.getClass().getClassLoader());
							if (alternativeClassLoader==null) {
								alternativeClassLoader = this.getClass().getClassLoader();
							}
							resources = alternativeClassLoader==null ? ClassLoader.getSystemResources(resName) : alternativeClassLoader.getResources(resName);								
							factory = new DomConfigFactory(alternativeClassLoader);
						} else {
							resources = classLoader.getResources(resName);
							factory = new DomConfigFactory(classLoader);
						}
							
					} catch (IOException e) {
						throw new RuntimeConfigurationException(e);
					}					
				}
				return resources;
			}

			public boolean hasNext() {
				return getResources().hasMoreElements();
			}

			public Object next() {
				try {
					return factory.create((URL) getResources().nextElement(), null);
				} catch (Exception e) {
					throw new RuntimeConfigurationException(e);
				}
			}

			public void remove() {
				throw new UnsupportedOperationException("This operation is not supported");				
			}
			
		};
		
	}

}