diff options
author | lresende <lresende@13f79535-47bb-0310-9956-ffa450edef68> | 2009-11-10 19:20:12 +0000 |
---|---|---|
committer | lresende <lresende@13f79535-47bb-0310-9956-ffa450edef68> | 2009-11-10 19:20:12 +0000 |
commit | 195774c489a1a671aca514b0afa88332bf9c6ee3 (patch) | |
tree | a22cb1f3f70f0c13a9a7049075205072901459aa /sdo-java/tags/1.1.1-RC2a/impl/src/main/java/org/apache/tuscany/sdo/util/resource/SDODeserializer.java | |
parent | c54bda13cb403d10675a6244bd00b8b536111ad6 (diff) |
Moving SDO tags
git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@834617 13f79535-47bb-0310-9956-ffa450edef68
Diffstat (limited to 'sdo-java/tags/1.1.1-RC2a/impl/src/main/java/org/apache/tuscany/sdo/util/resource/SDODeserializer.java')
-rw-r--r-- | sdo-java/tags/1.1.1-RC2a/impl/src/main/java/org/apache/tuscany/sdo/util/resource/SDODeserializer.java | 340 |
1 files changed, 340 insertions, 0 deletions
diff --git a/sdo-java/tags/1.1.1-RC2a/impl/src/main/java/org/apache/tuscany/sdo/util/resource/SDODeserializer.java b/sdo-java/tags/1.1.1-RC2a/impl/src/main/java/org/apache/tuscany/sdo/util/resource/SDODeserializer.java new file mode 100644 index 0000000000..01c043b074 --- /dev/null +++ b/sdo-java/tags/1.1.1-RC2a/impl/src/main/java/org/apache/tuscany/sdo/util/resource/SDODeserializer.java @@ -0,0 +1,340 @@ +/** + * + * 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.util.resource; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import javax.xml.namespace.NamespaceContext; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; + +import org.apache.tuscany.sdo.helper.HelperContextImpl; +import org.apache.tuscany.sdo.helper.TypeHelperImpl; +import org.apache.tuscany.sdo.helper.XMLStreamHelper; +import org.apache.tuscany.sdo.helper.XMLStreamHelperImpl; +import org.apache.tuscany.sdo.util.StreamDeserializer; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.common.util.TreeIterator; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EReference; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.util.ExtendedMetaData; +import org.eclipse.emf.ecore.xmi.XMLResource; + +import commonj.sdo.Property; +import commonj.sdo.Type; +import commonj.sdo.helper.HelperContext; +import commonj.sdo.helper.TypeHelper; +import commonj.sdo.helper.XSDHelper; + +/** + * SDO StAX Deserializer. The instance isn't thread-safe, however it's safe to use the instance any times on the same thread. + */ +public class SDODeserializer extends StreamDeserializer { + private HelperContext hc; + protected final void initialize(XMLStreamReader stream, HelperContext scope, Object rootObject) { + hc = scope; + reader = stream; + xsdHelper = scope.getXSDHelper(); + typeHelper = scope.getTypeHelper(); + extendedMetaData = ((TypeHelperImpl) typeHelper).getExtendedMetaData(); + deserializer = (XMLStreamHelperImpl)((HelperContextImpl)scope).getXMLStreamHelper();; + root = (EObject) rootObject; + } + + XSDHelper xsdHelper; + + protected Property propertyInSequence; + + Property getProperty(Object type) { + EClass c = (EClass) type; + EStructuralFeature containment = (EStructuralFeature) propertyInSequence; + Object containing = extendedMetaData.getAffiliation(c, containment); + // if (containing == null) report error? + if (containment == containing && containment.isDerived()) { + containing = extendedMetaData.getMixedFeature(c); + if (containing == null) { + containing = extendedMetaData.getGroup(containment); + if (containing == null) + return propertyInSequence; + } + } + return (Property) containing; + } + + protected final Property getProperty(Type type, String nameSpace, String name, boolean element) { + for (Iterator iterator = type.getProperties().iterator(); iterator.hasNext();) { + propertyInSequence = (Property) iterator.next(); + if (name.equals(xsdHelper.getLocalName(propertyInSequence)) + && nameSpace.equals(xsdHelper.getNamespaceURI(propertyInSequence))) + return getProperty(type); + } + propertyInSequence = xsdHelper.getGlobalProperty(nameSpace, name, element); + // if (propertyInSequence == null) report error? + return getProperty(type); + } + + protected final Property getProperty(Type type, String name) { + propertyInSequence = type.getProperty(name); + // if (propertyInSequence == null) report error? + return getProperty(type); + } + + protected final Property getProperty(String nameSpace, String name, Type type) { + return null == nameSpace ? getProperty(type, name) : getProperty(type, nameSpace, name, true); + } + + XMLStreamHelperImpl deserializer; + + TypeHelper typeHelper; + + protected Object load(XMLStreamReader reader, Map options) throws XMLStreamException { + return deserializer.loadObject(reader, options); + } + + static Object value(Type type, XMLStreamReader reader) throws XMLStreamException { + return value(type, reader.getElementText(), reader.getNamespaceContext()); + } + + protected final Object value(Type type) throws XMLStreamException { + return "true".equals(reader.getAttributeValue(ExtendedMetaData.XSI_URI, XMLResource.NIL)) ? null : type.isDataType() ? value(type, reader) + : load(reader, null); + } + + Map options/* = null */; + + protected final Object value(XMLStreamReader reader) throws XMLStreamException { + Type propertyType = propertyInSequence.getType(); + if (propertyType.isDataType()) + return value(propertyType, reader); + if (options == null) + options = new HashMap(); + options.put(XMLStreamHelper.OPTION_DEFAULT_ROOT_TYPE, propertyType); + return load(reader, options); + } + + private boolean match(String name, String space, EStructuralFeature feature) { + return name.equals(extendedMetaData.getName(feature)) && space.equals(extendedMetaData.getNamespace(feature)); + } + + EObject step(String ref, int step, int index, EObject container, String prefix, NamespaceContext nameSpaces) { + String name = ref.substring(step, index); + Iterator iterator = container.eContents().iterator(); + if (iterator.hasNext()) + if (prefix == null) + do { + container = (EObject) iterator.next(); + // if( container == null )continue; + if (name.equals(extendedMetaData.getName(container.eContainmentFeature()))) + return container; + } while (iterator.hasNext()); + else { + prefix = nameSpaces.getNamespaceURI(prefix); + do { + container = (EObject) iterator.next(); + // if( container == null )continue; + if (match(name, prefix, container.eContainmentFeature())) + return container; + } while (iterator.hasNext()); + } + return null; + } + + EObject root; + + ExtendedMetaData extendedMetaData; + + protected final EObject referent(String ref, NamespaceContext nameSpaces) { + int length = ref.length(); + switch (length) { + case 0: + return null; + case 1: // # + return root; + } + EObject container; + int step; + if (ref.charAt(1) == '/') { + container = EcoreUtil.getRootContainer(root); + if (length == 2) + return container; + if (ref.charAt(2) == '/') { + for (Iterator iterator = container.eContents().iterator();/* true */;) { + if (!iterator.hasNext()) + return null; + container = (EObject) iterator.next(); + // if( container != null ) + break; + } + /*#// is invalid + if (length == 3) + return container; */ + step = 3; + } else + step = 2; + } else { + container = root; + step = 1; + } + String prefix = null; + for (int index = step; ++index != length;) { + switch (ref.charAt(index)) { + case '/': + container = step(ref, step, index, container, prefix, nameSpaces); + if (container == null) + return null; + break; + case ':': + prefix = ref.substring(step, index); + if (++index == length) + return container; // report error? + step = index; + default: + continue; + case '[': + name = ref.substring(step, index); + step = ref.indexOf(']', index + 2); + if (step == -1) + return container; // report error? + index = Integer.parseInt(ref.substring(++index, step)); + EStructuralFeature feature; + Iterator iterator = container.eContents().iterator(); + if (prefix == null) + do { + if (!iterator.hasNext()) + return null; + EObject content = (EObject) iterator.next(); + // if( content == null )continue; + feature = content.eContainmentFeature(); + } while (!name.equals(extendedMetaData.getName(feature))); + else { + prefix = nameSpaces.getNamespaceURI(prefix); + do { + if (!iterator.hasNext()) + return null; + EObject content = (EObject) iterator.next(); + // if( content == null )continue; + feature = content.eContainmentFeature(); + } while (!match(name, prefix, feature)); + } + Object value = container.eGet(feature); + if (value instanceof List) { + List values = (List) value; + if (index > values.size()) + return null; + container = (EObject) values.get(--index); + } else if (index == 1) + container = (EObject) value; + else + return null; + index = ref.indexOf('/', ++step); + if (index == -1) + return container; + } + if (++index == length) + return container; + step = index; + prefix = null; + } + return step(ref, step, length, container, prefix, nameSpaces); + } + + static protected class Ref implements EObject // FeatureMapEntry value + { + protected Ref(String path, NamespaceContext context) { + ref = path; + nameSpaces = context; + } + + final String ref; + + final NamespaceContext nameSpaces; + + public TreeIterator eAllContents() { + return null; + } + public EClass eClass() { + return null; + } + public EObject eContainer() { + return null; + } + public EStructuralFeature eContainingFeature() { + return null; + } + public EReference eContainmentFeature() { + return null; + } + public EList eContents() { + return null; + } + public EList eCrossReferences() { + return null; + } + public Object eGet(EStructuralFeature feature) { + return null; + } + public Object eGet(EStructuralFeature feature, boolean resolve) { + return null; + } + public boolean eIsProxy() { + return false; + } + public boolean eIsSet(EStructuralFeature feature) { + return false; + } + public Resource eResource() { + return null; + } + public void eSet(EStructuralFeature feature, Object newValue) { + } + public void eUnset(EStructuralFeature feature) { + } + public EList eAdapters() { + return null; + } + public boolean eDeliver() { + return false; + } + public void eNotify(Notification notification) { + } + public void eSetDeliver(boolean deliver) { + } + } + + protected final EObject referent(Ref path) { + return referent(path.ref, path.nameSpaces); + } + + protected final Type typeXSI() { + return typedXSI() ? typeHelper.getType(nameSpace, name) : null; + } + + protected final Type globalElementType(String nameSpace, String name) { + return xsdHelper.getGlobalProperty(nameSpace, name, true).getType(); + } +} |