/******************************************************************************* | |
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved. | |
* This program and the accompanying materials are made available under the | |
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 | |
* which accompanies this distribution. | |
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
* and the Eclipse Distribution License is available at | |
* http://www.eclipse.org/org/documents/edl-v10.php. | |
* | |
* Contributors: | |
* Oracle - initial API and implementation from Oracle TopLink | |
******************************************************************************/ | |
/* | |
DESCRIPTION | |
Perform copy/equality junit test operations on DataObjects. | |
References: | |
SDO59-DeepCopy.doc | |
SDO_Ref_BiDir_Relationships_DesignSpec.doc | |
http://files.oraclecorp.com/content/MySharedFolders/ST%20Functional%20Specs/AS11gR1/TopLink/SDO/SDO_Ref_BiDir_Relationships_DesignSpec.doc | |
*/ | |
package org.eclipse.persistence.testing.sdo.helper; | |
import commonj.sdo.DataObject; | |
import commonj.sdo.Property; | |
import java.util.ArrayList; | |
import java.util.List; | |
import javax.xml.namespace.QName; | |
import org.eclipse.persistence.sdo.SDOConstants; | |
import org.eclipse.persistence.sdo.SDODataObject; | |
import org.eclipse.persistence.sdo.SDOProperty; | |
import org.eclipse.persistence.sdo.SDOType; | |
import org.eclipse.persistence.sdo.helper.SDOTypeHelper; | |
import org.eclipse.persistence.testing.sdo.SDOTestCase; | |
public class SDOCopyEqualityHelperTestCases extends SDOTestCase { | |
protected String rootTypeName = "rootTypeName"; | |
protected String rootTypeUri = "rootTypeTypeUri"; | |
protected String containedTypeName = "containedTypeName"; | |
protected String containedTypeUri = "containedTypeTypeUri"; | |
protected String containedType1Name = "containedType1Name"; | |
protected String containedType1Uri = "containedType1TypeUri"; | |
protected String containedByContainedTypeName = "containedByContainedTypeName"; | |
protected String containedBycontainedType1Uri = "containedBycontainedTypeTypeUri"; | |
protected SDODataObject root; | |
protected SDODataObject root1; | |
protected SDODataObject containedDataObject; | |
protected SDODataObject containedDataObject_1; | |
protected SDODataObject containedDataObject1; | |
protected SDODataObject containedByContainedDataObject; | |
protected SDOType rootType; | |
protected SDOType containedType; | |
protected SDOType containedType_1; | |
protected SDOType containedType1; | |
protected SDOType containedByContainedType; | |
protected SDOProperty rootProperty1; | |
protected SDOProperty rootProperty2; | |
protected SDOProperty rootProperty3; | |
protected SDOProperty rootProperty4; | |
protected SDOProperty containedProperty1; | |
protected SDOProperty containedProperty2; | |
protected SDOProperty containedProperty_ChangeSummary; | |
protected SDOProperty contained1Property1; | |
protected SDOProperty containedByContainedProperty1; | |
protected SDOProperty containedByContainedProperty2; | |
// Data structures for UC02xx (bidirectional property between internal nodes) | |
protected String containedType3Name = "containedType3Name"; | |
protected String containedType3Uri = "containedType3TypeUri"; | |
protected SDOType containedByContainedType3; | |
protected SDODataObject containedByContainedDataObject3; | |
protected String containedByContainedTypeName3 = "containedByContainedTypeName3"; | |
protected String containedBycontainedType3Uri = "containedBycontainedTypeType3Uri"; | |
protected SDOProperty containedByContainedProperty3; | |
protected SDOProperty contained1Property3; | |
protected SDOType containedType3; | |
protected SDOProperty containedProperty3; | |
// UC4 | |
protected SDODataObject rootUC4; | |
protected SDODataObject rootUC4m; | |
protected SDOType rootUC4Type; | |
protected SDOType rootUC4Typem; | |
protected SDOType homeType; | |
protected SDOType homeTypem; | |
protected SDOType workType; | |
protected SDOType workTypem; | |
protected SDOType addressType; | |
protected SDOType addressTypem; | |
protected SDODataObject workObject; | |
protected SDODataObject workObjectm; | |
protected SDODataObject homeObject; | |
protected SDODataObject homeObjectm; | |
protected SDODataObject addressObject; | |
protected SDODataObject addressObjectm; | |
protected SDOProperty homeAddress; | |
protected SDOProperty homeAddressm; | |
protected SDOProperty rootHome; | |
protected SDOProperty rootHomem; | |
protected SDOProperty rootWork; | |
protected SDOProperty rootWorkm; | |
protected SDOProperty workAddress; | |
protected SDOProperty workAddressm; | |
protected SDOProperty addressWork; | |
protected SDOProperty addressWorkm; | |
protected String workObjectName = "workObjectName"; | |
protected String homeObjectName = "homeObjectName"; | |
protected String addressObjectName = "addressObjectName"; | |
protected String workObjectUri = "workObjectUri"; | |
protected String homeObjectUri = "homeObjectUri"; | |
protected String addressObjectUri = "addressObjectUri"; | |
protected String workObjectUrim = "workObjectUrim"; | |
protected String homeObjectUrim = "homeObjectUrim"; | |
protected String addressObjectUrim = "addressObjectUrim"; | |
// property strings | |
protected String rootUC4TypeName = "rootUC4TypeName"; | |
protected String rootUC4TypeUri = "rootUC4TypeTypeUri"; | |
protected String rootUC4TypeUrim = "rootUC4TypeTypeUrim"; | |
protected String rootHomeName = "rootHome"; | |
protected String rootWorkName = "rootWork"; | |
protected String homeAddressName = "homeAddress"; | |
protected String workAddressName = "workAddress"; | |
protected String addressWorkName = "addressWork"; | |
protected String rootHomeUri = "rootHomeUri"; | |
protected String rootHomeUrim = "rootHomeUrim"; | |
protected String rootWorkUri = "rootWorkUri"; | |
protected String rootWorkUrim = "rootWorkUrim"; | |
protected String homeAddressUri = "homeAddressUri"; | |
protected String workAddressUri = "workAddressUri"; | |
protected String addressWorkUri = "addressWorkUri"; | |
protected String homeAddressUrim = "homeAddressUrim"; | |
protected String workAddressUrim = "workAddressUrim"; | |
protected String addressWorkUrim = "addressWorkUrim"; | |
// UCUniOutside | |
protected SDODataObject rootUCUniOutside; | |
protected SDOType rootUCUniOutsideType; | |
protected SDOType homeTypeUCUniOutside; | |
protected SDOType workTypeUCUniOutside; | |
protected SDOType addressTypeUCUniOutside; | |
protected SDODataObject workObjectUCUniOutside; | |
protected SDODataObject homeObjectUCUniOutside; | |
protected SDODataObject addressObjectUCUniOutside; | |
protected SDOProperty homeAddressUCUniOutside; | |
protected SDOProperty rootHomeUCUniOutside; | |
protected SDOProperty rootWorkUCUniOutside; | |
protected SDOProperty workAddressUCUniOutside; | |
protected SDOProperty addressWorkUCUniOutside; | |
protected String workObjectNameUCUniOutside = "workObjectNameUCUniOutside"; | |
protected String homeObjectNameUCUniOutside = "homeObjectNameUCUniOutside"; | |
protected String addressObjectNameUCUniOutside = "addressObjectNameUCUniOutside"; | |
protected String workObjectUriUCUniOutside = "workObjectUriUCUniOutside"; | |
protected String homeObjectUriUCUniOutside = "homeObjectUriUCUniOutside"; | |
protected String addressObjectUriUCUniOutside = "addressObjectUriUCUniOutside"; | |
// property strings | |
protected String rootUCUniOutsideTypeName = "rootUCUniOutsideTypeName"; | |
protected String rootUCUniOutsideTypeUri = "rootUCUniOutsideTypeTypeUri"; | |
protected String rootHomeNameUCUniOutside = "rootHome"; | |
protected String rootWorkNameUCUniOutside = "rootWork"; | |
protected String homeAddressNameUCUniOutside = "homeAddress"; | |
protected String workAddressNameUCUniOutside = "workAddress"; | |
protected String addressWorkNameUCUniOutside = "addressWork"; | |
protected String rootHomeUriUCUniOutside = "rootHomeUri"; | |
protected String rootWorkUriUCUniOutside = "rootWorkUri"; | |
protected String homeAddressUriUCUniOutside = "homeAddressUri"; | |
protected String workAddressUriUCUniOutside = "workAddressUri"; | |
protected String addressWorkUriUCUniOutside = "addressWorkUri"; | |
protected List objects = new ArrayList(); | |
protected List objects1 = new ArrayList(); | |
public SDOCopyEqualityHelperTestCases(String name) { | |
super(name); | |
} | |
/** | |
* Structure: | |
* | |
* root | |
* rootproperty1 --> is DataType; SDOString <---> value: "test" | |
* rootproperty2 --> not DataType <---> value: containedDataObject | |
* root's child: | |
* containedDataObject1 | |
* contained1Property1 --> not DataType; bidirectional <---> value: containedByContainedDataObject | |
* containedDataObject | |
* containedProperty1 --> is DataType; SDOString <---> value: "test1" | |
* containedProperty2 --> not DataType <---> value: containedByContainedDataObject | |
* containedProperty3 --> not DataType <---> value: containedByContainedDataObject3 (bidirectional inside sub-tree copy tree) | |
* containedProperty_ChangeSummary --> not DataType <---> value: chSum(ChangeSummary) | |
* containedDataObject's child: | |
* containedByContainedDataObject | |
* containedByContainedProperty1 --> not DataType; bidirectional <---> value: containedDataObejct1 | |
* | |
* Covered test cases: | |
* Test case 1: copied root's DataType property rootproperty1 has same value | |
* Test Case 2: copied root's not DataType property rootproperty2 has a copied DataObject from containedDataObject | |
* Test case 3: there exists dataobject's bidirectional not containment property has another DataObject as value | |
* Test Case 4: there exists dataobject's unidirectional not containment property has another DataObject as value | |
* Test Case 5: there exists dataobject's non containment property has another DataObject that is not in containment tree as value | |
* Test Case 6: copied containedProperty's ChangeSummary Type property containedProperty_ChangeSummary has a copied ChangeSummary from source's ChangeSummary chSum | |
*/ | |
public void setUp() { | |
super.setUp(); | |
SDOType changeSummaryType = (SDOType) aHelperContext.getTypeHelper().getType(SDOConstants.SDO_URL, SDOConstants.CHANGESUMMARY); | |
// first we set up root data object | |
DataObject rootTypeDO = defineType(rootTypeUri, rootTypeName); | |
rootType = (SDOType)typeHelper.define(rootTypeDO); | |
rootProperty1 = new SDOProperty(aHelperContext);// root's property1 | |
rootProperty1.setName("rootproperty1-datatype"); | |
SDOType rootProperty1_type = SDOConstants.SDO_STRING;// string type | |
rootProperty1.setType(rootProperty1_type); | |
rootType.addDeclaredProperty(rootProperty1);// add this property to root type's declared list | |
rootProperty2 = new SDOProperty(aHelperContext);//root's property2 | |
rootProperty2.setName("rootproperty2-notdatatype"); | |
rootProperty2.setContainment(true);// containment property | |
SDOType rootProperty2_type = new SDOType("notDataTypeUri", "notDataType"); | |
QName qname = new QName("notDataTypeUri", "notDataType"); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, rootProperty2_type); | |
rootProperty2.setType(rootProperty2_type); | |
rootType.addDeclaredProperty((Property)rootProperty2); | |
rootProperty3 = new SDOProperty(aHelperContext);// root's property3 | |
rootProperty3.setName("rootproperty3-notdatatype"); | |
rootProperty3.setContainment(true);// containment property | |
DataObject rootProperty3_typeDO = defineType("notDataTypeUri1", "notDataType1"); | |
SDOType rootProperty3_type = (SDOType)typeHelper.define(rootProperty3_typeDO); | |
rootProperty3.setType(rootProperty3_type); | |
rootType.addDeclaredProperty(rootProperty3); | |
rootProperty4 = new SDOProperty(aHelperContext); | |
rootProperty4.setName("rootproperty4-list"); | |
rootProperty4.setContainment(true); | |
rootProperty4.setMany(true); | |
DataObject rootProperty4_typeDO = defineType("listPropertyUri", "listProperty"); | |
SDOType rootProperty4_type = (SDOType)typeHelper.define(rootProperty4_typeDO); | |
rootProperty4.setType(rootProperty4_type); | |
rootType.addDeclaredProperty(rootProperty4); | |
SDOProperty rootProperty_NotContainment = new SDOProperty(aHelperContext); | |
rootProperty_NotContainment.setContainment(false); | |
DataObject rootProperty_NotContainment_typeDO = defineType("rootProperty_NotContainmenturi", "rootProperty_NotContainment"); | |
SDOType rootProperty_NotContainment_type = (SDOType)typeHelper.define(rootProperty_NotContainment_typeDO); | |
rootProperty_NotContainment.setType(rootProperty_NotContainment_type); | |
rootProperty_NotContainment.setName("rootProperty_NotContainment"); | |
rootType.addDeclaredProperty(rootProperty_NotContainment); | |
// 20060913: opposite property 3 (to test bidirectional property inside subtree copy tree) | |
contained1Property3 = new SDOProperty(aHelperContext);// containedDataObject3's property3 | |
contained1Property3.setName("contained1Property3-notdataType"); | |
contained1Property3.setContainment(false);// non-containment property | |
DataObject contained1Property3_typeDO = defineType("contained1Property3Uri", "contained1Property3_notdataType"); | |
SDOType contained1Property3_type = (SDOType)typeHelper.define(contained1Property3_typeDO); | |
contained1Property3.setType(contained1Property3_type); | |
objects = new ArrayList(); | |
SDOType obj1Type = new SDOType("listelm1", "listelm1"); | |
qname = new QName("listelm1", "listelm1"); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, obj1Type); | |
SDOProperty obj1Property = new SDOProperty(aHelperContext); | |
obj1Property.setName("obj1Property"); | |
SDOType obj1PropertyType = SDOConstants.SDO_STRING; | |
obj1Property.setType(obj1PropertyType); | |
obj1Property.setContainment(false); | |
obj1Type.addDeclaredProperty(obj1Property); | |
SDODataObject obj1 = (SDODataObject)dataFactory.create(obj1Type); | |
objects.add(obj1); | |
obj1.set(obj1Property, "test"); | |
// second, we create another dataobject contained by root | |
DataObject containedTypeDO = defineType(containedTypeUri, containedTypeName); | |
containedType = (SDOType)typeHelper.define(containedTypeDO); | |
containedProperty1 = new SDOProperty(aHelperContext);// containedDataObject's property1 | |
containedProperty1.setName("containedProperty1-dataType"); | |
SDOType containedProperty1_type = SDOConstants.SDO_STRING;// String Type | |
containedProperty1.setType(containedProperty1_type); | |
containedType.addDeclaredProperty(containedProperty1); | |
containedProperty2 = new SDOProperty(aHelperContext);// containedDataObject's property2 | |
containedProperty2.setName("containedProperty2-notdataType"); | |
containedProperty2.setContainment(true);// containment property | |
SDOType containedProperty2_type = new SDOType(// | |
"containedProperty2Uri", "containedProperty2_notdataType"); | |
qname = new QName("containedProperty2Uri", "containedProperty2_notdataType"); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, containedProperty2_type); | |
containedProperty2_type.setDataType(false);// not datatype | |
containedProperty2.setType(containedProperty2_type); | |
containedType.addDeclaredProperty(containedProperty2); | |
// 20060914 new bidirectional hosting node | |
containedProperty3 = new SDOProperty(aHelperContext);// containedDataObject's property2 | |
containedProperty3.setName("containedProperty3-notdataType"); | |
containedProperty3.setContainment(true);// containment property | |
SDOType containedProperty3_type = new SDOType(// | |
"containedProperty3Uri", "containedProperty3_notdataType"); | |
qname = new QName("containedProperty3Uri", "containedProperty3_notdataType"); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, containedProperty3_type); | |
containedProperty3_type.setDataType(false);// not datatype | |
containedProperty3.setType(containedProperty3_type); | |
containedType.addDeclaredProperty(containedProperty3); | |
containedProperty_ChangeSummary = new SDOProperty(aHelperContext); | |
containedProperty_ChangeSummary.setContainment(false); | |
containedProperty_ChangeSummary.setType(changeSummaryType); | |
containedProperty_ChangeSummary.setName("containedProperty_ChangeSummary"); | |
containedType.addDeclaredProperty(containedProperty_ChangeSummary); | |
containedDataObject = (SDODataObject)dataFactory.create(containedType); | |
// then, we create one dataobject as root's non containment property' value | |
containedType1 = new SDOType(containedType1Uri, containedType1Name); | |
qname = new QName(containedType1Uri, containedType1Name); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, containedType1); | |
contained1Property1 = new SDOProperty(aHelperContext);// containedDataObject1's property1 | |
contained1Property1.setName("contained1Property1-notdataType"); | |
contained1Property1.setContainment(false);// non containment property | |
SDOType contained1Property1_type = new SDOType(// | |
"contained1Property1Uri", "contained1Property1_notdataType"); | |
qname = new QName("contained1Property1Uri", "contained1Property1_notdataType"); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, contained1Property1_type); | |
contained1Property1_type.setDataType(false);// not datatype | |
contained1Property1.setType(contained1Property1_type); | |
// TODO: 20060906 bidirectional | |
// bidirectional to containedByContainedDataObject | |
// Note: the property parameter is null so this set will have no effect until the 2nd set later | |
contained1Property1.setOpposite(containedByContainedProperty1); | |
containedType1.addDeclaredProperty(contained1Property1); | |
containedDataObject1 = (SDODataObject)dataFactory.create(containedType1); | |
// finally, we create a dataobject contained by containedDataObject | |
containedByContainedType = new SDOType(containedBycontainedType1Uri, containedByContainedTypeName); | |
qname = new QName(containedBycontainedType1Uri, containedByContainedTypeName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, containedByContainedType); | |
containedByContainedProperty1 = new SDOProperty(aHelperContext);// containedByContainedDataObject's property1 | |
containedByContainedProperty1.setName("containedByContainedProperty1-notdataType"); | |
containedByContainedProperty1.setContainment(false);// non containment property | |
SDOType containedByContainedProperty1_type = new SDOType(// | |
"containedByContainedProperty1Uri", "containedByContainedProperty1_notdataType"); | |
qname = new QName("containedByContainedProperty1Uri", "containedByContainedProperty1_notdataType"); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, containedByContainedProperty1_type); | |
containedByContainedProperty1_type.setDataType(false);// not datatype | |
containedByContainedProperty1.setType(containedByContainedProperty1_type); | |
// TODO: 20060906 bidirectional | |
// bidirectional to containedDataObject1 | |
containedByContainedProperty1.setOpposite(contained1Property1); | |
containedByContainedType.addDeclaredProperty(containedByContainedProperty1); | |
// reset opposite set above when property paramenter used to be null | |
contained1Property1.setOpposite(containedByContainedProperty1); | |
containedByContainedProperty2 = new SDOProperty(aHelperContext);// containedByContainedDataObject's property1 | |
containedByContainedProperty2.setName("containedByContainedProperty2-dataType"); | |
containedByContainedProperty2.setContainment(false);// non containment property | |
SDOType containedByContainedProperty2_type = new SDOType(// | |
"containedByContainedProperty2Uri", "containedByContainedProperty2_notdataType"); | |
qname = new QName("containedByContainedProperty2Uri", "containedByContainedProperty2_notdataType"); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, containedByContainedProperty2_type); | |
containedByContainedProperty2_type.setDataType(false);// not datatype | |
containedByContainedProperty2.setType(containedByContainedProperty2_type); | |
containedByContainedType.addDeclaredProperty(containedByContainedProperty2); | |
// opposite property 3 | |
containedByContainedProperty3 = new SDOProperty(aHelperContext);// containedByContainedDataObject2's property3 | |
containedByContainedProperty3.setName("containedByContainedProperty3-notdataType"); | |
containedByContainedProperty3.setContainment(false);// non-containment property | |
SDOType containedByContainedProperty3_type = new SDOType(// | |
"containedByContainedProperty3Uri", "containedByContainedProperty3_notdataType"); | |
qname = new QName("containedByContainedProperty3Uri", "containedByContainedProperty3_notdataType"); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, containedByContainedProperty3_type); | |
containedByContainedProperty3_type.setDataType(false);// non-datatype | |
containedByContainedProperty3.setType(containedByContainedProperty3_type); | |
containedByContainedType.addDeclaredProperty(containedByContainedProperty3); | |
containedByContainedDataObject = (SDODataObject)dataFactory.create(// | |
containedByContainedType); | |
// set up relationship | |
root = (SDODataObject)dataFactory.create(rootType); | |
root.set(rootProperty1, "test"); | |
root.set(rootProperty2, containedDataObject);// child: containedDataObject | |
root.set(rootProperty3, containedDataObject1);// child: containedDataObject1 | |
root.set(rootProperty4, objects); | |
containedDataObject.set(containedProperty1, "test1"); | |
// child: containedByContainedDataObject | |
containedDataObject.set(containedProperty2, containedByContainedDataObject); | |
// set opposite property | |
containedDataObject1.set(contained1Property1, containedByContainedDataObject); | |
// set opposite property | |
containedByContainedDataObject.set(containedByContainedProperty1, containedDataObject1); | |
/* | |
// UC02xx: setup some bidirectional properties that have the same copy root | |
// but are 1 level down from the source root so that copy root != source root | |
// new CBCDO2 off off CDO | |
containedByContainedType3 = new SDOType(containedBycontainedType3Uri, containedByContainedTypeName3); | |
// add property to do | |
//containedByContainedType3.addDeclaredProperty(containedByContainedProperty3); | |
// 20060913 | |
//containedType3 = new SDOType(containedType3Uri, containedType3Name); | |
// add property to do | |
containedByContainedType3.addDeclaredProperty(contained1Property3); | |
// new DO | |
containedByContainedDataObject3 = (SDODataObject)dataFactory.create(// | |
containedByContainedType3); | |
// 2 new opposite properties CBCP2 and C1P2 between CBCDO and CBCDO2 | |
// set opposite property | |
// containedByContainedDataObject3.set(contained1Property3, containedByContainedDataObject); | |
// set opposite property | |
containedByContainedDataObject.set(containedByContainedProperty3, containedByContainedDataObject3); | |
// child: containedByContainedDataObject | |
// containedDataObject.set(containedProperty3, containedByContainedDataObject3); | |
// attach opposite properties between CBCDO and CBCDO2 | |
// bidirectional to containedDataObject1 | |
containedByContainedProperty3.setOpposite(contained1Property3); | |
// reset opposite set above when property paramenter used to be null | |
contained1Property3.setOpposite(containedByContainedProperty3); | |
*/ | |
// UC 4: mixed containment=true/containment=false bidirectional opposite set | |
// (work at home relationship) | |
// root -> home -> address | |
// root -> work -> address | |
// home/address -> noncontainment to -> work | |
// work -> containment to -> home/address | |
rootUC4Type = new SDOType(rootUC4TypeUri, rootUC4TypeName);// root's type | |
qname = new QName(rootUC4TypeUri, rootUC4TypeName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, rootUC4Type); | |
homeType = new SDOType(homeObjectUri, homeObjectName); | |
qname = new QName(homeObjectUri, homeObjectName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, homeType); | |
addressType = new SDOType(addressObjectUri, addressObjectName); | |
qname = new QName(addressObjectUri, addressObjectName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, addressType); | |
workType = new SDOType(workObjectUri, workObjectName); | |
qname = new QName(workObjectUri, workObjectName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, workType); | |
rootHome = new SDOProperty(aHelperContext); | |
rootHome.setName(rootHomeName); | |
rootHome.setContainment(true);// containment property | |
SDOType rootHome_type = new SDOType(rootHomeUri, rootHomeName); | |
qname = new QName(rootHomeUri, rootHomeName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, rootHome_type); | |
rootHome_type.setDataType(false);// not datatype | |
rootHome.setType(rootHome_type); | |
rootUC4Type.addDeclaredProperty((Property)rootHome); | |
rootWork = new SDOProperty(aHelperContext); | |
rootWork.setName(rootWorkName); | |
// non containment so that a containment opposite can be set to this node | |
rootWork.setContainment(false);//true);// containment property | |
//rootWork.setContainment(true);// containment property | |
SDOType rootWork_type = new SDOType(rootWorkUri, rootWorkName); | |
qname = new QName(rootWorkUri, rootWorkName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, rootWork_type); | |
rootWork_type.setDataType(false);// not datatype | |
rootWork.setType(rootWork_type); | |
rootUC4Type.addDeclaredProperty((Property)rootWork); | |
homeAddress = new SDOProperty(aHelperContext); | |
homeAddress.setName(homeAddressName); | |
homeAddress.setContainment(true);// containment property | |
SDOType homeAddress_type = new SDOType(homeAddressUri, homeAddressName); | |
qname = new QName(homeAddressUri, homeAddressName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, homeAddress_type); | |
homeAddress_type.setDataType(false);// not datatype | |
homeAddress.setType(homeAddress_type); | |
homeType.addDeclaredProperty((Property)homeAddress); | |
workAddress = new SDOProperty(aHelperContext); | |
workAddress.setName(workAddressName); | |
// one opposite property can be true | |
workAddress.setContainment(false);//true);// containment property | |
//workAddress.setContainment(true);// containment property | |
SDOType workAddress_type = new SDOType(workAddressUri, workAddressName); | |
qname = new QName(workAddressUri, workAddressName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, workAddress_type); | |
workAddress_type.setDataType(false);// not datatype | |
workAddress.setType(workAddress_type); | |
workType.addDeclaredProperty((Property)workAddress); | |
addressWork = new SDOProperty(aHelperContext); | |
addressWork.setName(addressWorkName); | |
// other opposite property must be false | |
addressWork.setContainment(true);// containment property | |
SDOType addressWork_type = new SDOType(addressWorkUri, addressWorkName); | |
qname = new QName(addressWorkUri, addressWorkName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, addressWork_type); | |
addressWork_type.setDataType(false);// not datatype | |
addressWork.setType(addressWork_type); | |
addressType.addDeclaredProperty((Property)addressWork); | |
rootUC4 = (SDODataObject)dataFactory.create(rootUC4Type); | |
addressObject = (SDODataObject)dataFactory.create(addressType); | |
homeObject = (SDODataObject)dataFactory.create(homeType); | |
workObject = (SDODataObject)dataFactory.create(workType); | |
addressWork.setOpposite(workAddress); | |
workAddress.setOpposite(addressWork); | |
rootUC4.set(rootHome, homeObject); | |
rootUC4.set(rootWork, workObject); | |
// child: | |
homeObject.set(homeAddress, addressObject); | |
// set opposite property | |
addressObject.set(addressWork, workObject); | |
// set opposite property | |
workObject.set(workAddress, addressObject); | |
// many case | |
// UC 4: mixed containment=true/containment=false bidirectional opposite set | |
// (work at home relationship) | |
// root -> home -> address | |
// root -> work -> address | |
// home/address -> noncontainment to -> work | |
// work -> containment to -> home/address | |
rootUC4Typem = new SDOType(rootUC4TypeUrim, rootUC4TypeName);// root's type | |
qname = new QName(rootUC4TypeUrim, rootUC4TypeName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, rootUC4Typem); | |
homeTypem = new SDOType(homeObjectUrim, homeObjectName); | |
qname = new QName(homeObjectUrim, homeObjectName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, homeTypem); | |
addressTypem = new SDOType(addressObjectUrim, addressObjectName); | |
qname = new QName(addressObjectUrim, addressObjectName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, addressTypem); | |
workTypem = new SDOType(workObjectUrim, workObjectName); | |
qname = new QName(workObjectUrim, workObjectName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, workTypem); | |
rootHomem = new SDOProperty(aHelperContext); | |
rootHomem.setName(rootHomeName); | |
rootHomem.setContainment(true);// containment property | |
SDOType rootHome_typem = new SDOType(rootHomeUrim, rootHomeName); | |
qname = new QName(rootHomeUrim, rootHomeName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, rootHome_typem); | |
rootHome_typem.setDataType(false);// not datatype | |
rootHomem.setType(rootHome_typem); | |
rootUC4Typem.addDeclaredProperty((Property)rootHomem); | |
rootWorkm = new SDOProperty(aHelperContext); | |
rootWorkm.setName(rootWorkName); | |
// non containment so that a containment opposite can be set to this node | |
rootWorkm.setContainment(false);//true);// containment property | |
rootWorkm.setMany(true); | |
SDOType rootWork_typem = new SDOType(rootWorkUrim, rootWorkName); | |
qname = new QName(rootWorkUrim, rootWorkName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, rootWork_typem); | |
rootWork_typem.setDataType(false);// not datatype | |
rootWorkm.setType(rootWork_typem); | |
rootUC4Typem.addDeclaredProperty((Property)rootWorkm); | |
homeAddressm = new SDOProperty(aHelperContext); | |
homeAddressm.setName(homeAddressName); | |
homeAddressm.setContainment(true);// containment property | |
SDOType homeAddress_typem = new SDOType(homeAddressUrim, homeAddressName); | |
qname = new QName(homeAddressUrim, homeAddressName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, homeAddress_typem); | |
homeAddress_typem.setDataType(false);// not datatype | |
homeAddressm.setType(homeAddress_typem); | |
homeTypem.addDeclaredProperty((Property)homeAddressm); | |
workAddressm = new SDOProperty(aHelperContext); | |
workAddressm.setName(workAddressName); | |
// one opposite property can be true | |
workAddressm.setContainment(false);//true);// containment property | |
//workAddress.setContainment(true);// containment property | |
SDOType workAddress_typem = new SDOType(workAddressUri, workAddressName); | |
qname = new QName(workAddressUri, workAddressName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, workAddress_typem); | |
workAddress_typem.setDataType(false);// not datatype | |
workAddressm.setType(workAddress_typem); | |
workTypem.addDeclaredProperty((Property)workAddressm); | |
addressWorkm = new SDOProperty(aHelperContext); | |
addressWorkm.setName(addressWorkName); | |
// other opposite property must be false | |
addressWorkm.setContainment(false);// containment property | |
addressWorkm.setMany(true); | |
SDOType addressWork_typem = new SDOType(addressWorkUri, addressWorkName); | |
qname = new QName(addressWorkUri, addressWorkName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, addressWork_typem); | |
addressWork_typem.setDataType(false);// not datatype | |
addressWorkm.setType(addressWork_typem); | |
addressTypem.addDeclaredProperty((Property)addressWorkm); | |
rootUC4m = (SDODataObject)dataFactory.create(rootUC4Typem); | |
addressObjectm = (SDODataObject)dataFactory.create(addressTypem); | |
homeObjectm = (SDODataObject)dataFactory.create(homeTypem); | |
workObjectm = (SDODataObject)dataFactory.create(workTypem); | |
addressWorkm.setOpposite(workAddressm); | |
workAddressm.setOpposite(addressWorkm); | |
rootUC4m.set(rootHomem, homeObjectm); | |
ArrayList workList = new ArrayList(); | |
workList.add(workObjectm); | |
rootUC4m.set(rootWorkm, workList); | |
//rootUC4m.set(rootWorkm, workObjectm); | |
// child: | |
homeObjectm.set(homeAddressm, addressObjectm); | |
// set opposite property | |
addressObjectm.set(addressWorkm, workList);//workObjectm); | |
// set opposite property | |
workObjectm.set(workAddressm, addressObjectm); | |
// UC 1b: unidirectional outside the copytree | |
// (work at home relationship) | |
// root -> home -> address | |
// root -> work -> address | |
// home/address -> noncontainment to -> work | |
// | |
rootUCUniOutsideType = new SDOType(rootUCUniOutsideTypeUri, rootUCUniOutsideTypeName);// root's type | |
qname = new QName(rootUCUniOutsideTypeUri, rootUCUniOutsideTypeName); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, rootUCUniOutsideType); | |
homeTypeUCUniOutside = new SDOType(homeObjectUriUCUniOutside, homeObjectNameUCUniOutside); | |
qname = new QName(homeObjectUriUCUniOutside, homeObjectNameUCUniOutside); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, homeTypeUCUniOutside); | |
addressTypeUCUniOutside = new SDOType(addressObjectUriUCUniOutside, addressObjectNameUCUniOutside); | |
qname = new QName(addressObjectUriUCUniOutside, addressObjectNameUCUniOutside); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, addressTypeUCUniOutside); | |
workTypeUCUniOutside = new SDOType(workObjectUriUCUniOutside, workObjectNameUCUniOutside); | |
qname = new QName(workObjectUriUCUniOutside, workObjectNameUCUniOutside); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, workTypeUCUniOutside); | |
rootHomeUCUniOutside = new SDOProperty(aHelperContext); | |
rootHomeUCUniOutside.setName(rootHomeNameUCUniOutside); | |
rootHomeUCUniOutside.setContainment(true);// containment property | |
SDOType rootHome_typeUCUniOutside = new SDOType(rootHomeUriUCUniOutside, rootHomeNameUCUniOutside); | |
qname = new QName(rootHomeUriUCUniOutside, rootHomeNameUCUniOutside); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, rootHome_typeUCUniOutside); | |
rootHome_typeUCUniOutside.setDataType(false);// not datatype | |
rootHomeUCUniOutside.setType(rootHome_typeUCUniOutside); | |
rootUCUniOutsideType.addDeclaredProperty((Property)rootHomeUCUniOutside); | |
rootWorkUCUniOutside = new SDOProperty(aHelperContext); | |
rootWorkUCUniOutside.setName(rootWorkNameUCUniOutside); | |
// non containment so that a containment opposite can be set to this node | |
rootWorkUCUniOutside.setContainment(false);//true);// containment property | |
SDOType rootWork_typeUCUniOutside = new SDOType(rootWorkUriUCUniOutside, rootWorkNameUCUniOutside); | |
qname = new QName(rootWorkUriUCUniOutside, rootWorkNameUCUniOutside); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, rootWork_typeUCUniOutside); | |
rootWork_typeUCUniOutside.setDataType(false);// not datatype | |
rootWorkUCUniOutside.setType(rootWork_typeUCUniOutside); | |
rootUCUniOutsideType.addDeclaredProperty((Property)rootWorkUCUniOutside); | |
homeAddressUCUniOutside = new SDOProperty(aHelperContext); | |
homeAddressUCUniOutside.setName(homeAddressNameUCUniOutside); | |
homeAddressUCUniOutside.setContainment(true);// containment property | |
SDOType homeAddress_typeUCUniOutside = new SDOType(homeAddressUriUCUniOutside, homeAddressNameUCUniOutside); | |
qname = new QName(homeAddressUriUCUniOutside, homeAddressNameUCUniOutside); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, homeAddress_typeUCUniOutside); | |
homeAddress_typeUCUniOutside.setDataType(false);// not datatype | |
homeAddressUCUniOutside.setType(homeAddress_typeUCUniOutside); | |
homeTypeUCUniOutside.addDeclaredProperty((Property)homeAddressUCUniOutside); | |
/* | |
workAddressUCUniOutside = new SDOProperty(aHelperContext); | |
workAddressUCUniOutside.setName(workAddressNameUCUniOutside); | |
// one opposite property can be true | |
workAddressUCUniOutside.setContainment(false);//true);// containment property | |
SDOType workAddress_typeUCUniOutside = new SDOType(workAddressUriUCUniOutside, workAddressNameUCUniOutside); | |
workAddress_typeUCUniOutside.setDataType(false);// not datatype | |
workAddressUCUniOutside.setType(workAddress_typeUCUniOutside); | |
workTypeUCUniOutside.addDeclaredProperty((Property)workAddressUCUniOutside); | |
*/ | |
addressWorkUCUniOutside = new SDOProperty(aHelperContext); | |
addressWorkUCUniOutside.setName(addressWorkNameUCUniOutside); | |
// other opposite property must be false | |
addressWorkUCUniOutside.setContainment(true);//false);// containment property | |
SDOType addressWork_typeUCUniOutside = new SDOType(addressWorkUriUCUniOutside, addressWorkNameUCUniOutside); | |
qname = new QName(addressWorkUriUCUniOutside, addressWorkNameUCUniOutside); | |
((SDOTypeHelper)typeHelper).getTypesHashMap().put(qname, addressWork_typeUCUniOutside); | |
addressWork_typeUCUniOutside.setDataType(false);// not datatype | |
addressWorkUCUniOutside.setType(addressWork_typeUCUniOutside); | |
addressTypeUCUniOutside.addDeclaredProperty((Property)addressWorkUCUniOutside); | |
rootUCUniOutside = (SDODataObject)dataFactory.create(rootUCUniOutsideType); | |
addressObjectUCUniOutside = (SDODataObject)dataFactory.create(addressTypeUCUniOutside); | |
homeObjectUCUniOutside = (SDODataObject)dataFactory.create(homeTypeUCUniOutside); | |
workObjectUCUniOutside = (SDODataObject)dataFactory.create(workTypeUCUniOutside); | |
//addressWorkUCUniOutside.setOpposite(workAddressUCUniOutside); | |
//workAddressUCUniOutside.setOpposite(addressWorkUCUniOutside); | |
rootUCUniOutside.set(rootHomeUCUniOutside, homeObjectUCUniOutside); | |
rootUCUniOutside.set(rootWorkUCUniOutside, workObjectUCUniOutside); | |
// child: | |
homeObjectUCUniOutside.set(homeAddressUCUniOutside, addressObjectUCUniOutside); | |
// set opposite property | |
addressObjectUCUniOutside.set(addressWorkUCUniOutside, workObjectUCUniOutside); | |
// set opposite property | |
//workObjectUCUniOutside.set(workAddressUCUniOutside, addressObjectUCUniOutside); | |
containedDataObject.getChangeSummary().beginLogging(); | |
} | |
} |