/** INTERNAL */
 public void directMarshal(Field field, AbstractMarshalRecord record, Object object) {
   Object fieldValue = null;
   if (marshalNullRepresentation == XMLNullRepresentationType.EMPTY_NODE) {
     fieldValue = Constants.EMPTY_STRING;
   } else {
     if (!field.getLastXPathFragment().isAttribute()) {
       if (marshalNullRepresentation == XMLNullRepresentationType.XSI_NIL) {
         fieldValue = XMLRecord.NIL;
       }
     }
   }
   record.put(field, fieldValue);
 }
  void lazyInitialize() {
    if (initialized) {
      return;
    }
    synchronized (this) {
      if (initialized) {
        return;
      }
      Descriptor xmlDescriptor = (Descriptor) descriptor;

      // MAPPINGS
      Iterator mappingIterator = xmlDescriptor.getMappings().iterator();
      Iterator fieldTransformerIterator;
      Mapping xmlMapping;

      // Transformation Mapping
      TransformationMapping transformationMapping;
      FieldTransformerNodeValue fieldTransformerNodeValue;
      Object[] nextFieldToTransformer;

      // Simple Type Translator
      TypeNodeValue typeNodeValue;

      NodeValue mappingNodeValue = null;
      Field xmlField;
      while (mappingIterator.hasNext()) {
        xmlMapping = (Mapping) mappingIterator.next();

        xmlField = (Field) xmlMapping.getField();
        if (xmlMapping.isTransformationMapping()) {
          transformationMapping = (TransformationMapping) xmlMapping;
          addTransformationMapping(transformationMapping);
          fieldTransformerIterator = transformationMapping.getFieldToTransformers().iterator();
          while (fieldTransformerIterator.hasNext()) {
            fieldTransformerNodeValue = new FieldTransformerNodeValue(transformationMapping);
            nextFieldToTransformer = (Object[]) fieldTransformerIterator.next();
            xmlField = (Field) nextFieldToTransformer[0];
            fieldTransformerNodeValue.setXMLField(xmlField);
            fieldTransformerNodeValue.setFieldTransformer(
                (CoreFieldTransformer) nextFieldToTransformer[1]);
            addChild(
                xmlField.getXPathFragment(),
                fieldTransformerNodeValue,
                xmlDescriptor.getNamespaceResolver());
          }
        } else {
          if (xmlMapping.isAbstractDirectMapping()) {
            mappingNodeValue = new XMLDirectMappingNodeValue((DirectMapping) xmlMapping);
          } else if (xmlMapping.isAbstractCompositeObjectMapping()) {
            mappingNodeValue =
                new XMLCompositeObjectMappingNodeValue((CompositeObjectMapping) xmlMapping);
          } else if (xmlMapping.isAbstractCompositeCollectionMapping()) {
            CompositeCollectionMapping collectionMapping = (CompositeCollectionMapping) xmlMapping;
            mappingNodeValue = new XMLCompositeCollectionMappingNodeValue(collectionMapping);
            if (collectionMapping.getWrapperNullPolicy() != null) {
              addChild(
                  xmlField.getXPathFragment(),
                  new CollectionGroupingElementNodeValue((ContainerValue) mappingNodeValue),
                  xmlDescriptor.getNamespaceResolver());
            }
          } else if (xmlMapping.isAbstractCompositeDirectCollectionMapping()) {
            DirectCollectionMapping collectionMapping = (DirectCollectionMapping) xmlMapping;
            mappingNodeValue = new XMLCompositeDirectCollectionMappingNodeValue(collectionMapping);
            if (collectionMapping.getWrapperNullPolicy() != null) {
              addChild(
                  xmlField.getXPathFragment(),
                  new CollectionGroupingElementNodeValue((ContainerValue) mappingNodeValue),
                  xmlDescriptor.getNamespaceResolver());
            }
          } else if (xmlMapping instanceof InverseReferenceMapping) {
            xmlMapping = (Mapping) ((InverseReferenceMapping) xmlMapping).getInlineMapping();
            if (xmlMapping == null) {
              continue;
            }
            xmlField = (Field) xmlMapping.getField();
            if (xmlMapping.isAbstractCompositeCollectionMapping()) {
              mappingNodeValue =
                  new XMLCompositeCollectionMappingNodeValue(
                      (CompositeCollectionMapping) xmlMapping, true);
            }
            if (xmlMapping.isAbstractCompositeObjectMapping()) {
              mappingNodeValue =
                  new XMLCompositeObjectMappingNodeValue((CompositeObjectMapping) xmlMapping, true);
            }

          } else if (xmlMapping instanceof VariableXPathCollectionMapping) {
            mappingNodeValue =
                new XMLVariableXPathCollectionMappingNodeValue(
                    (VariableXPathCollectionMapping) xmlMapping);
          } else if (xmlMapping instanceof VariableXPathObjectMapping) {
            mappingNodeValue =
                new XMLVariableXPathObjectMappingNodeValue((VariableXPathObjectMapping) xmlMapping);
          } else if (xmlMapping instanceof AnyObjectMapping) {
            mappingNodeValue = new XMLAnyObjectMappingNodeValue((AnyObjectMapping) xmlMapping);
          } else if (xmlMapping instanceof AnyCollectionMapping) {
            mappingNodeValue =
                new XMLAnyCollectionMappingNodeValue((AnyCollectionMapping) xmlMapping);
          } else if (xmlMapping instanceof AnyAttributeMapping) {
            mappingNodeValue =
                new XMLAnyAttributeMappingNodeValue((AnyAttributeMapping) xmlMapping);
          } else if (xmlMapping instanceof BinaryDataMapping) {
            mappingNodeValue = new XMLBinaryDataMappingNodeValue((BinaryDataMapping) xmlMapping);
          } else if (xmlMapping instanceof BinaryDataCollectionMapping) {
            mappingNodeValue =
                new XMLBinaryDataCollectionMappingNodeValue(
                    (BinaryDataCollectionMapping) xmlMapping);
          } else if (xmlMapping instanceof FragmentMapping) {
            mappingNodeValue = new XMLFragmentMappingNodeValue((FragmentMapping) xmlMapping);
          } else if (xmlMapping instanceof FragmentCollectionMapping) {
            mappingNodeValue =
                new XMLFragmentCollectionMappingNodeValue((FragmentCollectionMapping) xmlMapping);
          } else if (xmlMapping instanceof CollectionReferenceMapping) {
            CollectionReferenceMapping xmlColMapping = (CollectionReferenceMapping) xmlMapping;

            List fields = xmlColMapping.getFields();
            Field xmlColMappingField = (Field) xmlColMapping.getField();
            XPathNode branchNode;
            if (null == xmlColMappingField) {
              if (fields.size() > 1 && !xmlColMapping.usesSingleNode()) {
                addChild(
                    XPathFragment.SELF_FRAGMENT,
                    new XMLCollectionReferenceMappingMarshalNodeValue(xmlColMapping),
                    xmlDescriptor.getNamespaceResolver());
              }
              branchNode = rootXPathNode;
            } else {
              branchNode =
                  addChild(
                      ((Field) xmlColMapping.getField()).getXPathFragment(),
                      new XMLCollectionReferenceMappingMarshalNodeValue(xmlColMapping),
                      xmlDescriptor.getNamespaceResolver());
            }

            int containerIndex = -1;
            for (int i = 0, size = fields.size(); i < size; i++) {
              Field xmlFld = (Field) fields.get(i);
              mappingNodeValue = new XMLCollectionReferenceMappingNodeValue(xmlColMapping, xmlFld);
              if (i == 0) {
                addContainerValue((ContainerValue) mappingNodeValue);
                containerIndex = ((ContainerValue) mappingNodeValue).getIndex();
              } else {
                ((ContainerValue) mappingNodeValue).setIndex(containerIndex);
              }
              branchNode.addChild(
                  xmlFld.getXPathFragment(),
                  mappingNodeValue,
                  xmlDescriptor.getNamespaceResolver());
            }
            continue;
          } else if (xmlMapping instanceof ObjectReferenceMapping) {
            ObjectReferenceMapping xmlORMapping = (ObjectReferenceMapping) xmlMapping;
            Iterator fieldIt = xmlORMapping.getFields().iterator();
            while (fieldIt.hasNext()) {
              Field xmlFld = (Field) fieldIt.next();
              mappingNodeValue = new XMLObjectReferenceMappingNodeValue(xmlORMapping, xmlFld);
              addChild(
                  xmlFld.getXPathFragment(),
                  mappingNodeValue,
                  xmlDescriptor.getNamespaceResolver());
            }
            continue;
          } else if (xmlMapping instanceof ChoiceObjectMapping) {
            ChoiceObjectMapping xmlChoiceMapping = (ChoiceObjectMapping) xmlMapping;
            Iterator fields = xmlChoiceMapping.getChoiceElementMappings().keySet().iterator();
            Field firstField = (Field) fields.next();
            XMLChoiceObjectMappingNodeValue firstNodeValue =
                new XMLChoiceObjectMappingNodeValue(xmlChoiceMapping, firstField);
            firstNodeValue.setNullCapableNodeValue(firstNodeValue);
            addChild(
                firstField.getXPathFragment(),
                firstNodeValue,
                xmlDescriptor.getNamespaceResolver());
            while (fields.hasNext()) {
              Field next = (Field) fields.next();
              XMLChoiceObjectMappingNodeValue nodeValue =
                  new XMLChoiceObjectMappingNodeValue(xmlChoiceMapping, next);
              nodeValue.setNullCapableNodeValue(firstNodeValue);
              addChild(next.getXPathFragment(), nodeValue, xmlDescriptor.getNamespaceResolver());
            }
            continue;
          } else if (xmlMapping instanceof ChoiceCollectionMapping) {
            ChoiceCollectionMapping xmlChoiceMapping = (ChoiceCollectionMapping) xmlMapping;

            Iterator<Entry<Field, Mapping>> fields =
                xmlChoiceMapping.getChoiceElementMappings().entrySet().iterator();
            Entry<Field, Mapping> firstEntry = fields.next();
            Field firstField = firstEntry.getKey();

            XMLChoiceCollectionMappingUnmarshalNodeValue unmarshalValue =
                new XMLChoiceCollectionMappingUnmarshalNodeValue(xmlChoiceMapping, firstField);
            XMLChoiceCollectionMappingMarshalNodeValue marshalValue =
                new XMLChoiceCollectionMappingMarshalNodeValue(xmlChoiceMapping, firstField);

            // The reason behind LinkedHashMap is the order of items when for-cycling
            // HashMap.getEntrySet() or HashMap.getKeySet().
            // This change fixes non-determinism (implementation in JDK8 has changed so the order is
            // different (sometimes) than in JDK6 and JDK7).
            HashMap<Field, NodeValue> fieldToNodeValues = new LinkedHashMap<Field, NodeValue>();
            unmarshalValue.setContainerNodeValue(unmarshalValue);
            unmarshalValue.setFieldToNodeValues(fieldToNodeValues);
            if (xmlChoiceMapping.isMixedContent()
                && (xmlChoiceMapping.getMixedContentMapping() == firstEntry.getValue())) {
              unmarshalValue.setIsMixedNodeValue(true);
              marshalValue.setIsMixedNodeValue(true);
            }
            this.addContainerValue(unmarshalValue);
            ((ContainerValue) unmarshalValue.getChoiceElementNodeValue())
                .setIndex(unmarshalValue.getIndex());
            fieldToNodeValues.put(firstField, unmarshalValue);
            addChild(
                firstField.getXPathFragment(),
                unmarshalValue,
                xmlDescriptor.getNamespaceResolver());
            addChild(
                firstField.getXPathFragment(), marshalValue, xmlDescriptor.getNamespaceResolver());
            while (fields.hasNext()) {
              Entry<Field, Mapping> nextEntry = fields.next();
              Field nextField = nextEntry.getKey();
              XMLChoiceCollectionMappingUnmarshalNodeValue nodeValue =
                  new XMLChoiceCollectionMappingUnmarshalNodeValue(xmlChoiceMapping, nextField);
              nodeValue.setContainerNodeValue(unmarshalValue);
              nodeValue.setIndex(unmarshalValue.getIndex());
              ((ContainerValue) nodeValue.getChoiceElementNodeValue())
                  .setIndex(unmarshalValue.getIndex());
              addChild(
                  nextField.getXPathFragment(), nodeValue, xmlDescriptor.getNamespaceResolver());
              fieldToNodeValues.put(nextField, nodeValue);
              if (xmlChoiceMapping.isMixedContent()
                  && (xmlChoiceMapping.getMixedContentMapping() == nextEntry.getValue())) {
                nodeValue.setIsMixedNodeValue(true);
              }
            }
            if (xmlChoiceMapping.isAny()) {
              XMLChoiceCollectionMappingUnmarshalNodeValue nodeValue =
                  new XMLChoiceCollectionMappingUnmarshalNodeValue(
                      xmlChoiceMapping, null, xmlChoiceMapping.getAnyMapping());
              nodeValue.setContainerNodeValue(unmarshalValue);
              nodeValue.setIndex(unmarshalValue.getIndex());
              ((ContainerValue) nodeValue.getChoiceElementNodeValue())
                  .setIndex(unmarshalValue.getIndex());
              addChild(null, nodeValue, xmlDescriptor.getNamespaceResolver());
              fieldToNodeValues.put(null, nodeValue);
              if (xmlChoiceMapping.isMixedContent()) {
                nodeValue.setIsMixedNodeValue(true);
              }
            }
            marshalValue.setFieldToNodeValues(fieldToNodeValues);
            continue;
          }
          if (mappingNodeValue.isContainerValue()) {
            addContainerValue((ContainerValue) mappingNodeValue);
          }
          if (mappingNodeValue.isNullCapableValue()) {
            addNullCapableValue((NullCapableValue) mappingNodeValue);
          }
          if (xmlField != null) {
            addChild(
                xmlField.getXPathFragment(),
                mappingNodeValue,
                xmlDescriptor.getNamespaceResolver());
          } else {
            addChild(null, mappingNodeValue, xmlDescriptor.getNamespaceResolver());
          }
        }
      }

      if (descriptor.hasInheritance()) {
        Field indicatorField = (Field) descriptor.getInheritancePolicy().getClassIndicatorField();
        if (indicatorField != null) {
          if (indicatorField.getLastXPathFragment().getNamespaceURI() != null
              && indicatorField
                  .getLastXPathFragment()
                  .getNamespaceURI()
                  .equals(javax.xml.XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI)
              && indicatorField
                  .getLastXPathFragment()
                  .getLocalName()
                  .equals(Constants.SCHEMA_TYPE_ATTRIBUTE)) {
            xsiTypeIndicatorField = true;
          }
        }
      }

      initialized = true;
    }
  }
  public boolean addXsiTypeAndClassIndicatorIfRequired(
      Descriptor descriptor,
      Descriptor referenceDescriptor,
      Field xmlField,
      boolean isRootElement) {
    ObjectBuilder objectBuilder = (ObjectBuilder) descriptor.getObjectBuilder();
    boolean xsiTypeIndicatorField = objectBuilder.isXsiTypeIndicatorField();

    if (objectBuilder.addClassIndicatorFieldToRow(this)) {
      return true;
    }

    QName leafType = null;
    if (xmlField != null) {
      leafType = xmlField.getLeafElementType();

      XMLSchemaReference xmlRef = descriptor.getSchemaReference();
      if (xmlRef != null) {
        if (leafType == null) {
          if (xmlRef.getType() == XMLSchemaReference.ELEMENT) {
            return false;
          }
          if (referenceDescriptor == null) {
            writeXsiTypeAttribute(descriptor, xmlRef, isRootElement);
            return true;
          }
        } else if (((xmlRef.getType() == XMLSchemaReference.COMPLEX_TYPE)
                || (xmlRef.getType() == XMLSchemaReference.SIMPLE_TYPE))
            && xmlRef.getSchemaContext() != null
            && xmlRef.isGlobalDefinition()) {
          QName ctxQName = xmlRef.getSchemaContextAsQName(descriptor.getNamespaceResolver());
          if (!ctxQName.equals(leafType)) {
            writeXsiTypeAttribute(descriptor, xmlRef, isRootElement);
            return true;
          }
        }
      }
    }

    if (referenceDescriptor != null && referenceDescriptor == descriptor) {
      return false;
    }
    if (descriptor.hasInheritance()
        && !descriptor.getInheritancePolicy().isRootParentDescriptor()) {
      CoreInheritancePolicy inheritancePolicy = descriptor.getInheritancePolicy();
      Field indicatorField = (Field) inheritancePolicy.getClassIndicatorField();
      if (indicatorField != null && xsiTypeIndicatorField) {
        Object classIndicatorValueObject =
            inheritancePolicy.getClassIndicatorMapping().get(descriptor.getJavaClass());
        String classIndicatorUri = null;
        String classIndicatorLocal = null;
        String classIndicatorPrefix = null;
        if (classIndicatorValueObject instanceof QName) {
          QName classIndicatorQName = (QName) classIndicatorValueObject;
          classIndicatorUri = classIndicatorQName.getNamespaceURI();
          classIndicatorLocal = classIndicatorQName.getLocalPart();
          classIndicatorPrefix = classIndicatorQName.getPrefix();
        } else {
          String classIndicatorValue =
              (String) inheritancePolicy.getClassIndicatorMapping().get(descriptor.getJavaClass());
          int nsindex = classIndicatorValue.indexOf(Constants.COLON);
          String prefix = null;
          if (nsindex != -1) {
            classIndicatorLocal = classIndicatorValue.substring(nsindex + 1);
            prefix = classIndicatorValue.substring(0, nsindex);
          } else {
            classIndicatorLocal = classIndicatorValue;
          }
          classIndicatorUri =
              descriptor.getNonNullNamespaceResolver().resolveNamespacePrefix(prefix);
        }
        if (leafType == null
            || isRootElement && marshaller.isApplicationJSON() && !marshaller.isIncludeRoot()
            || !(leafType.getLocalPart().equals(classIndicatorLocal))
            || (classIndicatorUri == null
                && (leafType.getNamespaceURI() != null && leafType.getNamespaceURI().length() > 0))
            || (classIndicatorUri != null
                && !classIndicatorUri.equals(leafType.getNamespaceURI()))) {
          if (inheritancePolicy.hasClassExtractor()) {
            objectBuilder.addClassIndicatorFieldToRow(this);
          } else {
            writeXsiTypeAttribute(
                descriptor,
                classIndicatorUri,
                classIndicatorLocal,
                classIndicatorPrefix,
                isRootElement);
          }
          return true;
        }
        return false;
      }
    }
    return false;
  }