Coverage Report - org.dozer.loader.xml.XMLParser
 
Classes in this File Line Coverage Branch Coverage Complexity
XMLParser
100%
274/274
92%
167/180
5.737
 
 1  
 /**
 2  
  * Copyright 2005-2013 Dozer Project
 3  
  *
 4  
  * Licensed under the Apache License, Version 2.0 (the "License");
 5  
  * you may not use this file except in compliance with the License.
 6  
  * You may obtain a copy of the License at
 7  
  *
 8  
  *      http://www.apache.org/licenses/LICENSE-2.0
 9  
  *
 10  
  * Unless required by applicable law or agreed to in writing, software
 11  
  * distributed under the License is distributed on an "AS IS" BASIS,
 12  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  
  * See the License for the specific language governing permissions and
 14  
  * limitations under the License.
 15  
  */
 16  
 package org.dozer.loader.xml;
 17  
 
 18  
 
 19  
 import org.apache.commons.lang3.BooleanUtils;
 20  
 import org.apache.commons.lang3.StringUtils;
 21  
 import org.dozer.classmap.MappingDirection;
 22  
 import org.dozer.classmap.MappingFileData;
 23  
 import org.dozer.classmap.RelationshipType;
 24  
 import org.dozer.config.BeanContainer;
 25  
 import org.dozer.loader.DozerBuilder;
 26  
 import org.dozer.loader.MappingsSource;
 27  
 import org.slf4j.Logger;
 28  
 import org.slf4j.LoggerFactory;
 29  
 import org.w3c.dom.Document;
 30  
 import org.w3c.dom.Element;
 31  
 import org.w3c.dom.Node;
 32  
 import org.w3c.dom.NodeList;
 33  
 
 34  
 /**
 35  
  * Internal class that parses a raw custom xml mapping file into ClassMap objects.
 36  
  * <p/>
 37  
  * Only intended for internal use.
 38  
  *
 39  
  * @author garsombke.franz
 40  
  * @author johnsen.knut-erik
 41  
  * @author dmitry.buzdin
 42  
  */
 43  602
 public class XMLParser implements MappingsSource<Document> {
 44  
 
 45  705
   private final Logger log = LoggerFactory.getLogger(XMLParser.class);
 46  
 
 47  
   // Common Elements/Attributes
 48  
   private static final String WILDCARD = "wildcard";
 49  
   private static final String TRIM_STRINGS = "trim-strings";
 50  
   private static final String BEAN_FACTORY = "bean-factory";
 51  
   private static final String DATE_FORMAT = "date-format";
 52  
   private static final String RELATIONSHIP_TYPE = "relationship-type";
 53  
   private static final String REMOVE_ORPHANS = "remove-orphans";
 54  
   private static final String MAP_NULL = "map-null";
 55  
   private static final String MAP_EMPTY_STRING = "map-empty-string";
 56  
 
 57  
   // Parsing Elements
 58  
   private static final String CONFIGURATION_ELEMENT = "configuration";
 59  
   private static final String STOP_ON_ERRORS_ELEMENT = "stop-on-errors";
 60  
   private static final String CUSTOM_CONVERTERS_ELEMENT = "custom-converters";
 61  
   private static final String COPY_BY_REFERENCES_ELEMENT = "copy-by-references";
 62  
   private static final String COPY_BY_REFERENCE = "copy-by-reference";
 63  
   private static final String CONVERTER_ELEMENT = "converter";
 64  
   private static final String CLASS_A_ELEMENT = "class-a";
 65  
   private static final String CLASS_B_ELEMENT = "class-b";
 66  
   private static final String MAPPING_ELEMENT = "mapping";
 67  
   private static final String FIELD_ELEMENT = "field";
 68  
   private static final String FIELD_EXCLUDE_ELEMENT = "field-exclude";
 69  
   private static final String A_ELEMENT = "a";
 70  
   private static final String B_ELEMENT = "b";
 71  
   private static final String SRC_TYPE_HINT_ELEMENT = "a-hint";
 72  
   private static final String DEST_TYPE_HINT_ELEMENT = "b-hint";
 73  
   private static final String SRC_TYPE_DEEP_INDEX_HINT_ELEMENT = "a-deep-index-hint";
 74  
   private static final String DEST_TYPE_DEEP_INDEX_HINT_ELEMENT = "b-deep-index-hint";
 75  
   private static final String ALLOWED_EXCEPTIONS_ELEMENT = "allowed-exceptions";
 76  
   private static final String ALLOWED_EXCEPTION_ELEMENT = "exception";
 77  
   private static final String VARIABLES_ELEMENT = "variables";
 78  
   private static final String VARIABLE_ELEMENT = "variable";
 79  
 
 80  
   // Parsing Attributes
 81  
   private static final String TYPE_ATTRIBUTE = "type";
 82  
   private static final String NAME_ATTRIBUTE = "name";
 83  
   private static final String COPY_BY_REFERENCE_ATTRIBUTE = "copy-by-reference";
 84  
   private static final String THE_SET_METHOD_ATTRIBUTE = "set-method";
 85  
   private static final String THE_GET_METHOD_ATTRIBUTE = "get-method";
 86  
   private static final String STOP_ON_ERRORS_ATTRIBUTE = "stop-on-errors";
 87  
   private static final String MAPID_ATTRIBUTE = "map-id";
 88  
   private static final String MAP_SET_METHOD_ATTRIBUTE = "map-set-method";
 89  
   private static final String MAP_GET_METHOD_ATTRIBUTE = "map-get-method";
 90  
   private static final String KEY_ATTRIBUTE = "key";
 91  
   private static final String FACTORY_BEANID_ATTRIBUTE = "factory-bean-id";
 92  
   private static final String IS_ACCESSIBLE_ATTRIBUTE = "is-accessible";
 93  
   private static final String CREATE_METHOD_ATTRIBUTE = "create-method";
 94  
   private static final String MAP_NULL_ATTRIBUTE = "map-null";
 95  
   private static final String MAP_EMPTY_STRING_ATTRIBUTE = "map-empty-string";
 96  
   private static final String CUSTOM_CONVERTER_ATTRIBUTE = "custom-converter";
 97  
   private static final String CUSTOM_CONVERTER_ID_ATTRIBUTE = "custom-converter-id";
 98  
   private static final String CUSTOM_CONVERTER_PARAM_ATTRIBUTE = "custom-converter-param";
 99  
 
 100  
   private final ElementReader elementReader;
 101  
 
 102  705
   public XMLParser() {
 103  705
     this.elementReader = BeanContainer.getInstance().getElementReader();
 104  705
   }
 105  
 
 106  
   private String getAttribute(Element element, String attribute) {
 107  764278
     return elementReader.getAttribute(element, attribute);
 108  
   }
 109  
 
 110  
   private String getNodeValue(Element element) {
 111  72511
     return elementReader.getNodeValue(element);
 112  
   }
 113  
 
 114  
   private void debugElement(Element element) {
 115  59494
     log.debug("config name: {}",element.getNodeName());
 116  59494
     log.debug("  value: {}", element.getFirstChild().getNodeValue());
 117  59494
   }
 118  
 
 119  
   /**
 120  
    * Builds object representation of mappings based on content of Xml document
 121  
    *
 122  
    * @return mapping container
 123  
    */
 124  
   public MappingFileData read(Document document) {
 125  602
     DozerBuilder builder = new DozerBuilder();
 126  
 
 127  602
     Element theRoot = document.getDocumentElement();
 128  602
     NodeList nl = theRoot.getChildNodes();
 129  7554
     for (int i = 0; i < nl.getLength(); i++) {
 130  6956
       Node node = nl.item(i);
 131  6956
       if (node instanceof Element) {
 132  5688
         Element ele = (Element) node;
 133  5688
         log.debug("name: {}", ele.getNodeName());
 134  5688
         if (CONFIGURATION_ELEMENT.equals(ele.getNodeName())) {
 135  233
           parseConfiguration(ele, builder);
 136  5455
         } else if (MAPPING_ELEMENT.equals(ele.getNodeName())) {
 137  5455
           parseMapping(ele, builder);
 138  
         }
 139  
       }
 140  
     }
 141  
 
 142  598
     return builder.build();
 143  
   }
 144  
 
 145  
   private void parseMapping(Element ele, DozerBuilder builder) {
 146  5455
     DozerBuilder.MappingBuilder definitionBuilder = builder.mapping();
 147  
 
 148  5455
     if (StringUtils.isNotEmpty(getAttribute(ele, DATE_FORMAT))) {
 149  110
       definitionBuilder.dateFormat(getAttribute(ele, DATE_FORMAT));
 150  
     }
 151  5455
     if (StringUtils.isNotEmpty(getAttribute(ele, MAP_NULL_ATTRIBUTE))) {
 152  58
       definitionBuilder.mapNull(BooleanUtils.toBoolean(getAttribute(ele, MAP_NULL_ATTRIBUTE)));
 153  
     }
 154  5455
     if (StringUtils.isNotEmpty(getAttribute(ele, MAP_EMPTY_STRING_ATTRIBUTE))) {
 155  12
       definitionBuilder.mapEmptyString(BooleanUtils.toBoolean(getAttribute(ele, MAP_EMPTY_STRING_ATTRIBUTE)));
 156  
     }
 157  5455
     if (StringUtils.isNotEmpty(getAttribute(ele, BEAN_FACTORY))) {
 158  1
       definitionBuilder.beanFactory(getAttribute(ele, BEAN_FACTORY));
 159  
     }
 160  5455
     if (StringUtils.isNotEmpty(getAttribute(ele, RELATIONSHIP_TYPE))) {
 161  2
       String relationshipTypeValue = getAttribute(ele, RELATIONSHIP_TYPE);
 162  2
       RelationshipType relationshipType = RelationshipType.valueOf(relationshipTypeValue);
 163  2
       definitionBuilder.relationshipType(relationshipType);
 164  
     }
 165  5455
     if (StringUtils.isNotEmpty(getAttribute(ele, WILDCARD))) {
 166  870
       definitionBuilder.wildcard(Boolean.valueOf(getAttribute(ele, WILDCARD)));
 167  
     }
 168  5455
     if (StringUtils.isNotEmpty(getAttribute(ele, TRIM_STRINGS))) {
 169  6
       definitionBuilder.trimStrings(Boolean.valueOf(getAttribute(ele, TRIM_STRINGS)));
 170  
     }
 171  5455
     if (StringUtils.isNotEmpty(getAttribute(ele, STOP_ON_ERRORS_ATTRIBUTE))) {
 172  443
       definitionBuilder.stopOnErrors(Boolean.valueOf(getAttribute(ele, STOP_ON_ERRORS_ATTRIBUTE)));
 173  
     }
 174  5455
     if (StringUtils.isNotEmpty(getAttribute(ele, MAPID_ATTRIBUTE))) {
 175  672
       definitionBuilder.mapId(getAttribute(ele, MAPID_ATTRIBUTE));
 176  
     }
 177  5455
     if (StringUtils.isNotEmpty(getAttribute(ele, TYPE_ATTRIBUTE))) {
 178  278
       String mappingDirection = getAttribute(ele, TYPE_ATTRIBUTE);
 179  278
       MappingDirection direction = MappingDirection.valueOf(mappingDirection);
 180  278
       definitionBuilder.type(direction);
 181  
     }
 182  5455
     NodeList nl = ele.getChildNodes();
 183  31851
     for (int i = 0; i < nl.getLength(); i++) {
 184  26400
       Node node = nl.item(i);
 185  26400
       if (node instanceof Element) {
 186  25186
         Element element = (Element) node;
 187  25186
         debugElement(element);
 188  25186
         if (CLASS_A_ELEMENT.equals(element.getNodeName())) {
 189  5455
           String typeName = getNodeValue(element);
 190  5455
           DozerBuilder.ClassDefinitionBuilder classBuilder = definitionBuilder.classA(typeName);
 191  5453
           parseClass(element, classBuilder);
 192  
         }
 193  25184
         if (CLASS_B_ELEMENT.equals(element.getNodeName())) {
 194  5453
           String typeName = getNodeValue(element);
 195  5453
           DozerBuilder.ClassDefinitionBuilder classBuilder = definitionBuilder.classB(typeName);
 196  5453
           parseClass(element, classBuilder);
 197  
         }
 198  25184
         if (FIELD_ELEMENT.equals(element.getNodeName())) {
 199  13450
           parseGenericFieldMap(element, definitionBuilder);
 200  11734
         } else if (FIELD_EXCLUDE_ELEMENT.equals(element.getNodeName())) {
 201  828
           parseFieldExcludeMap(element, definitionBuilder);
 202  
         }
 203  
       }
 204  
     }
 205  5451
   }
 206  
 
 207  
   private void parseClass(Element element, DozerBuilder.ClassDefinitionBuilder classBuilder) {
 208  10906
     if (StringUtils.isNotEmpty(getAttribute(element, MAP_GET_METHOD_ATTRIBUTE))) {
 209  224
       classBuilder.mapGetMethod(getAttribute(element, MAP_GET_METHOD_ATTRIBUTE));
 210  
     }
 211  10906
     if (StringUtils.isNotEmpty(getAttribute(element, MAP_SET_METHOD_ATTRIBUTE))) {
 212  224
       classBuilder.mapSetMethod(getAttribute(element, MAP_SET_METHOD_ATTRIBUTE));
 213  
     }
 214  10906
     if (StringUtils.isNotEmpty(getAttribute(element, BEAN_FACTORY))) {
 215  66
       classBuilder.beanFactory(getAttribute(element, BEAN_FACTORY));
 216  
     }
 217  10906
     if (StringUtils.isNotEmpty(getAttribute(element, FACTORY_BEANID_ATTRIBUTE))) {
 218  1
       classBuilder.factoryBeanId(getAttribute(element, FACTORY_BEANID_ATTRIBUTE));
 219  
     }
 220  10906
     if (StringUtils.isNotEmpty(getAttribute(element, CREATE_METHOD_ATTRIBUTE))) {
 221  10
       classBuilder.createMethod(getAttribute(element, CREATE_METHOD_ATTRIBUTE));
 222  
     }
 223  10906
     if (StringUtils.isNotEmpty(getAttribute(element, MAP_NULL_ATTRIBUTE))) {
 224  12
       classBuilder.mapNull(Boolean.valueOf(getAttribute(element, MAP_NULL_ATTRIBUTE)));
 225  
     }
 226  10906
     if (StringUtils.isNotEmpty(getAttribute(element, MAP_EMPTY_STRING_ATTRIBUTE))) {
 227  12
       classBuilder.mapEmptyString(Boolean.valueOf(getAttribute(element, MAP_EMPTY_STRING_ATTRIBUTE)));
 228  
     }
 229  10906
     if (StringUtils.isNotEmpty(getAttribute(element, IS_ACCESSIBLE_ATTRIBUTE))) {
 230  24
       classBuilder.isAccessible(Boolean.valueOf(getAttribute(element, IS_ACCESSIBLE_ATTRIBUTE)));
 231  
     }
 232  10906
   }
 233  
 
 234  
   private void parseFieldExcludeMap(Element ele, DozerBuilder.MappingBuilder definitionBuilder) {
 235  828
     DozerBuilder.FieldExclusionBuilder fieldMapBuilder = definitionBuilder.fieldExclude();
 236  828
     if (StringUtils.isNotEmpty(getAttribute(ele, TYPE_ATTRIBUTE))) {
 237  828
       String mappingDirection = getAttribute(ele, TYPE_ATTRIBUTE);
 238  828
       MappingDirection direction = MappingDirection.valueOf(mappingDirection);
 239  828
       fieldMapBuilder.type(direction);
 240  
     }
 241  828
     NodeList nodeList = ele.getChildNodes();
 242  2484
     for (int i = 0; i < nodeList.getLength(); i++) {
 243  1656
       Node node = nodeList.item(i);
 244  1656
       if (node instanceof Element) {
 245  1656
         Element element = (Element) node;
 246  1656
         debugElement(element);
 247  1656
         parseFieldElements(element, fieldMapBuilder);
 248  
       }
 249  
     }
 250  828
   }
 251  
 
 252  
   private void parseFieldElements(Element element, DozerBuilder.FieldBuider fieldMapBuilder) {
 253  33034
     if (A_ELEMENT.equals(element.getNodeName())) {
 254  14276
       String name = getNodeValue(element);
 255  14276
       String type = getAttribute(element, TYPE_ATTRIBUTE);
 256  14276
       DozerBuilder.FieldDefinitionBuilder fieldBuilder = fieldMapBuilder.a(name, type);
 257  14276
       parseField(element, fieldBuilder);
 258  
     }
 259  33034
     if (B_ELEMENT.equals(element.getNodeName())) {
 260  14276
       String name = getNodeValue(element);
 261  14276
       String type = getAttribute(element, TYPE_ATTRIBUTE);
 262  14276
       DozerBuilder.FieldDefinitionBuilder fieldBuilder = fieldMapBuilder.b(name, type);
 263  14276
       parseField(element, fieldBuilder);
 264  
     }
 265  33034
   }
 266  
 
 267  
   private void parseGenericFieldMap(Element ele, DozerBuilder.MappingBuilder definitionBuilder) {
 268  13450
     DozerBuilder.FieldMappingBuilder fieldMapBuilder = determineFieldMap(definitionBuilder, ele);
 269  
 
 270  13448
     if (StringUtils.isNotEmpty(getAttribute(ele, COPY_BY_REFERENCE_ATTRIBUTE))) {
 271  229
       fieldMapBuilder.copyByReference(BooleanUtils.toBoolean(getAttribute(ele, COPY_BY_REFERENCE_ATTRIBUTE)));
 272  
     }
 273  13448
     if (StringUtils.isNotEmpty(getAttribute(ele, MAPID_ATTRIBUTE))) {
 274  574
       fieldMapBuilder.mapId(getAttribute(ele, MAPID_ATTRIBUTE));
 275  
     }
 276  13448
     if (StringUtils.isNotEmpty(getAttribute(ele, TYPE_ATTRIBUTE))) {
 277  562
       String mappingDirection = getAttribute(ele, TYPE_ATTRIBUTE);
 278  562
       MappingDirection direction = MappingDirection.valueOf(mappingDirection);
 279  562
       fieldMapBuilder.type(direction);
 280  
     }
 281  13448
     if (StringUtils.isNotEmpty(getAttribute(ele, CUSTOM_CONVERTER_ATTRIBUTE))) {
 282  69
       fieldMapBuilder.customConverter(getAttribute(ele, CUSTOM_CONVERTER_ATTRIBUTE));
 283  
     }
 284  13448
     if (StringUtils.isNotEmpty(getAttribute(ele, CUSTOM_CONVERTER_ID_ATTRIBUTE))) {
 285  16
       fieldMapBuilder.customConverterId(getAttribute(ele, CUSTOM_CONVERTER_ID_ATTRIBUTE));
 286  
     }
 287  13448
     if (StringUtils.isNotEmpty(getAttribute(ele, CUSTOM_CONVERTER_PARAM_ATTRIBUTE))) {
 288  22
       fieldMapBuilder.customConverterParam(getAttribute(ele, CUSTOM_CONVERTER_PARAM_ATTRIBUTE));
 289  
     }
 290  
 
 291  13448
     parseFieldMap(ele, fieldMapBuilder);
 292  13448
   }
 293  
 
 294  
   private DozerBuilder.FieldMappingBuilder determineFieldMap(DozerBuilder.MappingBuilder definitionBuilder, Element ele) {
 295  13450
     DozerBuilder.FieldMappingBuilder fieldMapBuilder = definitionBuilder.field();
 296  
 
 297  13450
     NodeList nl = ele.getChildNodes();
 298  46394
     for (int i = 0; i < nl.getLength(); i++) {
 299  32946
       Node node = nl.item(i);
 300  32946
       if (node instanceof Element) {
 301  31382
         Element element = (Element) node;
 302  
 
 303  31382
         if (A_ELEMENT.equals(element.getNodeName())) {
 304  13450
           String name = getNodeValue(element);
 305  13450
           String type = getAttribute(element, TYPE_ATTRIBUTE);
 306  13450
           DozerBuilder.FieldDefinitionBuilder builder = fieldMapBuilder.a(name, type);
 307  13450
           parseField(element, builder);
 308  
         }
 309  31382
         if (B_ELEMENT.equals(element.getNodeName())) {
 310  13450
           String name = getNodeValue(element);
 311  13450
           String type = getAttribute(element, TYPE_ATTRIBUTE);
 312  13450
           DozerBuilder.FieldDefinitionBuilder builder = fieldMapBuilder.b(name, type);
 313  13448
           parseField(element, builder);
 314  
         }
 315  
       }
 316  
     }
 317  
 
 318  13448
     return fieldMapBuilder;
 319  
   }
 320  
 
 321  
   private void parseFieldMap(Element ele, DozerBuilder.FieldMappingBuilder fieldMapBuilder) {
 322  13448
     setRelationshipType(ele, fieldMapBuilder);
 323  
 
 324  13448
     if (StringUtils.isNotEmpty(getAttribute(ele, REMOVE_ORPHANS))) {
 325  22
       fieldMapBuilder.removeOrphans(BooleanUtils.toBoolean(getAttribute(ele, REMOVE_ORPHANS)));
 326  
     }
 327  
 
 328  13448
     NodeList nl = ele.getChildNodes();
 329  46390
     for (int i = 0; i < nl.getLength(); i++) {
 330  32942
       Node node = nl.item(i);
 331  32942
       if (node instanceof Element) {
 332  31378
         Element element = (Element) node;
 333  
 
 334  31378
         debugElement(element);
 335  
 
 336  31378
         parseFieldElements(element, fieldMapBuilder);
 337  31378
         if (SRC_TYPE_HINT_ELEMENT.equals(element.getNodeName())) {
 338  1816
           String hint = getNodeValue(element);
 339  1816
           fieldMapBuilder.srcHintContainer(hint);
 340  
         }
 341  31378
         if (DEST_TYPE_HINT_ELEMENT.equals(element.getNodeName())) {
 342  2584
           String hint = getNodeValue(element);
 343  2584
           fieldMapBuilder.destHintContainer(hint);
 344  
         }
 345  31378
         if (SRC_TYPE_DEEP_INDEX_HINT_ELEMENT.equals(element.getNodeName())) {
 346  34
           String hint = getNodeValue(element);
 347  34
           fieldMapBuilder.srcDeepIndexHintContainer(hint);
 348  
         }
 349  31378
         if (DEST_TYPE_DEEP_INDEX_HINT_ELEMENT.equals(element.getNodeName())) {
 350  48
           String hint = getNodeValue(element);
 351  48
           fieldMapBuilder.destDeepIndexHintContainer(hint);
 352  
         }
 353  
       }
 354  
     }
 355  13448
   }
 356  
 
 357  
   private void setRelationshipType(Element ele, DozerBuilder.FieldMappingBuilder definitionBuilder) {
 358  13448
     RelationshipType relationshipType = null;
 359  13448
     if (StringUtils.isNotEmpty(getAttribute(ele, RELATIONSHIP_TYPE))) {
 360  808
       String relationshipTypeValue = getAttribute(ele, RELATIONSHIP_TYPE);
 361  808
       relationshipType = RelationshipType.valueOf(relationshipTypeValue);
 362  
     }
 363  13448
     definitionBuilder.relationshipType(relationshipType);
 364  13448
   }
 365  
 
 366  
   private void parseField(Element ele, DozerBuilder.FieldDefinitionBuilder fieldBuilder) {
 367  55450
     if (StringUtils.isNotEmpty(getAttribute(ele, DATE_FORMAT))) {
 368  276
       fieldBuilder.dateFormat(getAttribute(ele, DATE_FORMAT));
 369  
     }
 370  55450
     if (StringUtils.isNotEmpty(getAttribute(ele, THE_GET_METHOD_ATTRIBUTE))) {
 371  664
       fieldBuilder.theGetMethod(getAttribute(ele, THE_GET_METHOD_ATTRIBUTE));
 372  
     }
 373  55450
     if (StringUtils.isNotEmpty(getAttribute(ele, THE_SET_METHOD_ATTRIBUTE))) {
 374  3572
       fieldBuilder.theSetMethod(getAttribute(ele, THE_SET_METHOD_ATTRIBUTE));
 375  
     }
 376  55450
     if (StringUtils.isNotEmpty(getAttribute(ele, MAP_GET_METHOD_ATTRIBUTE))) {
 377  956
       fieldBuilder.mapGetMethod(getAttribute(ele, MAP_GET_METHOD_ATTRIBUTE));
 378  
     }
 379  55450
     if (StringUtils.isNotEmpty(getAttribute(ele, MAP_SET_METHOD_ATTRIBUTE))) {
 380  936
       fieldBuilder.mapSetMethod(getAttribute(ele, MAP_SET_METHOD_ATTRIBUTE));
 381  
     }
 382  55450
     if (StringUtils.isNotEmpty(getAttribute(ele, KEY_ATTRIBUTE))) {
 383  1784
       fieldBuilder.key(getAttribute(ele, KEY_ATTRIBUTE));
 384  
     }
 385  55450
     if (StringUtils.isNotEmpty(getAttribute(ele, CREATE_METHOD_ATTRIBUTE))) {
 386  40
       fieldBuilder.createMethod(getAttribute(ele, CREATE_METHOD_ATTRIBUTE));
 387  
     }
 388  55450
     if (StringUtils.isNotEmpty(getAttribute(ele, IS_ACCESSIBLE_ATTRIBUTE))) {
 389  228
       fieldBuilder.accessible(BooleanUtils.toBoolean(getAttribute(ele, IS_ACCESSIBLE_ATTRIBUTE)));
 390  
     }
 391  55450
   }
 392  
 
 393  
   private void parseConfiguration(Element ele, DozerBuilder builder) {
 394  233
     DozerBuilder.ConfigurationBuilder configBuilder = builder.configuration();
 395  233
     NodeList nl = ele.getChildNodes();
 396  1210
     for (int i = 0; i < nl.getLength(); i++) {
 397  977
       Node node = nl.item(i);
 398  977
       if (node instanceof Element) {
 399  735
         Element element = (Element) node;
 400  
 
 401  735
         debugElement(element);
 402  
 
 403  735
         final String nodeValue = getNodeValue(element);
 404  
 
 405  735
         if (STOP_ON_ERRORS_ELEMENT.equals(element.getNodeName())) {
 406  144
           configBuilder.stopOnErrors(Boolean.valueOf(nodeValue));
 407  591
         } else if (DATE_FORMAT.equals(element.getNodeName())) {
 408  135
           configBuilder.dateFormat(nodeValue);
 409  456
         } else if (WILDCARD.equals(element.getNodeName())) {
 410  138
           configBuilder.wildcard(Boolean.valueOf(nodeValue));
 411  318
         } else if (TRIM_STRINGS.equals(element.getNodeName())) {
 412  6
           configBuilder.trimStrings(Boolean.valueOf(nodeValue));
 413  312
         } else if (MAP_NULL.equals(element.getNodeName())) {
 414  1
           configBuilder.mapNull(Boolean.valueOf(nodeValue));
 415  311
         } else if (MAP_EMPTY_STRING.equals(element.getNodeName())) {
 416  1
           configBuilder.mapEmptyString(Boolean.valueOf(nodeValue));
 417  310
         } else if (RELATIONSHIP_TYPE.equals(element.getNodeName())) {
 418  2
           RelationshipType relationshipType = RelationshipType.valueOf(nodeValue);
 419  2
           configBuilder.relationshipType(relationshipType);
 420  2
         } else if (BEAN_FACTORY.equals(element.getNodeName())) {
 421  5
           configBuilder.beanFactory(nodeValue);
 422  303
         } else if (CUSTOM_CONVERTERS_ELEMENT.equals(element.getNodeName())) {
 423  167
           parseCustomConverters(element, configBuilder);
 424  136
         } else if (COPY_BY_REFERENCES_ELEMENT.equals(element.getNodeName())) {
 425  130
           parseCopyByReferences(element, configBuilder);
 426  6
         } else if (ALLOWED_EXCEPTIONS_ELEMENT.equals(element.getNodeName())) {
 427  4
           parseAllowedExceptions(element, configBuilder);
 428  2
         } else if (VARIABLES_ELEMENT.equals(element.getNodeName())) {
 429  2
           parseVariables(element);
 430  
         }
 431  
       }
 432  
     }
 433  233
   }
 434  
 
 435  
   private void parseVariables(Element element) {
 436  2
     NodeList nl = element.getChildNodes();
 437  12
     for (int i = 0; i < nl.getLength(); i++) {
 438  10
       Node node = nl.item(i);
 439  10
       if (node instanceof Element) {
 440  10
         Element ele = (Element) node;
 441  
 
 442  10
         debugElement(ele);
 443  
 
 444  10
         if (VARIABLE_ELEMENT.equals(ele.getNodeName())) {
 445  10
           ELEngine engine = BeanContainer.getInstance().getElEngine();
 446  10
           if (engine != null) {
 447  10
             String name = getAttribute(ele, NAME_ATTRIBUTE);
 448  10
             String value = getNodeValue(ele);
 449  
 
 450  10
             engine.setVariable(name, value);
 451  
           }
 452  
         }
 453  
       }
 454  
     }
 455  
 
 456  2
   }
 457  
 
 458  
   private void parseCustomConverters(Element ele, DozerBuilder.ConfigurationBuilder config) {
 459  167
     NodeList nl = ele.getChildNodes();
 460  892
     for (int i = 0; i < nl.getLength(); i++) {
 461  725
       Node node = nl.item(i);
 462  725
       if (node instanceof Element) {
 463  395
         Element element = (Element) node;
 464  
 
 465  395
         debugElement(element);
 466  
 
 467  395
         if (CONVERTER_ELEMENT.equals(element.getNodeName())) {
 468  395
           String converterType = getAttribute(element, TYPE_ATTRIBUTE);
 469  395
           DozerBuilder.CustomConverterBuilder customConverterBuilder = config.customConverter(converterType);
 470  
 
 471  395
           NodeList list = element.getChildNodes();
 472  1295
           for (int x = 0; x < list.getLength(); x++) {
 473  900
             Node node1 = list.item(x);
 474  900
             if (node1 instanceof Element) {
 475  790
               Element element1 = (Element) node1;
 476  790
               if (CLASS_A_ELEMENT.equals(element1.getNodeName())) {
 477  395
                 customConverterBuilder.classA(getNodeValue(element1));
 478  395
               } else if (CLASS_B_ELEMENT.equals(element1.getNodeName())) {
 479  395
                 customConverterBuilder.classB(getNodeValue(element1));
 480  
               }
 481  
             }
 482  
           }
 483  
         }
 484  
       }
 485  
     }
 486  167
   }
 487  
 
 488  
   private void parseCopyByReferences(Element ele, DozerBuilder.ConfigurationBuilder config) {
 489  130
     NodeList nl = ele.getChildNodes();
 490  260
     for (int i = 0; i < nl.getLength(); i++) {
 491  130
       Node node = nl.item(i);
 492  130
       if (node instanceof Element) {
 493  130
         Element element = (Element) node;
 494  
 
 495  130
         debugElement(element);
 496  
 
 497  130
         if (COPY_BY_REFERENCE.equals(element.getNodeName())) {
 498  130
           String typeMask = getNodeValue(element);
 499  130
           config.copyByReference(typeMask);
 500  
         }
 501  
       }
 502  
     }
 503  130
   }
 504  
 
 505  
   private void parseAllowedExceptions(Element ele, DozerBuilder.ConfigurationBuilder config) {
 506  4
     NodeList nl = ele.getChildNodes();
 507  8
     for (int i = 0; i < nl.getLength(); i++) {
 508  4
       Node node = nl.item(i);
 509  4
       if (node instanceof Element) {
 510  4
         Element element = (Element) node;
 511  
 
 512  4
         debugElement(element);
 513  
 
 514  4
         if (ALLOWED_EXCEPTION_ELEMENT.equals(element.getNodeName())) {
 515  4
           String exceptionType = getNodeValue(element);
 516  4
           config.allowedException(exceptionType);
 517  
         }
 518  
       }
 519  
     }
 520  4
   }
 521  
 
 522  
 }