/**
  * INTERNAL: Used during XML Unmarshal.
  *
  * @param dataObject
  * @param property
  * @param cs
  * @return
  */
 private Object getValue(SDODataObject dataObject, Property property, SDOChangeSummary cs) {
   if (cs != null) {
     Object returnValue = cs.getPropertyInternal(dataObject, property);
     if (property.isMany()) {
       if (cs.getOriginalElements().containsKey(returnValue)) {
         // are we using the cast to List as a sort of instance check that would throw a CCE?
         return cs.getOriginalElements().get(returnValue);
       }
     }
     return returnValue;
   }
   return dataObject.get(property); // get the value of current property
 }
  public ValueStore copy() {
    AbstractSession session =
        ((JAXBContext) jaxbHelperContext.getJAXBContext()).getXMLContext().getSession(entity);
    Object originalEntity = entity;
    entity = descriptor.getInstantiationPolicy().buildNewInstance();

    for (SDOProperty sdoProperty : (List<SDOProperty>) dataObject.getType().getProperties()) {
      if (!sdoProperty.getType().isChangeSummaryType()) {
        Mapping mapping = getJAXBMappingForProperty(sdoProperty);
        CoreAttributeAccessor attributeAccessor = mapping.getAttributeAccessor();
        Object attributeValue = attributeAccessor.getAttributeValueFromObject(originalEntity);
        if (mapping.isCollectionMapping()) {
          Object containerCopy = null;
          SDOChangeSummary sdoChangeSummary = dataObject.getChangeSummary();
          if (null != sdoChangeSummary) {
            List list = listWrappers.get(sdoProperty);
            containerCopy = sdoChangeSummary.getOriginalElements().get(list);
          }
          if (null == containerCopy) {
            CoreContainerPolicy containerPolicy = mapping.getContainerPolicy();
            containerCopy = containerPolicy.containerInstance();
            if (null != attributeValue) {
              Object attributeValueIterator = containerPolicy.iteratorFor(attributeValue);
              while (containerPolicy.hasNext(attributeValueIterator)) {
                containerPolicy.addInto(
                    containerPolicy.nextEntry(attributeValueIterator), containerCopy, session);
              }
            }
          }
          attributeAccessor.setAttributeValueInObject(entity, containerCopy);
        } else {
          attributeAccessor.setAttributeValueInObject(entity, attributeValue);
        }
      }
    }
    return new JAXBValueStore(
        jaxbHelperContext, originalEntity, descriptor, dataObject, listWrappers);
  }
  /**
   * INTERNAL: Implement ChangeSummary deep copy Note: a copy with a CS requires the
   * DefautlValueStore implementation because of changes outside the ValueStore interface for the
   * dataObject field DeepCopy the original changeSummary into the copy dataObject. All deleted keys
   * in originalValueStore, deletedMap, deepCopies are the same original object. We require the
   * following relationships in order to build copies of originals and copies of copies of
   * originals. origDOtoCopyDOMap original object (deleted + current) - in original DO : copy of
   * original object - in copy DO copyDOtoCopyOfDOMap
   *
   * <p>Assumptions: Property objects instances are copied only by reference - metadata is the same
   * in the copy. Deleted objects never exist in the currentValueStore (and are therefore not in the
   * doMap). Created and modified objects are always in the currentValueStore (and are in the
   * doMap).
   *
   * @param anOriginalCS
   * @param aCopyCS
   * @param doMap (map of original do's (CS1) to their copy do's in (CS2))
   */
  private void copyChangeSummary(
      ChangeSummary anOriginalCS,
      ChangeSummary aCopyCS, //
      Map origDOCS1toCopyDOCS2Map) {
    // cast interfaces to concrete classes in one place
    SDOChangeSummary originalCS = (SDOChangeSummary) anOriginalCS;
    SDOChangeSummary copyCS = (SDOChangeSummary) aCopyCS;

    // handled by copy constructor
    // map of copy of original ListWrapper (CS2) to its new copy of a copy (CS2) - link ValueStores
    // to Elements
    HashMap copyListWrapperCS2toCopyOfListCS2Map = new HashMap();

    // in the absence of a ListWrapper.getProperty() we keep a map
    HashMap propertyToOriginalListMap = new HashMap();

    /** In 3 parts we add deleted objects to the global doMap and copy modified, created nodes */

    // fields that need re-referencing from original to copy
    DataObject anOriginalObject = null;
    DataObject aCopyOfOriginalObject = null;

    // iterate deleted objects
    for (Iterator anIterator = originalCS.getDeleted().iterator(); anIterator.hasNext(); ) {
      anOriginalObject = (DataObject) anIterator.next();
      aCopyOfOriginalObject = copy(anOriginalObject, null);
      // fix deletedList
      copyCS.getDeleted().add(aCopyOfOriginalObject);
      // Assumption check do map before a possible re-add - reset()
      if (null == origDOCS1toCopyDOCS2Map.get(anOriginalObject)) {
        // add temp map of original  : copy of original
        origDOCS1toCopyDOCS2Map.put(anOriginalObject, aCopyOfOriginalObject);
      }
    }

    // iterate created objects
    for (Iterator aIterator = originalCS.getCreated().iterator(); aIterator.hasNext(); ) {
      copyCS.getCreated().add(origDOCS1toCopyDOCS2Map.get(aIterator.next()));
    }

    // add modified objects
    for (Iterator anIterator = originalCS.getModified().iterator(); anIterator.hasNext(); ) {
      copyCS.getModified().add(origDOCS1toCopyDOCS2Map.get(anIterator.next()));
    }

    /**
     * Fix originalValueStores by deep copying the original dataObject:key and the original
     * valueStore:value key is original deleted object in [deepCopies] - value is copy of the
     * ValueStore
     */
    ValueStore aVSCopy = null;
    ValueStore aVSOriginal = null;
    for (Iterator anIterator = originalCS.getOriginalValueStores().keySet().iterator();
        anIterator.hasNext(); ) {
      anOriginalObject = (DataObject) anIterator.next();
      // deep copy to get corresponding copy DataObject (deleted objects were added to doMap)
      aCopyOfOriginalObject = (DataObject) origDOCS1toCopyDOCS2Map.get(anOriginalObject);

      /**
       * Recursively shallow-copy elements (by iterating the ovs map and iterating the properties of
       * each item) Fix the dataObject pointer
       */
      aVSCopy = createValueStore();
      aVSOriginal = (ValueStore) originalCS.getOriginalValueStores().get(anOriginalObject);
      // changes made to the copy VS must not affect the original -hence the dataObject field must
      // be a copy of the original
      aVSCopy.initialize(aCopyOfOriginalObject);
      Object aVSPropertyItem = null;

      // get the # of non-opencontent properties for the object holding the CS - do not use
      // DVS.getTypePropertyValues()
      for (int size = ((SDOType) anOriginalObject.getType()).getDeclaredProperties().size(), i = 0;
          i < size;
          i++) {
        aVSPropertyItem = aVSOriginal.getDeclaredProperty(i);
        // only iterate set properties
        if (aVSOriginal.isSetDeclaredProperty(i)) {
          // shallow copy the object values
          // handle single case
          SDOProperty currentProperty =
              (SDOProperty) ((SDOType) anOriginalObject.getType()).getDeclaredProperties().get(i);
          if (currentProperty.isMany()) {
            propertyToOriginalListMap.put(aVSPropertyItem, currentProperty);

            // handle many case - handled by originalElements
            // container DO must be in our reference map
            SDODataObject copyContainer =
                (SDODataObject) origDOCS1toCopyDOCS2Map.get(anOriginalObject);
            ListWrapper aCopyOfListCopy =
                (ListWrapper) ((DataObject) copyContainer).getList(currentProperty);

            // add reference of new copy of original List keyed on original List
            copyListWrapperCS2toCopyOfListCS2Map.put(
                (anOriginalObject).getList(currentProperty), aCopyOfListCopy);
            aVSCopy.setDeclaredProperty(i, aCopyOfListCopy);
          } else {
            // COMPLEX SINGLE
            if (!currentProperty.getType().isDataType()) {
              // are we using the cast to DataObject as a sort of instance check that would throw a
              // CCE?
              aVSCopy.setDeclaredProperty(i, origDOCS1toCopyDOCS2Map.get(aVSPropertyItem));
            } else {
              // SIMPLE SINGLE
              // skip changeSummary property
              if (!currentProperty.getType().isChangeSummaryType()) {
                // simple singles set
                aVSCopy.setDeclaredProperty(i, aVSPropertyItem);
              }
            }
          }
        }
      }

      // create list of unset and current open content properties
      List ocPropertiesList = new ArrayList();
      ocPropertiesList.addAll(originalCS.getUnsetOCProperties(anOriginalObject));
      // add existing properties
      ocPropertiesList.addAll(((SDODataObject) anOriginalObject)._getOpenContentProperties());
      ocPropertiesList.addAll(
          ((SDODataObject) anOriginalObject)._getOpenContentPropertiesAttributes());
      // iterate existing open content properties
      for (Iterator i = ocPropertiesList.iterator(); i.hasNext(); ) {
        SDOProperty ocProperty = (SDOProperty) i.next();
        if (aVSOriginal.isSetOpenContentProperty(ocProperty)) {
          // get oc value
          Object anOCPropertyItem = aVSOriginal.getOpenContentProperty(ocProperty);

          // get oc copy - shallow copy the object values
          if (ocProperty.isMany()) {
            // handle many case - handled by originalElements
            // container DO must be in our reference map
            SDODataObject copyContainer =
                (SDODataObject) origDOCS1toCopyDOCS2Map.get(anOriginalObject);
            ListWrapper aCopyOfListCopy =
                (ListWrapper) ((DataObject) copyContainer).getList(ocProperty);

            // add reference of new copy of original List keyed on original List
            copyListWrapperCS2toCopyOfListCS2Map.put(
                (anOriginalObject).getList(ocProperty), aCopyOfListCopy);
            aVSCopy.setOpenContentProperty(ocProperty, aCopyOfListCopy);
          } else {
            // handle complex single case
            if (!ocProperty.getType().isDataType()) {
              aVSCopy.setOpenContentProperty(
                  ocProperty, origDOCS1toCopyDOCS2Map.get(aVSPropertyItem));
            } else {
              // simple singles set
              aVSCopy.setOpenContentProperty(ocProperty, anOCPropertyItem);
            }
          }
        }
      }

      // set the copy map entry keyed on copy with value a deep copy of the copy
      copyCS.getOriginalValueStores().put(aCopyOfOriginalObject, aVSCopy);
    }

    // end originalValueStore iteration

    /**
     * Fix originalElements by deep copying the original dataObject:key and the original List:value
     * key is original deleted object in [deepCopies] - value is copy of the elements The instances
     * of ListWrapper inside the valueStores must be the same ones used in the originalElements
     */
    ListWrapper anOriginalListKey = null;
    ListWrapper aCopyListWrapper = null;
    List aCopyList = null;
    for (Iterator anIterator = originalCS.getOriginalElements().keySet().iterator();
        anIterator.hasNext(); ) {
      anOriginalListKey = (ListWrapper) anIterator.next();
      // create a new ListWrapper
      SDOProperty aProperty = (SDOProperty) propertyToOriginalListMap.get(anOriginalListKey);
      aCopyListWrapper = (ListWrapper) copyListWrapperCS2toCopyOfListCS2Map.get(anOriginalListKey);
      aCopyList = new ArrayList();

      /**
       * For each key:ListWrapper - shallow copy all the items in the currentElements list - replace
       * the dataObject with its copy of the copy - leave the property as is For each
       * value:ArrayList - replace all values with their copy
       */
      Object aListItem = null;
      Object aListItemCopy = null;
      for (Iterator anItemIterator = anOriginalListKey.iterator(); anItemIterator.hasNext(); ) {
        aListItem = anItemIterator.next();
        // for simple many types we use the original in the copy
        if (!aProperty.getType().isDataType()) {
          // get the copy of the original (in the current valuestore) - we need do not make a copy
          // of this copy
          // we should have a copy of the copy for List items - ListWrapper.add(item) will remove
          // the item from its original wrapper
          aListItemCopy = origDOCS1toCopyDOCS2Map.get(aListItem);
        } else {
          aListItemCopy = aListItem;
        }
        aCopyList.add(aListItemCopy);
      }

      // add element list directly to the ListWrapper and bypass the cs element copy and containment
      // updates
      aCopyListWrapper.setCurrentElements(aCopyList);
      List listValueCopy = new ArrayList();

      // fix ArrayList value
      List listValue = (List) originalCS.getOriginalElements().get(anOriginalListKey);
      aListItem = null;
      aListItemCopy = null;
      for (Iterator aListIterator = listValue.iterator(); aListIterator.hasNext(); ) {
        aListItem = aListIterator.next();
        // for simple many types we use the original in the copy
        if (!aProperty.getType().isDataType()) {
          aListItemCopy = origDOCS1toCopyDOCS2Map.get(aListItem);
        } else {
          aListItemCopy = aListItem;
        }

        // don't add nulls to the listWrapper so an undoChanges will encounter an NPE later
        if (aListItemCopy != null) {
          listValueCopy.add(aListItemCopy);
        }
      }

      // set the copy map entry keyed on copy with value a deep copy of the copy
      copyCS.getOriginalElements().put(aCopyListWrapper, listValueCopy);
    }

    // end originalist Iteration

    /**
     * fields that are already set when logging is turned on but need to be fixed (deleted objects
     * need references)
     */
    Map oldContainersMap = originalCS.getOldContainers();
    Map copyContainersMap = copyCS.getOldContainers();
    DataObject oldContainerKey = null;
    DataObject copyContainerKey = null;

    // convert any existing entries in the Map - should normally be 0 - unless any OC properties
    // were unset
    for (Iterator anIterator = oldContainersMap.keySet().iterator(); anIterator.hasNext(); ) {
      oldContainerKey = (DataObject) anIterator.next();
      // get corresponding copy
      copyContainerKey = (SDODataObject) origDOCS1toCopyDOCS2Map.get(oldContainerKey);
      // check existing copyContainers for existing objects - should be 0 - add all objects when
      // pauseLogging() used
      DataObject oldContainerValue = null;
      if (null == copyContainersMap.get(copyContainerKey)) {
        oldContainerValue = (DataObject) oldContainersMap.get(oldContainerKey);
        // set copy key:value pair on copy map directly
        copyContainersMap.put(copyContainerKey, origDOCS1toCopyDOCS2Map.get(oldContainerValue));
      }
    }

    Map oldContainmentPropertyMap = originalCS.getOldContainmentProperty();
    Map copyContainmentPropertyMap = copyCS.getOldContainmentProperty();
    DataObject oldContainmentPropertyKey = null;
    DataObject copyContainmentPropertyKey = null;

    // convert any existing entries in the Map - should normally be 0 - unless any OC properties
    // were unset
    for (Iterator iterContProp = oldContainmentPropertyMap.keySet().iterator();
        iterContProp.hasNext(); ) {
      oldContainmentPropertyKey = (DataObject) iterContProp.next();
      // get corresponding copy
      copyContainmentPropertyKey =
          (SDODataObject) origDOCS1toCopyDOCS2Map.get(oldContainmentPropertyKey);
      // check existing copyContainers for existing objects - should be 0 - add all objects when
      // pauseLogging() used
      if (null == copyContainmentPropertyMap.get(copyContainmentPropertyKey)) {
        // set copy key:value pair on copy map directly
        copyContainmentPropertyMap.put(
            copyContainmentPropertyKey, oldContainmentPropertyMap.get(oldContainmentPropertyKey));
      }
    }

    Map oldUnsetOCPropertyMap = originalCS.getUnsetOCPropertiesMap();
    SDODataObject oldOCPropertyContainer = null;

    // convert any existing entries in the Map - should normally be 0
    for (Iterator iterContainer = oldUnsetOCPropertyMap.keySet().iterator();
        iterContainer.hasNext(); ) {
      // DataObject will be non-Null
      oldOCPropertyContainer = (SDODataObject) iterContainer.next();
      // check existing copyContainers for existing objects - should be 0 - add all objects when
      // pauseLogging() used
      for (Iterator iterUnset =
              ((List) oldUnsetOCPropertyMap.get(oldOCPropertyContainer)).iterator();
          iterUnset.hasNext(); ) {
        // set/create new list on copy Map with corresponding copy of container
        copyCS.setUnsetOCProperty(
            (SDODataObject)
                origDOCS1toCopyDOCS2Map.get( //
                    oldOCPropertyContainer),
            (Property) iterUnset.next());
      }
    }

    // process sequences

    /**
     * Fix originalSequences by deep copying the original dataObject:key and the original
     * Sequence:value key is original deleted object in [deepCopies] - value is copy of the settings
     * in the sequence. The instances of Sequence inside the originalSequences must be the same ones
     * used in the originalElements
     */

    // iterate the map of <DataObject, Sequence>
    for (Iterator aMapIterator = originalCS.getOriginalSequences().keySet().iterator();
        aMapIterator.hasNext(); ) {
      SDODataObject sequenceDataObjectKey = (SDODataObject) aMapIterator.next();
      SDOSequence originalSequence =
          (SDOSequence) originalCS.getOriginalSequences().get(sequenceDataObjectKey);

      // create a new Sequence with a pointer to the copy of the original DataObject backpointer
      // assume that all dataObject backpointers are containment objects.
      SDODataObject copyOriginalSequenceDataObject =
          (SDODataObject) origDOCS1toCopyDOCS2Map.get(originalSequence.getDataObject());
      SDOSequence copySequence = new SDOSequence(copyOriginalSequenceDataObject);

      replicateAndRereferenceSequenceCopyPrivate(
          originalSequence,
          copySequence,
          originalSequence.getDataObject(),
          copyOriginalSequenceDataObject,
          origDOCS1toCopyDOCS2Map,
          originalCS);

      // set the copy map entry keyed on copy with value a deep copy of the copy
      copyCS.getOriginalSequences().put(copyOriginalSequenceDataObject, copySequence);
    }

    /**
     * fields to ignore // aHelperContext SDOHelperContext (id=42) // dataGraph null // logging true
     * // loggingMapping true // unsetPropsMap HashMap<K,V> (id=117) // createdXPaths null //
     * deletedXPaths null // modifiedDoms null
     */
    /**
     * fields to ignore that are on-demand oldSettings HashMap<K,V> (id=110) reverseDeletedMap
     * HashMap<K,V> (id=116) oldSequences HashMap<K,V> (id=88)
     */
  }
  /**
   * INTERNAL: Make a copy of all settings on the original sequence onto the copy sequence while
   * using a cross-reference doMap that relates the original DataObject key to the copy DataObject
   * key. This function is used during deep copy and changeSummary copy.
   *
   * @param origSequence
   * @param copySequence
   * @param doMap
   */
  private void replicateAndRereferenceSequenceCopyPrivate(
      SDOSequence origSequence,
      SDOSequence copySequence,
      DataObject dataObject,
      DataObject copy,
      Map doMap,
      SDOChangeSummary cs) {
    if (cs != null && cs.isDeleted(dataObject)) {
      origSequence = cs.getOldSequence(dataObject);
    }

    SDOProperty seqProperty = null;
    try {
      List settings = origSequence.getSettings();
      for (int index = 0, size = origSequence.size(); index < size; index++) {
        Setting nextSetting = (Setting) settings.get(index);
        seqProperty = origSequence.getProperty(nextSetting);

        if ((null == seqProperty) || seqProperty.getType().isDataType()) {
          Setting copySetting = nextSetting.copy(copy);
          copySequence.getSettings().add(copySetting);
          copySequence.addValueToSettings(copySetting);
        } else {
          Object copySeqValue = null;
          Object origSeqValue = origSequence.getValue(index);

          if (cs != null) {
            Object orig = cs.getReverseDeletedMap().get(origSeqValue);
            if (orig != null) {
              origSeqValue = orig;
            }
          }

          if (origSeqValue instanceof XMLRoot) {
            origSeqValue = ((XMLRoot) origSeqValue).getObject();
          }

          // lookup copy if not null, if null then the copySeqValue will be null in the reduced
          // scope assignment above
          if (null != origSeqValue) {
            copySeqValue = doMap.get(origSeqValue);
          } else {
            // as a secondary verification to the assignment above - make sure the copy is null as
            // well
            copySeqValue =
                null; // this assignment is however redundant in our reduced scope assignment above
          }

          // now we have the new value
          Setting copySetting = nextSetting.copy(copy, copySeqValue);
          copySequence.getSettings().add(copySetting);
          copySequence.addValueToSettings(copySetting);
        }

        /**
         * Move assignment inside the loop to minimize scope and to initialize the variable to null
         * to handle the case where the original is null and no lookup is performed. Do not move the
         * scope of this variable outside the for loop or we will end up with the previous
         * iterations' value set for a complex object that is unset(null). see #6026714
         */
      }
    } catch (ClassCastException cce) { // catch any failure of a DataObject cast above
      throw SDOException.foundSimpleValueForNonDataTypeProperty(seqProperty.getName());
    }
  }
 /**
  * INTERNAL: Used during XML Unmarshal.
  *
  * @param dataObject
  * @param property
  * @param cs
  * @return
  */
 private boolean isSet(SDODataObject dataObject, Property property, SDOChangeSummary cs) {
   if (cs != null) {
     return cs.wasSet(dataObject, property);
   }
   return dataObject.isSetInternal(property);
 }