diff options
Diffstat (limited to 'sdo-java/branches/sdo-1.1-incubating/impl/src/main/java/org/apache/tuscany/sdo/helper/BaseSDOExtendedMetaDataImpl.java')
-rw-r--r-- | sdo-java/branches/sdo-1.1-incubating/impl/src/main/java/org/apache/tuscany/sdo/helper/BaseSDOExtendedMetaDataImpl.java | 167 |
1 files changed, 167 insertions, 0 deletions
diff --git a/sdo-java/branches/sdo-1.1-incubating/impl/src/main/java/org/apache/tuscany/sdo/helper/BaseSDOExtendedMetaDataImpl.java b/sdo-java/branches/sdo-1.1-incubating/impl/src/main/java/org/apache/tuscany/sdo/helper/BaseSDOExtendedMetaDataImpl.java new file mode 100644 index 0000000000..88c714f8bf --- /dev/null +++ b/sdo-java/branches/sdo-1.1-incubating/impl/src/main/java/org/apache/tuscany/sdo/helper/BaseSDOExtendedMetaDataImpl.java @@ -0,0 +1,167 @@ +/** + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.tuscany.sdo.helper; + +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EClassifier; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.EReference; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.emf.ecore.ETypedElement; +import org.eclipse.emf.ecore.EcoreFactory; +import org.eclipse.emf.ecore.EcorePackage; +import org.eclipse.emf.ecore.util.BasicExtendedMetaData; +import org.eclipse.emf.ecore.util.ExtendedMetaData; +import org.eclipse.emf.ecore.xml.type.XMLTypePackage; + +/** + * A BasicExtendedMetaData that uses a supplied (SDO) ecore factory to create properties and types. + */ +public class BaseSDOExtendedMetaDataImpl extends BasicExtendedMetaData +{ + protected EcoreFactory ecoreFactory = EcoreFactory.eINSTANCE; + protected DemandMetaData demandMetaData = new DemandMetaData(); + + public static class DemandMetaData { + EClassifier getEObject() { return EcorePackage.eINSTANCE.getEObject(); } + EClassifier getAnyType() { return XMLTypePackage.eINSTANCE.getAnyType(); } + EClassifier getAnySimpleType() { return XMLTypePackage.eINSTANCE.getAnySimpleType(); } + EClassifier getXMLTypeDocumentRoot() { return XMLTypePackage.eINSTANCE.getXMLTypeDocumentRoot(); } + } + + public BaseSDOExtendedMetaDataImpl(EPackage.Registry registry) + { + super(registry); + } + + public EPackage demandPackage(String namespace) + { + EPackage ePackage = demandRegistry.getEPackage(namespace); + if (ePackage == null) + { + ePackage = ecoreFactory.createEPackage(); + ePackage.setNsURI(namespace); + setQualified(ePackage, namespace != null); + if (namespace != null) + { + ePackage.setNsPrefix + (namespace.equals(ExtendedMetaData.XMLNS_URI) ? + namespace.equals(ExtendedMetaData.XML_URI) ? + "xml" : + "xmlns" : + computePrefix(namespace)); + } + demandRegistry.put(namespace, ePackage); + + // demandDocumentRoot(ePackage); + + EClass documentRootEClass = ecoreFactory.createEClass(); + documentRootEClass.getESuperTypes().add(demandMetaData.getXMLTypeDocumentRoot()); + documentRootEClass.setName("DocumentRoot"); + ePackage.getEClassifiers().add(documentRootEClass); + setDocumentRoot(documentRootEClass); + } + return ePackage; + } + + public EClassifier demandType(String namespace, String name) + { + EPackage ePackage = demandPackage(namespace); + EClassifier eClassifier = getType(ePackage, name); + if (eClassifier != null) + { + return eClassifier; + } + else + { + EClass eClass = ecoreFactory.createEClass(); + eClass.setName(name); + eClass.getESuperTypes().add(demandMetaData.getAnyType()); + setContentKind(eClass, MIXED_CONTENT); + ePackage.getEClassifiers().add(eClass); + return eClass; + } + } + + public EStructuralFeature demandFeature(String namespace, String name, boolean isElement, boolean isReference) + { + EPackage ePackage = demandPackage(namespace); + EClass documentRootEClass = getDocumentRoot(ePackage); + EStructuralFeature eStructuralFeature = + isElement ? + getLocalElement(documentRootEClass, namespace, name) : + getLocalAttribute(documentRootEClass, namespace, name); + if (eStructuralFeature != null) + { + return eStructuralFeature; + } + else + { + if (isReference) + { + EReference eReference = ecoreFactory.createEReference(); + eReference.setContainment(isElement); + eReference.setEType(demandMetaData.getEObject()); + eReference.setName(name); + eReference.setDerived(true); + eReference.setTransient(true); + eReference.setVolatile(true); + documentRootEClass.getEStructuralFeatures().add(eReference); + + setFeatureKind(eReference, isElement ? ELEMENT_FEATURE : ATTRIBUTE_FEATURE); + setNamespace(eReference, namespace); + + // Mark the bound as unspecified so that it won't be considered many + // but can nevertheless be recognized as being unspecified and perhaps still be treat as many. + // + if (isElement) + { + eReference.setUpperBound(ETypedElement.UNSPECIFIED_MULTIPLICITY); + } + + return eReference; + } + else + { + EAttribute eAttribute = ecoreFactory.createEAttribute(); + eAttribute.setName(name); + eAttribute.setEType(demandMetaData.getAnySimpleType()); + eAttribute.setDerived(true); + eAttribute.setTransient(true); + eAttribute.setVolatile(true); + documentRootEClass.getEStructuralFeatures().add(eAttribute); + + setFeatureKind(eAttribute, isElement ? ELEMENT_FEATURE : ATTRIBUTE_FEATURE); + setNamespace(eAttribute, namespace); + + // Mark the bound as unspecified so that it won't be considered many + // but can nevertheless be recognized as being unspecified and perhaps still be treat as many. + // + if (isElement) + { + eAttribute.setUpperBound(ETypedElement.UNSPECIFIED_MULTIPLICITY); + } + + return eAttribute; + } + } + } +} |