/*
    * Copyright 2006 The Xanot team
    */
   package org.xanot;
   
   import org.apache.log4j.Logger;
   
   import org.xanot.structure.AttributeSetRule;
   import org.xanot.structure.CloseCollectionInstanceRule;
  import org.xanot.structure.CloseInstanceRule;
  import org.xanot.structure.CreateInstanceRule;
  import org.xanot.structure.ParentReferenceRule;
  import org.xanot.structure.PropertyCollectionSetRule;
  import org.xanot.structure.PropertySetRule;
  
  import org.xanot.util.StackMap;
  import org.xanot.util.UniquePairs;
  
  import org.xml.sax.Attributes;
  import org.xml.sax.SAXException;
  import org.xml.sax.SAXParseException;
  import org.xml.sax.helpers.DefaultHandler;
  
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  
  import java.math.BigInteger;
  
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.StringTokenizer;
  import java.util.Collection;
  
  /***
   * SAX xml handler. This is the actual engine that maps xml data into the model
   * based on rules profided by rule builder.
   * 
   * @author Ferdinand Neman (newm4n _at_ gmail.com)
   */
  public class XanotSAXHandler extends DefaultHandler {
  	Logger log = Logger.getLogger(XanotSAXHandler.class);
  
  	private RuleBuilder ruleBuilder = null;
  
  	private StackMap<String, Object> stack = null;
  
  	private Object rootObject = null;
  
  	private String characterData = "";
  
  	private Collection<SAXParseException> warnings = new ArrayList<SAXParseException>();
  
  	private Collection<SAXParseException> errors = new ArrayList<SAXParseException>();
  
  	private Collection<SAXParseException> fatals = new ArrayList<SAXParseException>();
  
  	private boolean stopOnWarning = true;
  
  	private boolean stopOnError = true;
  
  	private boolean stopOnFatal = true;
  
  	/***
  	 * Creates a new XanotSAXHandler object.
  	 * 
  	 * @param ruleBuilder
  	 *            Rule builder that provides maping rule.
  	 */
  	public XanotSAXHandler(RuleBuilder ruleBuilder) {
  		setRuleBuilder(ruleBuilder);
  	}
  
  	/***
  	 * Get the instance of root object. Call this method after the parsing
  	 * process have fully finished.
  	 * 
  	 * @return Returns the rootObject.
  	 */
  	public Object getRootObject() {
  		return rootObject;
  	}
  
  	/***
  	 * Get the rule builder that providing rules.
  	 * 
  	 * @return Returns the ruleBuilder.
  	 */
  	public RuleBuilder getRuleBuilder() {
  		return ruleBuilder;
  	}
  
  	/***
  	 * Set the rule builder that providing rules.
  	 * 
  	 * @param ruleBuilder
  	 *            The ruleBuilder to set.
 	 */
 	public void setRuleBuilder(RuleBuilder ruleBuilder) {
 		if (ruleBuilder == null) {
 			throw new NullPointerException();
 		}
 
 		this.ruleBuilder = ruleBuilder;
 	}
 
 	/***
 	 * Triggered by SAX parser when encountered character data in the xml.
 	 * 
 	 * @param ch
 	 *            Character data
 	 * @param start
 	 *            Start offset in the array
 	 * @param length
 	 *            Length of data starting from the offset.
 	 * @throws SAXException
 	 *             Thrown if anything goes wrong on the parsing.
 	 */
 	@Override
 	public void characters(char[] ch, int start, int length)
 			throws SAXException {
 		String data = new String(ch, start, length).trim();
 
 		if (data.length() > 0) {
 			characterData = data;
 			log.debug("Character : \"" + characterData + "\"");
 		}
 	}
 
 	/***
 	 * Triggered by SAX parser when the xml document ends.
 	 * 
 	 * @throws SAXException
 	 *             Thrown if anything goes wrong on the parsing.
 	 */
 	@Override
 	public void endDocument() throws SAXException {
 		stack = null;
 	}
 
 	/***
 	 * Triggered by SAX parser when an end tag is encounter.
 	 * 
 	 * @param uri
 	 *            URI element
 	 * @param localName
 	 *            Local name
 	 * @param qName
 	 *            Tag name
 	 * @throws SAXException
 	 *             Thrown if anything goes wrong on the parsing.
 	 */
 	@Override
 	public void endElement(String uri, String localName, String qName)
 			throws SAXException {
 		String path = stack.getStringKeyPath() + "/" + qName;
 		String[] paths = getPosiblePathAlternatives(path);
 
 		log.debug("Closing tag </" + qName + ">");
 		log.debug("------------------------------");
 		log.debug("Current stack path " + stack.getStringKeyPath());
 
 		PropertySetRule[] propertyRules = ruleBuilder.getPropertySetRule(paths);
 		log.debug("PropertySetRule effected : " + propertyRules.length);
 
 		PropertyCollectionSetRule[] propertyCollectionSetRule = ruleBuilder
 				.getPropertyCollectionSetRule(paths);
 		log.debug("PropertyCollectionSetRule effected : "
 				+ propertyCollectionSetRule.length);
 
 		boolean propertyWins = false;
 
 		if ((propertyRules.length > 0)
 				|| (propertyCollectionSetRule.length > 0)) {
 			propertyWins = true;
 		}
 
 		CloseInstanceRule[] closeInstanceRule = ruleBuilder
 				.getCloseInstanceRule(getPosiblePathAlternatives(stack
 						.getStringKeyPath()));
 		log.debug("CloseInstanceRules effected : " + closeInstanceRule.length);
 
 		CloseCollectionInstanceRule[] closePropColRule = ruleBuilder
 				.getCloseCollectionInstanceRule(getPosiblePathAlternatives(stack
 						.getStringKeyPath()));
 		log.debug("CloseCollectionInstanceRule effected : "
 				+ closePropColRule.length);
 
 		if (propertyWins) {
 			log
 					.debug("Only PropertySetRule or PropertyCollectionSetRule is executed");
 		}
 
 		if ((closeInstanceRule.length > 0) && !propertyWins) {
 			Object parentObj = stack.peekParentValue();
 			Class parentClass = parentObj.getClass();
 
 			for (CloseInstanceRule closeRule : closeInstanceRule) {
 				log.debug("MATCH CloseInstanceRule. " + closeRule.getPath());
 
 				Method setter = getSetterMethod(parentClass, closeRule
 						.getPropertyName());
 
 				if (setter == null) {
 					log.error("Not found setter method for property "
 							+ closeRule.getPropertyName() + " on class "
 							+ parentClass.getName());
 				} else {
 					try {
 						log.debug("Setter Method " + setter.getName()
 								+ " on class " + parentClass.getName()
 								+ " is invoked with parameter "
 								+ stack.getValue(stack.size() - 1).getClass());
 						setter.invoke(parentObj, new Object[] { stack
 								.getValue(stack.size() - 1) });
 					} catch (IllegalArgumentException e) {
 						log.error("Setter Method "
 								+ setter.getName()
 								+ " on class "
 								+ parentClass.getName()
 								+ " is not accepting argument of type "
 								+ stack.getValue(stack.size() - 1).getClass()
 										.getName(), e);
 					} catch (IllegalAccessException e) {
 						log.error("Setter Method " + setter.getName()
 								+ " on class " + parentClass.getName()
 								+ " is not accessible.", e);
 					} catch (InvocationTargetException e) {
 						log.error("Setter Method " + setter.getName()
 								+ " on class " + parentClass.getName()
 								+ " is not invocable on instance.", e);
 					}
 				}
 			}
 
 			Object o = stack.pop();
 			log.debug("POP " + o.getClass().getName() + ". Stack : "
 					+ stack.size());
 		} else if ((closePropColRule.length > 0) && !propertyWins) {
 			Object topObject = stack.getValue(stack.size() - 1);
 			Class topClass = topObject.getClass();
 			Object parentObj = stack.peekParentValue();
 			Class parentClass = parentObj.getClass();
 			UniquePairs pairs = new UniquePairs();
 
 			for (CloseCollectionInstanceRule ccir : closePropColRule) {
 				log.debug("MATCH PropertyCollectionSetRule. " + ccir.getPath());
 
 				Method setterMethod = null;
 
 				for (Method met : parentClass.getMethods()) {
 					if (met.getName().equals(ccir.getMethodName())) {
 						setterMethod = met;
 
 						break;
 					}
 				}
 
 				if (setterMethod != null) {
 					if (!pairs.isPairExist(setterMethod, topObject)) {
 						pairs.addPair(setterMethod, topObject);
 
 						Class[] paramTypes = setterMethod.getParameterTypes();
 
 						if (paramTypes.length == 1) {
 							Class paramType = paramTypes[0];
 
 							if (paramType.equals(topClass)) {
 								try {
 									log.debug("Setter Method "
 											+ setterMethod.getName()
 											+ " on class "
 											+ parentClass.getName()
 											+ " is invoked with parameter "
 											+ topClass.getName());
 
 									if (topObject == null) {
 										log.fatal("Null top object");
 										System.exit(-1);
 									}
 
 									if (parentObj == null) {
 										log.fatal("Null parent object");
 										System.exit(-1);
 									}
 
 									setterMethod.invoke(parentObj, topObject);
 								} catch (IllegalArgumentException e) {
 									log
 											.error(
 													"Setter Method "
 															+ setterMethod
 																	.getName()
 															+ " on class "
 															+ parentClass
 																	.getName()
 															+ " is not accepting argument of type "
 															+ topClass
 																	.getName(),
 													e);
 								} catch (IllegalAccessException e) {
 									log.error("Setter Method "
 											+ setterMethod.getName()
 											+ " on class "
 											+ parentClass.getName()
 											+ " is not accessible.", e);
 								} catch (InvocationTargetException e) {
 									log.error("Setter Method "
 											+ setterMethod.getName()
 											+ " on class "
 											+ parentClass.getName()
 											+ " is not invocable on instance.",
 											e);
 								}
 							} else {
 								log
 										.error("Method "
 												+ ccir.getMethodName()
 												+ " in class "
 												+ topClass.getName()
 												+ " is not accepting parameter of type "
 												+ topClass.getName());
 							}
 						} else {
 							log
 									.error("Method "
 											+ ccir.getMethodName()
 											+ " in class "
 											+ topClass.getName()
 											+ " requires more than 1 parameters or no parameter at all.");
 						}
 					} else {
 						log.debug("Avoiding Multicall Bug");
 					}
 				} else {
 					log.error("Cannot find method " + ccir.getMethodName()
 							+ " in class " + topClass.getName());
 				}
 			}
 
 			Object o = stack.pop();
 			log.debug("POP " + o.getClass().getName() + ". Stack : "
 					+ stack.size());
 		} else if ((propertyRules.length > 0) && propertyWins) {
 			Object topObject = stack.getValue(stack.size() - 1);
 			Class topClass = topObject.getClass();
 
 			for (PropertySetRule propRule : propertyRules) {
 				log.debug("MATCH PropertySetRule. " + propRule.getPath());
 
 				Method getMet = getGetterMethod(topClass, propRule
 						.getPropertyName());
 				Method setMet = getSetterMethod(topClass, propRule
 						.getPropertyName());
 
 				if (getMet != null) {
 					Class retType = getMet.getReturnType();
 					Object param = null;
 
 					try {
 						if (retType.getName().equals("boolean")
 								|| retType.equals(Boolean.class)) {
 							param = new Boolean(characterData);
 						} else if (retType.getName().equals("char")
 								|| retType.equals(Character.class)) {
 							param = new Character(characterData.charAt(0));
 						} else if (retType.getName().equals("byte")
 								|| retType.equals(Byte.class)) {
 							param = new Byte(characterData);
 						} else if (retType.getName().equals("short")
 								|| retType.equals(Short.class)) {
 							param = new Short(characterData);
 						} else if (retType.getName().equals("int")
 								|| retType.equals(Integer.class)) {
 							param = new Integer(characterData);
 						} else if (retType.getName().equals("long")
 								|| retType.equals(Long.class)) {
 							param = new Long(characterData);
 						} else if (retType.getName().equals("float")
 								|| retType.equals(Float.class)) {
 							param = new Float(characterData);
 						} else if (retType.getName().equals("double")
 								|| retType.equals(Double.class)) {
 							param = new Double(characterData);
 						} else if (retType.equals(String.class)) {
 							param = characterData;
 						} else if (retType.equals(Date.class)) {
 							SimpleDateFormat sdf = new SimpleDateFormat(
 									propRule.getDateFormat());
 							param = sdf.parse(characterData);
 						} else if (retType.equals(BigInteger.class)) {
 							param = new BigInteger(characterData);
 						} else {
 							log
 									.error("Xanot is too dumb tobe able to initialize class "
 											+ retType.getName()
 											+ " with string data. Path : "
 											+ path);
 						}
 
 						if (param != null) {
 							if (setMet != null) {
 								try {
 									log.debug("Setter Method "
 											+ setMet.getName() + " on class "
 											+ topClass.getName()
 											+ " is invoked with parameter "
 											+ param.toString());
 									setMet.invoke(topObject,
 											new Object[] { param });
 								} catch (IllegalArgumentException e) {
 									log
 											.error(
 													"Setter Method "
 															+ setMet.getName()
 															+ " on class "
 															+ topClass
 																	.getName()
 															+ " is not accepting argument of type "
 															+ stack
 																	.getValue(
 																			stack
 																					.size() - 1)
 																	.getClass()
 																	.getName(),
 													e);
 								} catch (IllegalAccessException e) {
 									log.error("Setter Method "
 											+ setMet.getName() + " on class "
 											+ topClass.getName()
 											+ " is not accessible.", e);
 								} catch (InvocationTargetException e) {
 									log.error("Setter Method "
 											+ setMet.getName() + " on class "
 											+ topClass.getName()
 											+ " is not invocable on instance.",
 											e);
 								}
 							} else {
 								log.error("Setter method for property "
 										+ propRule.getPropertyName()
 										+ " is not exist in class "
 										+ topClass.getName());
 							}
 						}
 					} catch (ParseException pe) {
 						log
 								.error("Xanot is too dumb tobe able to parse data \""
 										+ characterData
 										+ "\" to date format '"
 										+ propRule.getDateFormat()
 										+ "'. Path : " + path);
 					} catch (NumberFormatException nfe) {
 						log
 								.error("Xanot is too dumb tobe able to parse data \""
 										+ characterData
 										+ "\" to numerical value. Path : "
 										+ path);
 					}
 				} else {
 					log.error("Getter Method " + getMet.getName()
 							+ " on class " + topClass.getName()
 							+ " is not exist.");
 				}
 			}
 		} else if ((propertyCollectionSetRule.length > 0) && propertyWins) {
 			Object topObject = stack.getValue(stack.size() - 1);
 			Class topClass = topObject.getClass();
 
 			for (PropertyCollectionSetRule colRule : propertyCollectionSetRule) {
 				log.debug("MATCH PropertyCollectionSetRule. "
 						+ colRule.getPath());
 
 				Method setterMethod = null;
 
 				for (Method met : topClass.getMethods()) {
 					if (met.getName().equals(colRule.getMethodName())) {
 						setterMethod = met;
 
 						break;
 					}
 				}
 
 				if (setterMethod != null) {
 					Class[] paramTypes = setterMethod.getParameterTypes();
 
 					if (paramTypes.length == 1) {
 						Class paramType = paramTypes[0];
 						Object param = null;
 
 						try {
 							if (paramType.getName().equals("boolean")
 									|| paramType.equals(Boolean.class)) {
 								param = new Boolean(characterData);
 							} else if (paramType.getName().equals("char")
 									|| paramType.equals(Character.class)) {
 								param = new Character(characterData.charAt(0));
 							} else if (paramType.getName().equals("byte")
 									|| paramType.equals(Byte.class)) {
 								param = new Byte(characterData);
 							} else if (paramType.getName().equals("short")
 									|| paramType.equals(Short.class)) {
 								param = new Short(characterData);
 							} else if (paramType.getName().equals("int")
 									|| paramType.equals(Integer.class)) {
 								param = new Integer(characterData);
 							} else if (paramType.getName().equals("long")
 									|| paramType.equals(Long.class)) {
 								param = new Long(characterData);
 							} else if (paramType.getName().equals("float")
 									|| paramType.equals(Float.class)) {
 								param = new Float(characterData);
 							} else if (paramType.getName().equals("double")
 									|| paramType.equals(Double.class)) {
 								param = new Double(characterData);
 							} else if (paramType.equals(String.class)) {
 								param = characterData;
 							} else if (paramType.equals(Date.class)) {
 								SimpleDateFormat sdf = new SimpleDateFormat(
 										colRule.getDateFormat());
 								param = sdf.parse(characterData);
 							} else if (paramType.equals(BigInteger.class)) {
 								param = new BigInteger(characterData);
 							} else {
 								log
 										.error("Xanot is too dumb tobe able to initialize class "
 												+ paramType.getName()
 												+ " with string data. Path : "
 												+ path);
 							}
 
 							if (param != null) {
 								try {
 									log.debug("Setter Method "
 											+ setterMethod.getName()
 											+ " on class " + topClass.getName()
 											+ " is invoked with parameter "
 											+ param.toString());
 									setterMethod.invoke(topObject,
 											new Object[] { param });
 								} catch (IllegalArgumentException e) {
 									log
 											.error(
 													"Setter Method "
 															+ setterMethod
 																	.getName()
 															+ " on class "
 															+ topClass
 																	.getName()
 															+ " is not accepting argument of type "
 															+ stack
 																	.getValue(
 																			stack
 																					.size() - 1)
 																	.getClass()
 																	.getName(),
 													e);
 								} catch (IllegalAccessException e) {
 									log.error("Setter Method "
 											+ setterMethod.getName()
 											+ " on class " + topClass.getName()
 											+ " is not accessible.", e);
 								} catch (InvocationTargetException e) {
 									log.error("Setter Method "
 											+ setterMethod.getName()
 											+ " on class " + topClass.getName()
 											+ " is not invocable on instance.",
 											e);
 								}
 							}
 						} catch (ParseException pe) {
 							log
 									.error("Xanot is too dumb tobe able to parse data \""
 											+ characterData
 											+ "\" to date format '"
 											+ colRule.getDateFormat()
 											+ "'. Path : " + path);
 						} catch (NumberFormatException nfe) {
 							log
 									.error("Xanot is too dumb tobe able to parse data \""
 											+ characterData
 											+ "\" to numerical value. Path : "
 											+ path);
 						}
 					} else {
 						log
 								.error("Method "
 										+ colRule.getMethodName()
 										+ " in class "
 										+ topClass.getName()
 										+ " requires more than 1 parameters or no parameter at all.");
 					}
 				} else {
 					log.error("Cannot find method " + colRule.getMethodName()
 							+ " in class " + topClass.getName());
 				}
 			}
 		} else {
 			if (stack.size() > 1) {
 				log.warn("</" + qName + "> is not handled.");
 			} else {
 				log.debug("XML END");
 			}
 		}
 	}
 
 	/***
 	 * Get a setter method from a specific property name on a class.
 	 * 
 	 * @param klass
 	 *            Class to inspect
 	 * @param property
 	 *            Property name
 	 * @return Setter method or null if there's no such setter method for the
 	 *         specified property
 	 */
 	public Method getSetterMethod(Class klass, String property) {
 		for (Method met : klass.getMethods()) {
 			String setSetter = "set"
 					+ Character.toUpperCase(property.charAt(0))
 					+ property.substring(1);
 
 			if (met.getName().equals(setSetter)) {
 				return met;
 			}
 		}
 
 		return null;
 	}
 
 	/***
 	 * Get a getter method from a specific property name on a class.
 	 * 
 	 * @param klass
 	 *            Class to inspect
 	 * @param property
 	 *            Property name
 	 * @return Getter method or null if there's no such getter method for the
 	 *         specified property
 	 */
 	public Method getGetterMethod(Class klass, String property) {
 		for (Method met : klass.getMethods()) {
 			String isGetter = "is" + Character.toUpperCase(property.charAt(0))
 					+ property.substring(1);
 			String getGetter = "get"
 					+ Character.toUpperCase(property.charAt(0))
 					+ property.substring(1);
 
 			if (met.getName().equals(isGetter)
 					|| met.getName().equals(getGetter)) {
 				return met;
 			}
 		}
 
 		return null;
 	}
 
 	/***
 	 * Triggered by SAX if it encouter an error when parsing.
 	 * 
 	 * @param e
 	 *            The cause
 	 * @throws SAXException
 	 *             Thrown if anything goes wrong on the parsing.
 	 */
 	@Override
 	public void error(SAXParseException e) throws SAXException {
 		errors.add(e);
 		if (isStopOnError()) {
 			throw new SAXException("Parser catches an Error", e);
 		}
 		super.error(e);
 	}
 
 	/***
 	 * Triggered by SAX if it encouter a fatal error when parsing.
 	 * 
 	 * @param e
 	 *            The cause
 	 * @throws SAXException
 	 *             Thrown if anything goes wrong on the parsing.
 	 */
 	@Override
 	public void fatalError(SAXParseException e) throws SAXException {
 		fatals.add(e);
 		if (isStopOnFatal()) {
 			throw new SAXException("Parser catches a Fatal Error", e);
 		}
 		super.fatalError(e);
 	}
 
 	/***
 	 * Triggered by SAX parser when it start parsing.
 	 * 
 	 * @throws SAXException
 	 *             Thrown if anything goes wrong on the parsing.
 	 */
 	@Override
 	public void startDocument() throws SAXException {
 		errors.clear();
 		fatals.clear();
 		warnings.clear();
 		stack = new StackMap<String, Object>();
 	}
 
 	/***
 	 * Triggered by SAX parser when it encounter the starting of xml element.
 	 * 
 	 * @param uri
 	 *            The URI
 	 * @param localName
 	 *            Local Name
 	 * @param qName
 	 *            Tag name
 	 * @param attributes
 	 *            Collection of attributes.
 	 * @throws SAXException
 	 *             Thrown if anything goes wrong on the parsing.
 	 */
 	@Override
 	public void startElement(String uri, String localName, String qName,
 			Attributes attributes) throws SAXException {
 		String path = stack.getStringKeyPath() + "/" + qName;
 		String[] paths = getPosiblePathAlternatives(path);
 
 		CreateInstanceRule[] createInstanceRules = ruleBuilder
 				.getCreateInstanceRule(paths);
 
 		log.debug("\n++++++++++++++++++++++++++++++");
 		log.debug("Start Element : <" + qName + ">");
 		log.debug("Path : " + path);
 
 		characterData = "";
 
 		if (createInstanceRules.length > 0) {
 			log.debug("CreateInstanceRule path : "
 					+ createInstanceRules[0].getPath());
 
 			// CreateInstanceRule cir = ruleBuilder.getCreateInstanceRule(path);
 			CreateInstanceRule cir = createInstanceRules[0];
 
 			if (cir != null) {
 				try {
 					Object instance = cir.createInstance();
 
 					// If the tag have no parent instance, or this is the first
 					// object instantiated
 					// then make this instance the root object.
 					if ((rootObject == null) && (stack.size() == 0)) {
 						rootObject = instance;
 						// if there already object inside the stack, than make
 						// all parent references to work.
 					}
 
 					stack.push(qName, instance);
 					log.debug("Instantiated " + instance.getClass().getName());
 					log.debug("PUSH " + instance.getClass().getName()
 							+ ". Stack : " + stack.size());
 
 					// Now we are going to setup the parent references tag.
 					if (stack.size() > 1) {
 						ParentReferenceRule[] parentReferenceRules = ruleBuilder
 								.getParentReferenceRule(paths);
 						if (parentReferenceRules.length > 0) {
 							Object parent = stack.peekParentValue();
 							for (ParentReferenceRule ppr : parentReferenceRules) {
 								Method getMet = getGetterMethod(instance
 										.getClass(), ppr.getAttributeName());
 								Method setMet = getSetterMethod(instance
 										.getClass(), ppr.getAttributeName());
 								if (getMet.getReturnType().isAssignableFrom(
 										parent.getClass())) {
 									try {
 										setMet.invoke(instance,
 												new Object[] { parent });
 									} catch (Exception e) {
 										log
 												.error(
 														"Canot set parent reference on "
 																+ instance
 																		.getClass()
 																		.getName()
 																+ "."
 																+ setMet
 																		.getName()
 																+ " with parameter of type "
 																+ parent
 																		.getClass()
 																		.getName()
 																+ ". ParentReference not set.",
 														e);
 									}
 								} else {
 									log
 											.error("Unable to create parent reference for ");
 								}
 							}
 						}
 					}
 
 					// Now we are going to setup all xml attributes.
 					for (int i = 0; i < attributes.getLength(); i++) {
 						String attrName = attributes.getQName(i);
 						String attrValue = attributes.getValue(i);
 
 						log.debug("Initializing attributes. Tag : " + attrName);
 
 						AttributeSetRule[] attrRules = ruleBuilder
 								.getAttributeSetRule(paths);
 
 						for (AttributeSetRule asr : attrRules) {
 							if (asr.getXmlAttributeName().equals(attrName)) {
 								String prop = asr.getPropertyName();
 								Method setter = null;
 								setter = getSetterMethod(cir.getBaseClass(),
 										prop);
 
 								if (setter != null) {
 									Class[] paramTypes = setter
 											.getParameterTypes();
 
 									if (paramTypes.length == 1) {
 										Class paramType = paramTypes[0];
 										Object param = null;
 
 										try {
 											if (paramType.getName().equals(
 													"boolean")
 													|| paramType
 															.equals(Boolean.class)) {
 												param = new Boolean(attrValue);
 											} else if (paramType.getName()
 													.equals("char")
 													|| paramType
 															.equals(Character.class)) {
 												param = new Character(attrValue
 														.charAt(0));
 											} else if (paramType.getName()
 													.equals("byte")
 													|| paramType
 															.equals(Byte.class)) {
 												param = new Byte(attrValue);
 											} else if (paramType.getName()
 													.equals("short")
 													|| paramType
 															.equals(Short.class)) {
 												param = new Short(attrValue);
 											} else if (paramType.getName()
 													.equals("int")
 													|| paramType
 															.equals(Integer.class)) {
 												param = new Integer(attrValue);
 											} else if (paramType.getName()
 													.equals("long")
 													|| paramType
 															.equals(Long.class)) {
 												param = new Long(attrValue);
 											} else if (paramType.getName()
 													.equals("float")
 													|| paramType
 															.equals(Float.class)) {
 												param = new Float(attrValue);
 											} else if (paramType.getName()
 													.equals("double")
 													|| paramType
 															.equals(Double.class)) {
 												param = new Double(attrValue);
 											} else if (paramType
 													.equals(String.class)) {
 												param = attrValue;
 											} else if (paramType
 													.equals(Date.class)) {
 												SimpleDateFormat sdf = new SimpleDateFormat(
 														asr.getDateFormat());
 												param = sdf.parse(attrValue);
 											} else if (paramType
 													.equals(BigInteger.class)) {
 												param = new BigInteger(
 														attrValue);
 											} else {
 												log
 														.error("Xanot is too dumb tobe able to initialize class "
 																+ paramType
 																		.getName()
 																+ " with string data. Path : "
 																+ path);
 											}
 
 											if (param != null) {
 												try {
 													log
 															.debug("Setter Method "
 																	+ setter
 																			.getName()
 																	+ " on class "
 																	+ cir
 																			.getBaseClass()
 																			.getName()
 																	+ " is invoked with parameter "
 																	+ param
 																			.toString());
 													setter
 															.invoke(
 																	instance,
 																	new Object[] { param });
 												} catch (IllegalArgumentException e) {
 													log
 															.error(
 																	"Setter Method "
 																			+ setter
 																					.getName()
 																			+ " on class "
 																			+ cir
 																					.getBaseClass()
 																					.getName()
 																			+ " is not accepting argument of type "
 																			+ stack
 																					.getValue(
 																							stack
 																									.size() - 1)
 																					.getClass()
 																					.getName(),
 																	e);
 												} catch (IllegalAccessException e) {
 													log
 															.error(
 																	"Setter Method "
 																			+ setter
 																					.getName()
 																			+ " on class "
 																			+ cir
 																					.getBaseClass()
 																					.getName()
 																			+ " is not accessible.",
 																	e);
 												} catch (InvocationTargetException e) {
 													log
 															.error(
 																	"Setter Method "
 																			+ setter
 																					.getName()
 																			+ " on class "
 																			+ cir
 																					.getBaseClass()
 																					.getName()
 																			+ " is not invocable on instance.",
 																	e);
 												}
 											}
 										} catch (ParseException pe) {
 											log
 													.error("Xanot is too dumb tobe able to parse data \""
 															+ attrValue
 															+ "\" to date format '"
 															+ asr
 																	.getDateFormat()
 															+ "'. Path : "
 															+ path);
 										} catch (NumberFormatException nfe) {
 											log
 													.error("Xanot is too dumb tobe able to parse data \""
 															+ attrValue
 															+ "\" to numerical value. Path : "
 															+ path);
 										}
 									} else {
 										log
 												.error("Method "
 														+ setter.getName()
 														+ " in class "
 														+ cir.getBaseClass()
 																.getName()
 														+ " requires more than 1 parameters or no parameter at all.");
 									}
 								} else {
 									log.error("Setter method for property "
 											+ prop + " is not exist in class "
 											+ cir.getBaseClass().getName());
 								}
 							}
 						}
 					}
 				} catch (InstantiationException ie) {
 					log
 							.fatal(
 									"Class "
 											+ cir.getClass().getName()
 											+ " cannot be instantiate. Probably abstract or interface.",
 									ie);
 					System.exit(-1);
 				} catch (IllegalAccessException iae) {
 					log.fatal("Class " + cir.getClass().getName()
 							+ " cannot be accessed.", iae);
 					System.exit(-1);
 				}
 			}
 		}
 
 		/*
 		 * TODO Add implementation to handle ParentReference annotation.
 		 */
 	}
 
 	/***
 	 * Generate all posible path as alternative to the given path.
 	 * 
 	 * @param path
 	 *            Path
 	 * @return Alternative paths including the given path.
 	 */
 	private String[] getPosiblePathAlternatives(String path) {
 		ArrayList<String> al = new ArrayList<String>();
 		StringTokenizer stok = new StringTokenizer(path, "/");
 
 		while (stok.hasMoreTokens()) {
 			al.add(stok.nextToken());
 		}
 
 		String[] tokens = al.toArray(new String[al.size()]);
 
 		for (int i = 0; i < tokens.length; i++) {
 			tokens[i] = buildupPath(tokens, i);
 		}
 
 		String[] newToken = new String[tokens.length + 2];
 		System.arraycopy(tokens, 0, newToken, 1, tokens.length);
 		newToken[newToken.length - 1] = "..";
 
 		newToken[0] = newToken[1];
 		newToken[1] = ".." + newToken[0];
 
 		return newToken;
 	}
 
 	/***
 	 * Buildup complete path out of a string tokens.
 	 * 
 	 * @param tokens
 	 *            String tokens
 	 * @param count
 	 *            Number of tokens
 	 * @return A complete path
 	 */
 	private String buildupPath(String[] tokens, int count) {
 		StringBuilder sb = new StringBuilder();
 
 		if (count == 0) {
 			for (int i = 0; i < tokens.length; i++) {
 				sb.append("/");
 				sb.append(tokens[i]);
 			}
 		} else {
 			sb.append("..");
 
 			for (int i = count; i < tokens.length; i++) {
 				sb.append("/");
 				sb.append(tokens[i]);
 			}
 		}
 
 		return sb.toString();
 	}
 
 	/***
 	 * Triggered by SAX parser when it encounters an Error
 	 * 
 	 * @param e
 	 *            The cause
 	 * @throws SAXException
 	 *             Thrown if anything goes wrong on the parsing.
 	 */
 	@Override
 	public void warning(SAXParseException e) throws SAXException {
 		warnings.add(e);
 		if (isStopOnWarning()) {
 			throw new SAXException("Parser catches a warning", e);
 		}
 	}
 
 	/***
 	 * Get collection of warnings, collected when the parsing is running.
 	 * 
 	 * @return Collection warning.
 	 */
 	public Collection<SAXParseException> getWarnings() {
 		return warnings;
 	}
 
 	/***
 	 * Set collection of warnings. It is not to be used manually by user since
 	 * the collection will be emptied eachtime the parsing starts.
 	 * 
 	 * @param warnings
 	 *            Collection warning.
 	 */
 	public void setWarnings(Collection<SAXParseException> warnings) {
 		if (warnings == null) {
 			throw new NullPointerException();
 		}
 		this.warnings = warnings;
 	}
 
 	/***
 	 * Get collection of errors, collected when the parsing is running
 	 * 
 	 * @return Collection of errors.
 	 */
 	public Collection<SAXParseException> getErrors() {
 		return errors;
 	}
 
 	/***
 	 * Set collection of errors. It is not to be used manually by user since the
 	 * collection will be emptied eachtime the parsing starts.
 	 * 
 	 * @param errors
 	 *            Collection of errors
 	 */
 	public void setErrors(Collection<SAXParseException> errors) {
 		if (errors == null) {
 			throw new NullPointerException();
 		}
 		this.errors = errors;
 	}
 
 	/***
 	 * Get collection of fatal errors, collected when the parsing is running
 	 * 
 	 * @return Collection of fatal errors.
 	 */
 	public Collection<SAXParseException> getFatals() {
 		return fatals;
 	}
 
 	/***
 	 * Set collection of fatal errors. It is not to be used manually by user
 	 * since the collection will be emptied eachtime the parsing starts.
 	 * 
 	 * @param fatals
 	 *            Collection of fatal errors.
 	 */
 	public void setFatals(Collection<SAXParseException> fatals) {
 		if (fatals == null) {
 			throw new NullPointerException();
 		}
 		this.fatals = fatals;
 	}
 
 	/***
 	 * Check wether parsing should halt on any warning.
 	 * 
 	 * @return True if halt on warning, false if otherwise.
 	 */
 	public boolean isStopOnWarning() {
 		return stopOnWarning;
 	}
 
 	/***
 	 * Set to stp
 	 * 
 	 * @param stopOnWarning
 	 */
 	public void setStopOnWarning(boolean stopOnWarning) {
 		this.stopOnWarning = stopOnWarning;
 	}
 
 	public boolean isStopOnError() {
 		return stopOnError;
 	}
 
 	public void setStopOnError(boolean stopOnError) {
 		this.stopOnError = stopOnError;
 	}
 
 	public boolean isStopOnFatal() {
 		return stopOnFatal;
 	}
 
 	public void setStopOnFatal(boolean stopOnFatal) {
 		this.stopOnFatal = stopOnFatal;
 	}
 }