@Override
 public List<Namespace> addExtraNamespacesToNamespaceResolver(
     Descriptor desc,
     AbstractMarshalRecord marshalRecord,
     CoreAbstractSession session,
     boolean allowOverride,
     boolean ignoreEqualResolvers) {
   if (rootXPathNode.getNonAttributeChildren() == null) {
     return null;
   } else {
     return marshalRecord.addExtraNamespacesToNamespaceResolver(
         desc, session, allowOverride, ignoreEqualResolvers);
   }
 }
 private XPathNode addChild(
     XPathFragment xPathFragment, NodeValue nodeValue, NamespaceResolver namespaceResolver) {
   return rootXPathNode.addChild(xPathFragment, nodeValue, namespaceResolver);
 }
  @Override
  public boolean marshalAttributes(
      MarshalRecord marshalRecord, Object object, CoreAbstractSession session) {
    lazyInitialize();
    boolean hasValue = false;
    NamespaceResolver namespaceResolver = ((Descriptor) descriptor).getNamespaceResolver();

    List<XPathNode> attributeChildren = rootXPathNode.getAttributeChildren();
    if (null != attributeChildren) {
      ObjectMarshalContext objectMarshalContext = ObjectMarshalContext.getInstance();
      for (XPathNode anAttributeChildren : attributeChildren) {
        hasValue =
            anAttributeChildren.marshal(
                    marshalRecord,
                    object,
                    session,
                    namespaceResolver,
                    null,
                    objectMarshalContext,
                    null)
                || hasValue;
      }
    }

    if (rootXPathNode.getAnyAttributeNode() != null) {
      hasValue =
          rootXPathNode
                  .getAnyAttributeNode()
                  .marshal(
                      marshalRecord,
                      object,
                      session,
                      namespaceResolver,
                      null,
                      ObjectMarshalContext.getInstance(),
                      null)
              || hasValue;
    }

    List<XPathNode> selfChildren = rootXPathNode.getSelfChildren();
    if (null != selfChildren) {
      for (XPathNode selfXPathNode : selfChildren) {
        NodeValue marshalNodeValue = selfXPathNode.getMarshalNodeValue();
        if (marshalNodeValue instanceof MappingNodeValue) {
          Mapping selfMapping = ((MappingNodeValue) marshalNodeValue).getMapping();
          Object value = selfMapping.getAttributeValueFromObject(object);
          Descriptor referenceDescriptor = (Descriptor) selfMapping.getReferenceDescriptor();
          Descriptor valueDescriptor;
          if (value != null
              && (referenceDescriptor == null || referenceDescriptor.hasInheritance())) {
            valueDescriptor = (Descriptor) session.getDescriptor(value.getClass());
          } else {
            valueDescriptor = referenceDescriptor;
          }
          if (null != valueDescriptor) {
            marshalRecord.addXsiTypeAndClassIndicatorIfRequired(
                valueDescriptor, referenceDescriptor, (Field) selfMapping.getField(), false);
          }
        }
        selfXPathNode.marshalSelfAttributes(
            marshalRecord, object, session, namespaceResolver, marshalRecord.getMarshaller());
      }
    }

    return hasValue;
  }
  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;
    }
  }
  @Override
  public XMLRecord buildRow(
      XMLRecord record,
      Object object,
      CoreAbstractSession session,
      Marshaller marshaller,
      XPathFragment rootFragment) {
    lazyInitialize();
    XPathNode textNode = rootXPathNode.getTextNode();
    List<XPathNode> nonAttributeChildren = rootXPathNode.getNonAttributeChildren();
    if (null == textNode && null == nonAttributeChildren) {
      return record;
    }

    Descriptor xmlDescriptor = (Descriptor) descriptor;
    XPathNode node = rootXPathNode;
    MarshalRecord marshalRecord = (MarshalRecord) record;
    QName schemaType = null;

    if (marshalRecord.getCycleDetectionStack().contains(object, marshaller.isEqualUsingIdenity())) {
      if (cycleRecoverableClass == null) {
        initCycleRecoverableClasses();
      }
      if (cycleRecoverableClass != null
          && cycleRecoverableClass.isAssignableFrom(object.getClass())) {
        try {
          Object jaxbMarshaller = marshaller.getProperty(Constants.JAXB_MARSHALLER);
          // Create a proxy instance of CycleRecoverable$Context, a parameter to
          // the onCycleDetected method
          Object contextProxy =
              CycleRecoverableContextProxy.getProxy(cycleRecoverableContextClass, jaxbMarshaller);
          // Invoke onCycleDetected method, passing in proxy, and reset
          // 'object' to the returned value
          Method onCycleDetectedMethod =
              object
                  .getClass()
                  .getMethod(ON_CYCLE_DETECTED, new Class[] {cycleRecoverableContextClass});
          object =
              PrivilegedAccessHelper.invokeMethod(
                  onCycleDetectedMethod, object, new Object[] {contextProxy});
        } catch (Exception e) {
          throw XMLMarshalException.marshalException(e);
        }

        // Returned object might have a different descriptor
        xmlDescriptor = (Descriptor) session.getDescriptor(object.getClass());
        if (xmlDescriptor != null) {
          node = ((ObjectBuilder) xmlDescriptor.getObjectBuilder()).getRootXPathNode();
        } else {
          node = null;
        }

        // Push new object
        marshalRecord.getCycleDetectionStack().push(object);

        // Write xsi:type if onCycleDetected returned an object of a type different than the one
        // mapped
        if (xmlDescriptor != descriptor) {
          if (xmlDescriptor == null) {
            schemaType = record.getConversionManager().schemaType(object.getClass());
          } else {
            schemaType = xmlDescriptor.getSchemaReference().getSchemaContextAsQName();
          }
          marshalRecord.writeXsiTypeAttribute(
              xmlDescriptor,
              schemaType.getNamespaceURI(),
              schemaType.getLocalPart(),
              schemaType.getPrefix(),
              false);
        }
      } else {
        // Push the duplicate object anyway, so that we can get the complete cycle string
        marshalRecord.getCycleDetectionStack().push(object);
        throw XMLMarshalException.objectCycleDetected(
            marshalRecord.getCycleDetectionStack().getCycleString());
      }
    } else {
      marshalRecord.getCycleDetectionStack().push(object);
    }

    NamespaceResolver namespaceResolver = null;
    if (xmlDescriptor != null) {
      namespaceResolver = xmlDescriptor.getNamespaceResolver();
    }
    MarshalContext marshalContext = null;
    if (xmlDescriptor != null && xmlDescriptor.isSequencedObject()) {
      SequencedObject sequencedObject = (SequencedObject) object;
      marshalContext = new SequencedMarshalContext(sequencedObject.getSettings());
    } else {
      marshalContext = ObjectMarshalContext.getInstance();
    }
    if (null == nonAttributeChildren) {
      textNode.marshal(
          (MarshalRecord) record,
          object,
          session,
          namespaceResolver,
          marshaller,
          marshalContext,
          rootFragment);
    } else {
      if (node == null) {
        // No descriptor for this object, so manually create a MappingNodeValue and marshal it
        XPathNode n = new XPathNode();
        CompositeObjectMapping m = new XMLCompositeObjectMapping();
        m.setXPath(".");
        XMLCompositeObjectMappingNodeValue nv = new XMLCompositeObjectMappingNodeValue(m);
        n.setMarshalNodeValue(nv);
        nv.marshalSingleValue(
            new XPathFragment("."),
            marshalRecord,
            null,
            object,
            session,
            namespaceResolver,
            marshalContext);
      } else {
        for (int x = 0, size = marshalContext.getNonAttributeChildrenSize(node); x < size; x++) {
          XPathNode xPathNode = (XPathNode) marshalContext.getNonAttributeChild(x, node);
          xPathNode.marshal(
              (MarshalRecord) record,
              object,
              session,
              namespaceResolver,
              marshaller,
              marshalContext.getMarshalContext(x),
              rootFragment);
        }
      }
    }
    marshalRecord.getCycleDetectionStack().pop();
    return record;
  }