| /* |
| * Copyright (c) 1998, 2021 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 v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // 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 |
| */ |
| @Override |
| 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(); |
| } |
| } |
