fieldMap.setRelationshipType(ele.getAttribute(RELATIONSHIP_TYPE_ATTRIBUTE));
    }
    NodeList nl = ele.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
      Node node = nl.item(i);
      if (node instanceof Element) {
        Element element = (Element) node;
        log.info("config name: " + element.getNodeName());
        log.info("  value: " + element.getFirstChild().getNodeValue());
        parseFieldElements(element, fieldMap);
        if (SOURCE_TYPE_HINT_ELEMENT.equals(element.getNodeName())) {
          Hint sourceHint = new Hint();
          sourceHint.setHintName(element.getFirstChild().getNodeValue().trim());
          fieldMap.setSourceTypeHint(sourceHint);
        }
        if (DESTINATION_TYPE_HINT_ELEMENT.equals(element.getNodeName())) {
          Hint destHint = new Hint();
          destHint.setHintName(element.getFirstChild().getNodeValue().trim());
          fieldMap.setDestinationTypeHint(destHint);
        }
      }
    }
  }

  private boolean isIndexed(String fieldName) {
    return (fieldName != null) && (fieldName.matches(".+\\[\\d+\\]"));
  }

  private String getFieldNameOfIndexedField(String fieldName) {
    return fieldName == null ? null : fieldName.replaceAll("\\[\\d+\\]", "");
  }

  private int getIndexOfIndexedField(String fieldName) {
    return Integer.parseInt(fieldName.replaceAll(".*\\[", "").replaceAll("\\]", ""));
  }

  private Field parseField(Element ele) {
    Field rvalue = null;
    String type = null;
    String fieldName;
    String name = (ele.getFirstChild().getNodeValue().trim());
    if (isIndexed(name)) {
      fieldName = getFieldNameOfIndexedField(name);
    } else {
      fieldName = name;
    }
    if (StringUtils.isNotEmpty(ele.getAttribute(TYPE_ATTRIBUTE))) {
      type = ele.getAttribute(TYPE_ATTRIBUTE);
    }
    rvalue = new Field(fieldName, type);
    if (isIndexed(name)) {
      rvalue.setIndexed(true);
      rvalue.setIndex(getIndexOfIndexedField(name));
    }
    if (StringUtils.isNotEmpty(ele.getAttribute(DATE_FORMAT_ATTRIBUTE))) {
      rvalue.setDateFormat(ele.getAttribute(DATE_FORMAT_ATTRIBUTE));
    }
    if (StringUtils.isNotEmpty(ele.getAttribute(THE_GET_METHOD_ATTRIBUTE))) {
      rvalue.setTheGetMethod(ele.getAttribute(THE_GET_METHOD_ATTRIBUTE));
    }
    if (StringUtils.isNotEmpty(ele.getAttribute(THE_SET_METHOD_ATTRIBUTE))) {
      rvalue.setTheSetMethod(ele.getAttribute(THE_SET_METHOD_ATTRIBUTE));
    }
    if (StringUtils.isNotEmpty(ele.getAttribute(MAP_GET_METHOD_ATTRIBUTE))) {
      rvalue.setMapGetMethod(ele.getAttribute(MAP_GET_METHOD_ATTRIBUTE));
    }
    if (StringUtils.isNotEmpty(ele.getAttribute(MAP_SET_METHOD_ATTRIBUTE))) {
      rvalue.setMapSetMethod(ele.getAttribute(MAP_SET_METHOD_ATTRIBUTE));
    }
    if (StringUtils.isNotEmpty(ele.getAttribute(KEY_ATTRIBUTE))) {
      rvalue.setKey(ele.getAttribute(KEY_ATTRIBUTE));
    }
    if (StringUtils.isNotEmpty(ele.getAttribute(CREATE_METHOD_ATTRIBUTE))) {
      rvalue.setCreateMethod(ele.getAttribute(CREATE_METHOD_ATTRIBUTE));
    }
    if (StringUtils.isNotEmpty(ele.getAttribute(IS_ACCESSIBLE_ATTRIBUTE))) {
      rvalue.setAccessible(BooleanUtils.toBoolean(ele.getAttribute(IS_ACCESSIBLE_ATTRIBUTE)));
    }
    return rvalue;
  }

  private void parseConfiguration(Element ele) {
    Configuration config = new Configuration();
    mappings.setConfiguration(config);
    NodeList nl = ele.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
      Node node = nl.item(i);
      if (node instanceof Element) {
        Element element = (Element) node;
        log.info("config name: " + element.getNodeName());
        log.info("  value: " + element.getFirstChild().getNodeValue());
        if (STOP_ON_ERRORS_ELEMENT.equals(element.getNodeName())) {
          config.setStopOnErrors(BooleanUtils.toBoolean(element.getFirstChild().getNodeValue().trim()));
        } else if (DATE_FORMAT_ELEMENT.equals(element.getNodeName())) {
          config.setDateFormat(element.getFirstChild().getNodeValue().trim());
        } else if (WILDCARD_ELEMENT.equals(element.getNodeName())) {
          config.setWildcard(BooleanUtils.toBoolean(element.getFirstChild().getNodeValue().trim()));
        } else if (BEAN_FACTORY_ELEMENT.equals(element.getNodeName())) {
          config.setBeanFactory(element.getFirstChild().getNodeValue().trim());
        } else if (IS_ACCESSIBLE_ELEMENT.equals(element.getNodeName())) {
          config.setAccessible(BooleanUtils.toBoolean(element.getFirstChild().getNodeValue().trim()));
        } else if (CUSTOM_CONVERTERS_ELEMENT.equals(element.getNodeName())) {
          parseCustomConverters(element, config);
        } else if (COPY_BY_REFERENCES_ELEMENT.equals(element.getNodeName())) {
          parseCopyByReferences(element, config);
        }
      }
    }
  }

  private void parseCustomConverters(Element ele, Configuration config) {
    CustomConverterContainer container = new CustomConverterContainer();
    config.setCustomConverters(container);
    NodeList nl = ele.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
      Node node = nl.item(i);
      if (node instanceof Element) {
        Element element = (Element) node;
        log.info("config name: " + element.getNodeName());
        log.info("  value: " + element.getFirstChild().getNodeValue());
        if (CONVERTER_ELEMENT.equals(element.getNodeName())) {
          CustomConverterDescription customConverter = new CustomConverterDescription();
          container.addConverter(customConverter);
          customConverter.setType(element.getAttribute(TYPE_ATTRIBUTE));
          NodeList list = element.getChildNodes();
          for (int x = 0; x < list.getLength(); x++) {
            Node node1 = list.item(x);
            if (node1 instanceof Element) {
              Element element1 = (Element) node1;
              if (CLASS_A_ELEMENT.equals(element1.getNodeName())) {
                customConverter.setClassA(element1.getFirstChild().getNodeValue().trim());
              } else if (CLASS_B_ELEMENT.equals(element1.getNodeName())) {
                customConverter.setClassB(element1.getFirstChild().getNodeValue().trim());
              }
            }
          }
        }
      }
    }
  }

  private void parseCopyByReferences(Element ele, Configuration config) {
    CopyByReferenceContainer container = new CopyByReferenceContainer();
    config.setCopyByReferences(container);
    NodeList nl = ele.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
      Node node = nl.item(i);
      if (node instanceof Element) {
        Element element = (Element) node;
        log.info("config name: " + element.getNodeName());
        log.info("  value: " + element.getFirstChild().getNodeValue());
        if (COPY_BY_REFERENCE_ELEMENT.equals(element.getNodeName())) {
          CopyByReference cbr = new CopyByReference();
          container.getCopyByReferences().add(cbr);
          cbr.setReferenceName(element.getFirstChild().getNodeValue().trim());
        }
      }
    }
  }

  /**
   * Create a JAXP DocumentBuilderFactory that this bean definition reader will use for parsing XML documents. Can be
   * overridden in subclasses, adding further initialization of the factory.
   * 
   * @return the JAXP DocumentBuilderFactory
   * @throws ParserConfigurationException
   *           if thrown by JAXP methods
   */
  protected DocumentBuilderFactory createDocumentBuilderFactory() throws ParserConfigurationException {

    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    factory.setValidating(true);
    factory.setNamespaceAware(false);
    factory.setIgnoringElementContentWhitespace(true);
    return factory;
  }

  /**
   * Create a JAXP DocumentBuilder that this bean definition reader will use for parsing XML documents. Can be
   * overridden in subclasses, adding further initialization of the builder.
   * 
   * @param factory
   *          the JAXP DocumentBuilderFactory that the DocumentBuilder should be created with
   * @return the JAXP DocumentBuilder
   * @throws ParserConfigurationException
   *           if thrown by JAXP methods
   */
  protected DocumentBuilder createDocumentBuilder(DocumentBuilderFactory factory) throws ParserConfigurationException {

    DocumentBuilder docBuilder = factory.newDocumentBuilder();
    docBuilder.setErrorHandler(new DozerDefaultHandler());
    docBuilder.setEntityResolver(new DozerResolver());
    return docBuilder;
  }

  class DozerDefaultHandler extends DefaultHandler {
    private final Logger log = Logger.getLogger(DozerDefaultHandler.class);

    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
      log.info("tag: " + qName);
    }

    public void warning(SAXParseException e) throws SAXException {
      // you can choose not to handle it
      throw new SAXException(getMessage("Warning", e));
    }

    public void error(SAXParseException e) throws SAXException {
      throw new SAXException(getMessage("Error", e));
    }

    public void fatalError(SAXParseException e) throws SAXException {
      throw new SAXException(getMessage("Fatal Error", e));
    }

    private String getMessage(String level, SAXParseException e) {
      return ("Parsing " + level + "\n" + "Line:    " + e.getLineNumber() + "\n" + "URI:     " + e.getSystemId() + "\n"
          + "Message: " + e.getMessage());
    }
  }
}