/** Test to very that the wrapped constructor properly invokes the wrapped ones. */
public void testListWrapper_constructors() {
int type = List.IMPLICIT;
String[] elements = new String[] {"a", "b", "c"};
ListWrapper lw = new ListWrapper(title, type);
assertEquals("List Title", title, lw.getTitle());
lw = new ListWrapper(title, type, elements, null);
assertEquals("List Title", title, lw.getTitle());
assertEquals("List Items 0", elements[0], lw.getString(0));
assertEquals("List Items 1", elements[1], lw.getString(1));
assertEquals("List Items 2", elements[2], lw.getString(2));
}
/**
* 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: Iterate the non-containment nodes and copy all uni/bi-directional properties on the
* copy.
*
* @param doMap
* @param ncPropMap
*/
private void processNonContainmentNodesPrivate(HashMap doMap, HashMap ncPropMap) {
// for the doMap and ncPropMap we can either deep copy them all now or each one during
// rereferencing later
// iterate nc property map and set bidirectional/unidirectional properties that are in scope
for (Iterator ncIterator = ncPropMap.keySet().iterator();
ncIterator.hasNext(); ) { // p.142 limit scope of while by using for
// get current source dataobject (the one we will set properties on)
DataObject sourceDO = (DataObject) ncIterator.next();
// get the list of properties for the current do
ArrayList aList = (ArrayList) ncPropMap.get(sourceDO);
// iterate property list
for (Iterator propIterator = aList.iterator();
propIterator.hasNext(); ) { // p.142 limit scope of while by using for
// get current property
SDOProperty aProperty = (SDOProperty) propIterator.next();
/*
* Stored in the map we have
* doMap: (a=key, a'=value)
* ncPropMap (a=key, (list of props)=value
* We get the copy from the doMap
* We get the copy of the source by doing a get on the current source do
*/
// get original object that sourceDO points to via current property
Object targetDO = sourceDO.get(aProperty);
// flag whether the property is inside the copy tree
boolean isPropertyInsideCopyTreeScope = false;
// get sourceDO copy that we will be setting the property on
DataObject sourceDOCopy = null;
// lookup copy of targetDO in map
Object targetDOCopy = null;
/*
* Handle 1-n many case
* For containment=true
* the DO's will be cached previously, and both bidirectional (one) and unidirectional
* properties will set the copy on the copy object
* For containment=false
* the DO's will not be cached (outside the tree), only unidirectional properties
* will be set using the original list
*/
if (aProperty.isMany()) {
// create new list to hold copied list items
ListWrapper targetList = (ListWrapper) targetDO;
// get source\DO copy that we will be setting the property on
sourceDOCopy = (DataObject) doMap.get(sourceDO);
// lookup copy of targetDO in map
targetDOCopy = new ArrayList();
for (int i = 0, size = targetList.size(); i < size; i++) {
// get sourceDO key - used as a lookup in our doMap
DataObject sourceDOCopyKey = (DataObject) targetList.get(i);
DataObject sourceDOCopyValue = (DataObject) doMap.get(sourceDOCopyKey);
// add copy to new list
if (sourceDOCopyValue != null) {
// bidirectional/unidirectional inside copy tree - use copy object
((List) targetDOCopy).add(sourceDOCopyValue);
} else {
// non-containment properties are not cached - store original for unidirectional
// targetDOCopy.add(sourceDOCopyKey);
}
}
// check if the target copies are in our map (inside copy tree scope)
// when containment = false then targetDOCopy is empty
// Assume: all items in the list share the same property
isPropertyInsideCopyTreeScope = ((List) targetDOCopy).size() > 0;
} else {
// handle 1-1 DataObject
// lookup copy of targetDO in map
targetDOCopy = doMap.get(targetDO);
// get sourceDO copy that we will be setting the property on
sourceDOCopy = (DataObject) doMap.get(sourceDO);
// check if the target copy is in our map (inside copy tree scope)
isPropertyInsideCopyTreeScope = targetDOCopy != null;
}
// set nc property if we are in the copy tree
// check if the target copy is in our map (inside copy tree scope)
if (isPropertyInsideCopyTreeScope) {
((SDODataObject) sourceDOCopy).set(aProperty, targetDOCopy, false);
} else {
// only set unidirectional properties
if (null == aProperty.getOpposite()) {
// spec 3.9.4 set property to original object when unidirectional
((SDODataObject) sourceDOCopy).set(aProperty, targetDO, false);
}
}
}
}
}
/** Verifies that the toString method has been overridden. */
public void testListWrapper_toStringNoSelection() {
int type = List.IMPLICIT;
ListWrapper fw = new ListWrapper(title, type);
assertEquals(UNOVERRIDED_TOSTRING_ERROR, DisplayableVisitor.toString(fw), fw.toString());
}