/**
* Copyright (c) 2002-2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM - Initial API and implementation
*/
package org.eclipse.emf.ecore.xmi.impl;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;
import javax.xml.namespace.QName;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.BasicEMap;
import org.eclipse.emf.common.util.EMap;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.common.util.UniqueEList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EDataType;
import org.eclipse.emf.ecore.EFactory;
import org.eclipse.emf.ecore.ENamedElement;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.InternalEObject;
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.util.FeatureMap;
import org.eclipse.emf.ecore.util.InternalEList;
import org.eclipse.emf.ecore.xmi.DanglingHREFException;
import org.eclipse.emf.ecore.xmi.IllegalValueException;
import org.eclipse.emf.ecore.xmi.NameInfo;
import org.eclipse.emf.ecore.xmi.XMIException;
import org.eclipse.emf.ecore.xmi.XMLHelper;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.eclipse.emf.ecore.xml.type.SimpleAnyType;
import org.eclipse.emf.ecore.xml.type.XMLTypePackage;
/**
* This class handles the package to use when there is no XML
* namespace in an XML file.
*/
public class XMLHelperImpl implements XMLHelper
{
protected static final Integer INTEGER_DATATYPE_IS_MANY = DATATYPE_IS_MANY;
protected static final Integer INTEGER_DATATYPE_SINGLE = DATATYPE_SINGLE;
protected static final Integer INTEGER_IS_MANY_ADD = IS_MANY_ADD;
protected static final Integer INTEGER_IS_MANY_MOVE = IS_MANY_MOVE;
protected static final Integer INTEGER_OTHER = OTHER;
protected EPackage noNamespacePackage;
protected XMLResource.XMLMap xmlMap;
protected ExtendedMetaData extendedMetaData;
protected boolean laxFeatureProcessing;
protected EPackage.Registry packageRegistry;
protected XMLResource resource;
protected URI resourceURI;
protected boolean deresolve;
protected Map<EPackage, String> packages;
protected Map<EStructuralFeature, Integer> featuresToKinds;
protected String processDanglingHREF;
protected DanglingHREFException danglingHREFException;
protected EMap<String, String> prefixesToURIs;
protected Map<String, List<String>> urisToPrefixes;
protected Map<String, String> anyPrefixesToURIs;
protected NamespaceSupport namespaceSupport;
protected EClass anySimpleType;
// true if seen xmlns="" declaration
protected boolean seenEmptyStringMapping;
protected EPackage xmlSchemaTypePackage = XMLTypePackage.eINSTANCE;
protected List<String> allPrefixToURI;
protected boolean checkForDuplicates;
protected boolean mustHavePrefix;
protected XMLResource.URIHandler uriHandler;
protected List<? extends EObject> roots;
protected String [] fragmentPrefixes;
private EPackage previousPackage;
private String previousNS;
public static String saveString(Map<?, ?> options, List<? extends EObject> contents, String encoding, XMLHelper helper) throws Exception
{
if (helper == null)
{
helper = new XMIHelperImpl();
}
if (!options.containsKey(XMLResource.OPTION_DECLARE_XML))
{
Map<Object, Object> modifiedOptions = new HashMap<Object, Object>(options);
modifiedOptions.put(XMLResource.OPTION_DECLARE_XML, Boolean.FALSE);
options = modifiedOptions;
}
XMLSaveImpl save = new XMISaveImpl(options, helper, encoding);
if (Boolean.TRUE.equals(options.get(XMLResource.OPTION_DEFER_IDREF_RESOLUTION)))
{
((XMLHelperImpl)helper).checkForDuplicates = true;
}
((XMLHelperImpl)helper).processDanglingHREF = (String)options.get(XMLResource.OPTION_PROCESS_DANGLING_HREF);
save.traverse(contents);
if (save.useCache)
{
if (save.doc != null)
{
ConfigurationCache.INSTANCE.releasePrinter(save.doc);
}
if (save.escape != null)
{
ConfigurationCache.INSTANCE.releaseEscape(save.escape);
}
}
char[] chars = save.toChar();
return new String(chars);
}
public XMLHelperImpl()
{
super();
packages = new HashMap<EPackage, String>();
featuresToKinds = new HashMap<EStructuralFeature, Integer>();
prefixesToURIs =
new BasicEMap<String, String>()
{
private static final long serialVersionUID = 1L;
protected List<String> getPrefixes(String uri)
{
List<String> result = urisToPrefixes.get(uri);
if (result == null)
{
urisToPrefixes.put(uri, result = new ArrayList<String>());
}
return result;
}
@Override
protected void didAdd(Entry<String, String> entry)
{
getPrefixes(entry.getValue()).add(entry.getKey());
}
@Override
protected void didClear(BasicEList<Entry<String, String>>[] oldEntryData)
{
urisToPrefixes.clear();
}
@Override
protected void didModify(Entry<String, String> entry, String oldValue)
{
String key = entry.getKey();
getPrefixes(oldValue).remove(key);
getPrefixes(entry.getValue()).add(key);
}
@Override
protected void didRemove(Entry<String, String> entry)
{
getPrefixes(entry.getValue()).add(entry.getKey());
}
};
urisToPrefixes = new HashMap<String, List<String>>();
anyPrefixesToURIs = new HashMap<String, String>();
allPrefixToURI = new ArrayList<String>();
namespaceSupport = new NamespaceSupport();
}
public XMLHelperImpl(XMLResource resource)
{
this();
setResource(resource);
}
public void setOptions(Map<?, ?> options)
{
laxFeatureProcessing = Boolean.TRUE.equals(options.get(XMLResource.OPTION_LAX_FEATURE_PROCESSING));
uriHandler = (XMLResource.URIHandler)options.get(XMLResource.OPTION_URI_HANDLER);
if (uriHandler != null)
{
uriHandler.setBaseURI(resourceURI);
}
@SuppressWarnings("unchecked")
List<? extends EObject> roots = (List<? extends EObject>)options.get(XMLResource.OPTION_ROOT_OBJECTS);
if (roots != null)
{
this.roots = roots;
fragmentPrefixes = new String[roots.size()];
int count = 0;
for (EObject root : roots)
{
InternalEObject internalEObject = (InternalEObject)root;
List<String> uriFragmentPath = new ArrayList<String>();
for (InternalEObject container = internalEObject.eInternalContainer(); container != null; container = internalEObject.eInternalContainer())
{
uriFragmentPath.add(container.eURIFragmentSegment(internalEObject.eContainingFeature(), internalEObject));
internalEObject = container;
Resource resource = container.eDirectResource();
if (resource != null)
{
int index = resource.getContents().indexOf(container);
uriFragmentPath.add(index != 0 ? Integer.toString(index) : "");
break;
}
}
StringBuilder result = new StringBuilder("/");
for (int i = uriFragmentPath.size() - 1; i >= 1; --i)
{
result.append(uriFragmentPath.get(i));
result.append('/');
}
fragmentPrefixes[count++] = result.toString();
}
}
}
public void setNoNamespacePackage(EPackage pkg)
{
noNamespacePackage = pkg;
}
public EPackage getNoNamespacePackage()
{
return
noNamespacePackage != null ?
noNamespacePackage :
extendedMetaData != null ?
extendedMetaData.getPackage(null) :
null;
}
public void setXMLMap(XMLResource.XMLMap map)
{
xmlMap = map;
if (map != null && map.getNoNamespacePackage() != null)
{
setNoNamespacePackage(map.getNoNamespacePackage());
}
}
public XMLResource.XMLMap getXMLMap()
{
return xmlMap;
}
public void setExtendedMetaData(ExtendedMetaData extendedMetaData)
{
this.extendedMetaData = extendedMetaData;
if (extendedMetaData != null && extendedMetaData.getPackage(null) != null)
{
setNoNamespacePackage(extendedMetaData.getPackage(null));
}
}
public ExtendedMetaData getExtendedMetaData()
{
return extendedMetaData;
}
public XMLResource getResource()
{
return resource;
}
public void setResource(XMLResource resource)
{
this.resource = resource;
if (resource == null)
{
resourceURI = null;
deresolve = false;
packageRegistry = EPackage.Registry.INSTANCE;
}
else
{
resourceURI = resource.getURI();
deresolve = resourceURI != null && !resourceURI.isRelative() && resourceURI.isHierarchical();
packageRegistry = resource.getResourceSet() == null ? EPackage.Registry.INSTANCE : resource.getResourceSet().getPackageRegistry();
}
}
public Object getValue(EObject obj, EStructuralFeature f)
{
return obj.eGet(f, false);
}
public String getQName(EClass c)
{
String name = getName(c);
if (xmlMap != null)
{
XMLResource.XMLInfo clsInfo = xmlMap.getInfo(c);
if (clsInfo != null)
{
String targetNamespace = clsInfo.getTargetNamespace();
return getQName(targetNamespace, name);
}
}
return getQName(c.getEPackage(), name);
}
public void populateNameInfo(NameInfo nameInfo, EClass c)
{
String name = getName(c);
nameInfo.setLocalPart(name);
if (xmlMap != null)
{
XMLResource.XMLInfo clsInfo = xmlMap.getInfo(c);
if (clsInfo != null)
{
String targetNamespace = clsInfo.getTargetNamespace();
nameInfo.setNamespaceURI(targetNamespace);
nameInfo.setQualifiedName(getQName(targetNamespace, name));
return;
}
}
getQName(nameInfo, c.getEPackage(), name);
}
public String getQName(EDataType c)
{
String name = getName(c);
if (xmlMap != null)
{
XMLResource.XMLInfo clsInfo = xmlMap.getInfo(c);
if (clsInfo != null)
{
String targetNamespace = clsInfo.getTargetNamespace();
return getQName(targetNamespace, name);
}
}
return getQName(c.getEPackage(), name);
}
public void populateNameInfo(NameInfo nameInfo, EDataType eDataType)
{
String name = getName(eDataType);
nameInfo.setLocalPart(name);
if (xmlMap != null)
{
XMLResource.XMLInfo clsInfo = xmlMap.getInfo(eDataType);
if (clsInfo != null)
{
String targetNamespace = clsInfo.getTargetNamespace();
nameInfo.setNamespaceURI(targetNamespace);
nameInfo.setQualifiedName(getQName(targetNamespace, name));
return;
}
}
getQName(nameInfo, eDataType.getEPackage(), name);
}
public String getQName(EStructuralFeature feature)
{
if (extendedMetaData != null)
{
String namespace = extendedMetaData.getNamespace(feature);
String name = extendedMetaData.getName(feature);
String result = name;
// We need to be careful that we don't end up requiring the no namespace package
// just because the feature is unqualified.
//
if (namespace != null)
{
// There really must be a package.
//
EPackage ePackage;
if (namespace.equals(previousNS))
{
ePackage = previousPackage;
}
else
{
ePackage = extendedMetaData.getPackage(namespace);
if (ePackage == null)
{
ePackage = extendedMetaData.demandPackage(namespace);
}
previousPackage = ePackage;
previousNS = namespace;
}
result = getQName(ePackage, name);
// We must have a qualifier for an attribute that needs qualified.
//
if (result.length() == name.length() && extendedMetaData.getFeatureKind(feature) == ExtendedMetaData.ATTRIBUTE_FEATURE)
{
result = getQName(ePackage, name, true);
}
}
return result;
}
String name = getName(feature);
if (xmlMap != null)
{
XMLResource.XMLInfo info = xmlMap.getInfo(feature);
if (info != null)
{
return getQName(info.getTargetNamespace(), name);
}
}
return name;
}
public void populateNameInfo(NameInfo nameInfo, EStructuralFeature feature)
{
if (extendedMetaData != null)
{
String namespace = extendedMetaData.getNamespace(feature);
String name = extendedMetaData.getName(feature);
nameInfo.setNamespaceURI(namespace);
nameInfo.setLocalPart(name);
nameInfo.setQualifiedName(name);
// We need to be careful that we don't end up requiring the no namespace package
// just because the feature is unqualified.
//
if (namespace != null)
{
// There really must be a package.
//
EPackage ePackage = extendedMetaData.getPackage(namespace);
if (ePackage == null)
{
ePackage = extendedMetaData.demandPackage(namespace);
}
String result = getQName(nameInfo, ePackage, name);
// We must have a qualifier for an attribute that needs qualified.
//
if (result.length() == name.length() && extendedMetaData.getFeatureKind(feature) == ExtendedMetaData.ATTRIBUTE_FEATURE)
{
getQName(nameInfo, ePackage, name, true);
}
}
}
else
{
String name = getName(feature);
nameInfo.setNamespaceURI(null);
nameInfo.setLocalPart(name);
if (xmlMap != null)
{
XMLResource.XMLInfo info = xmlMap.getInfo(feature);
if (info != null)
{
String targetNamespace = info.getTargetNamespace();
nameInfo.setNamespaceURI(targetNamespace);
nameInfo.setQualifiedName(getQName(targetNamespace, name));
}
}
nameInfo.setQualifiedName(name);
}
}
protected String getQName(NameInfo nameInfo, EPackage ePackage, String name)
{
String qname = getQName(nameInfo, ePackage, name, mustHavePrefix);
nameInfo.setQualifiedName(qname);
return qname;
}
protected String getQName(NameInfo nameInfo, EPackage ePackage, String name, boolean mustHavePrefix)
{
String nsPrefix = getPrefix(ePackage, mustHavePrefix);
nameInfo.setNamespaceURI(getNamespaceURI(nsPrefix));
if ("".equals(nsPrefix))
{
return name;
}
else if (name.length() == 0)
{
return nsPrefix;
}
else
{
return nsPrefix + ":" + name;
}
}
protected String getQName(EPackage ePackage, String name)
{
return getQName(ePackage, name, mustHavePrefix);
}
protected String getQName(EPackage ePackage, String name, boolean mustHavePrefix)
{
String nsPrefix = getPrefix(ePackage, mustHavePrefix);
if ("".equals(nsPrefix))
{
return name;
}
else if (name.length() == 0)
{
return nsPrefix;
}
else
{
return nsPrefix + ":" + name;
}
}
public String getPrefix(EPackage ePackage)
{
return getPrefix(ePackage, mustHavePrefix);
}
public String getNamespaceURI(String prefix)
{
String namespaceURI = namespaceSupport.getURI(prefix);
if (namespaceURI == null)
{
namespaceURI = prefixesToURIs.get(prefix);
}
return namespaceURI;
}
protected String getPrefix(EPackage ePackage, boolean mustHavePrefix)
{
String nsPrefix = packages.get(ePackage);
if (nsPrefix == null || mustHavePrefix && nsPrefix.length() == 0)
{
String nsURI =
xmlSchemaTypePackage == ePackage ?
XMLResource.XML_SCHEMA_URI :
extendedMetaData == null ?
ePackage.getNsURI() :
extendedMetaData.getNamespace(ePackage);
boolean found = false;
List<String> prefixes = urisToPrefixes.get(nsURI);
if (prefixes != null)
{
for (String prefix : prefixes)
{
nsPrefix = prefix;
if (!mustHavePrefix || nsPrefix.length() > 0)
{
found = true;
break;
}
}
}
if (!found)
{
// for any content prefix to URI mapping could be in namespace context
nsPrefix = namespaceSupport.getPrefix(nsURI);
if (nsPrefix != null)
{
return nsPrefix;
}
if (nsURI != null)
{
nsPrefix = xmlSchemaTypePackage == ePackage ? "xsd" : ePackage.getNsPrefix();
}
if (nsPrefix == null)
{
nsPrefix = mustHavePrefix ? "_" : "";
}
if (prefixesToURIs.containsKey(nsPrefix))
{
String currentValue = prefixesToURIs.get(nsPrefix);
if (currentValue == null ? nsURI != null : !currentValue.equals(nsURI))
{
int index = 1;
while (prefixesToURIs.containsKey(nsPrefix + "_" + index))
{
++index;
}
nsPrefix += "_" + index;
}
}
prefixesToURIs.put(nsPrefix, nsURI);
}
if (!packages.containsKey(ePackage))
{
packages.put(ePackage, nsPrefix);
}
}
return nsPrefix;
}
public List<String> getPrefixes(EPackage ePackage)
{
List<String> result = new UniqueEList<String>();
result.add(getPrefix(ePackage));
String namespace = extendedMetaData == null ? ePackage.getNsURI() : extendedMetaData.getNamespace(ePackage);
List<String> prefixes = urisToPrefixes.get(namespace);
if (prefixes != null)
{
result.addAll(prefixes);
}
return result;
}
protected String getQName(String uri, String name)
{
if (uri == null)
{
EPackage theNoNamespacePackage = getNoNamespacePackage();
if (theNoNamespacePackage != null)
{
packages.put(theNoNamespacePackage, "");
}
return name;
}
EPackage ePackage =
extendedMetaData == null ?
EPackage.Registry.INSTANCE.getEPackage(uri) :
extendedMetaData.getPackage(uri);
if (ePackage == null)
{
if (extendedMetaData != null)
{
return getQName(extendedMetaData.demandPackage(uri), name);
}
else
{
// EATM this would be wrong.
return name;
}
}
else
{
return getQName(ePackage, name);
}
}
public String getName(ENamedElement obj)
{
if (extendedMetaData != null)
{
return
obj instanceof EStructuralFeature ?
extendedMetaData.getName((EStructuralFeature)obj) :
extendedMetaData.getName((EClassifier)obj);
}
if (xmlMap != null)
{
XMLResource.XMLInfo info = xmlMap.getInfo(obj);
if (info != null)
{
String result = info.getName();
if (result != null)
{
return result;
}
}
}
return obj.getName();
}
public String getID(EObject obj)
{
return resource == null ? null : resource.getID(obj);
}
protected String getURIFragmentQuery(Resource containingResource, EObject object)
{
return null;
}
protected String getURIFragment(Resource containingResource, EObject object)
{
if (roots != null && containingResource == resource && !EcoreUtil.isAncestor(roots, object))
{
URI uriResult = handleDanglingHREF(object);
return uriResult == null || !uriResult.hasFragment() ? null : uriResult.fragment();
}
else
{
String result = containingResource.getURIFragment(object);
if (result.length() > 0 && result.charAt(0) != '/')
{
String query = getURIFragmentQuery(containingResource, object);
if (query != null)
{
result += "?" + query + "?";
}
}
else if ("/-1".equals(result))
{
if (object.eResource() != containingResource)
{
URI uriResult = handleDanglingHREF(object);
return uriResult == null || !uriResult.hasFragment() ? null : uriResult.fragment();
}
}
else if (fragmentPrefixes != null)
{
for (int i = 0; i < fragmentPrefixes.length; ++i)
{
String fragmentPrefix = fragmentPrefixes[i];
if (result.startsWith(fragmentPrefix))
{
result = "/" + (i == 0 ? "" : Integer.toString(i)) + result.substring(fragmentPrefix.length() - 1);
break;
}
}
}
return result;
}
}
public String getIDREF(EObject obj)
{
return resource == null ? null : getURIFragment(resource, obj);
}
protected URI handleDanglingHREF(EObject object)
{
if (!XMLResource.OPTION_PROCESS_DANGLING_HREF_DISCARD.equals(processDanglingHREF))
{
DanglingHREFException exception = new DanglingHREFException(
"The object '" + object + "' is not contained in a resource.",
resource == null || resource.getURI() == null ? "unknown" : resource.getURI().toString(), 0, 0);
if (danglingHREFException == null)
{
danglingHREFException = exception;
}
if (resource != null)
{
resource.getErrors().add(exception);
}
}
return null;
}
public String getHREF(EObject obj)
{
InternalEObject o = (InternalEObject) obj;
URI objectURI = o.eProxyURI();
if (objectURI == null)
{
Resource otherResource = obj.eResource();
if (otherResource == null)
{
if (resource != null && resource.getID(obj) != null)
{
objectURI = getHREF(resource, obj);
}
else
{
objectURI = handleDanglingHREF(obj);
if (objectURI == null)
{
return null;
}
}
}
else
{
objectURI = getHREF(otherResource, obj);
}
}
objectURI = deresolve(objectURI);
return objectURI.toString();
}
protected URI getHREF(Resource otherResource, EObject obj)
{
return otherResource.getURI().appendFragment(getURIFragment(otherResource, obj));
}
public URI deresolve(URI uri)
{
if (uriHandler != null)
{
uri = uriHandler.deresolve(uri);
}
else if (deresolve && !uri.isRelative())
{
URI deresolvedURI = uri.deresolve(resourceURI, true, true, false);
if (deresolvedURI.hasRelativePath())
{
uri = deresolvedURI;
}
}
return uri;
}
public int getFeatureKind(EStructuralFeature feature)
{
Integer kind = featuresToKinds.get(feature);
if (kind != null)
{
return kind;
}
else
{
computeFeatureKind(feature);
kind = featuresToKinds.get(feature);
if (kind != null)
{
return kind;
}
else
{
featuresToKinds.put(feature, INTEGER_OTHER);
return OTHER;
}
}
}
public EObject createObject(EFactory eFactory, EClassifier type)
{
EObject newObject = null;
if (eFactory != null)
{
if (extendedMetaData != null)
{
if (type == null)
{
return null;
}
else if (type instanceof EClass)
{
EClass eClass = (EClass)type;
if (!eClass.isAbstract())
{
newObject = eFactory.create(eClass);
}
}
else
{
SimpleAnyType result = (SimpleAnyType)EcoreUtil.create(anySimpleType);
result.setInstanceType((EDataType)type);
newObject = result;
}
}
else
{
if (type != null)
{
EClass eClass = (EClass)type;
if (!eClass.isAbstract())
{
newObject = eFactory.create(eClass);
}
}
}
}
return newObject;
}
public EClassifier getType(EFactory eFactory, String typeName)
{
if (eFactory != null)
{
EPackage ePackage = eFactory.getEPackage();
if (extendedMetaData != null)
{
return extendedMetaData.getType(ePackage, typeName);
}
else
{
EClassifier eClassifier = ePackage.getEClassifier(typeName);
if (eClassifier == null && xmlMap != null)
{
return xmlMap.getClassifier(ePackage.getNsURI(), typeName);
}
return eClassifier;
}
}
return null;
}
/**
* @deprecated since 2.2
*/
@Deprecated
public EObject createObject(EFactory eFactory, String classXMIName)
{
return createObject(eFactory, getType(eFactory, classXMIName));
}
public EStructuralFeature getFeature(EClass eClass, String namespaceURI, String name)
{
EStructuralFeature feature = getFeatureWithoutMap(eClass, name);
if (feature == null)
{
if (xmlMap != null)
{
feature = xmlMap.getFeature(eClass, namespaceURI, name);
if (feature != null)
{
computeFeatureKind(feature);
}
}
else if (laxFeatureProcessing && extendedMetaData != null)
{
List<EStructuralFeature> structuralFeatures = eClass.getEAllStructuralFeatures();
for (int i = 0, size = structuralFeatures.size(); i < size; ++i)
{
EStructuralFeature eStructuralFeature = structuralFeatures.get(i);
if (name.equals(extendedMetaData.getName(eStructuralFeature))
&& (namespaceURI == null ? extendedMetaData.getNamespace(eStructuralFeature) == null : namespaceURI.equals(extendedMetaData.getNamespace(eStructuralFeature))))
{
return eStructuralFeature;
}
}
}
}
return feature;
}
public EStructuralFeature getFeature(EClass eClass, String namespaceURI, String name, boolean isElement)
{
if (extendedMetaData != null)
{
// Once we see a lookup of an element in the null namespace, we should behave as if there has been an explicit xmlns=""
//
if (isElement && namespaceURI == null)
{
seenEmptyStringMapping = true;
}
EStructuralFeature eStructuralFeature =
isElement ?
extendedMetaData.getElement(eClass, namespaceURI, name) :
extendedMetaData.getAttribute(eClass, namespaceURI == "" ? null : namespaceURI, name);
if (eStructuralFeature != null)
{
computeFeatureKind(eStructuralFeature);
}
else
{
eStructuralFeature = getFeature(eClass, namespaceURI, name);
// Only if the feature kind is unspecified should we return a match.
// Otherwise, we might return an attribute feature when an element is required,
// or vice versa. This also can be controlled by XMLResource.OPTION_LAX_FEATURE_PROCESSING.
//
if (!laxFeatureProcessing && eStructuralFeature != null &&
extendedMetaData.getFeatureKind(eStructuralFeature) != ExtendedMetaData.UNSPECIFIED_FEATURE)
{
eStructuralFeature = null;
}
}
return eStructuralFeature;
}
return getFeature(eClass, namespaceURI, name);
}
protected EStructuralFeature getFeatureWithoutMap(EClass eClass, String name)
{
EStructuralFeature feature = eClass.getEStructuralFeature(name);
if (feature != null)
computeFeatureKind(feature);
return feature;
}
protected void computeFeatureKind(EStructuralFeature feature)
{
EClassifier eClassifier = feature.getEType();
if (eClassifier instanceof EDataType)
{
if (feature.isMany())
{
featuresToKinds.put(feature, INTEGER_DATATYPE_IS_MANY);
}
else
{
featuresToKinds.put(feature, INTEGER_DATATYPE_SINGLE);
}
}
else
{
if (feature.isMany())
{
EReference reference = (EReference) feature;
EReference opposite = reference.getEOpposite();
if (opposite == null || opposite.isTransient() || !opposite.isMany())
featuresToKinds.put(feature, INTEGER_IS_MANY_ADD);
else
featuresToKinds.put(feature, INTEGER_IS_MANY_MOVE);
}
}
}
public String getJavaEncoding(String xmlEncoding)
{
return xmlEncoding;
}
public String getXMLEncoding(String javaEncoding)
{
return javaEncoding;
}
public EPackage[] packages()
{
Map<String, EPackage> map = new TreeMap<String, EPackage>();
// Sort and eliminate duplicates caused by having both a regular package and a demanded package for the same nsURI.
//
for (EPackage ePackage : packages.keySet())
{
String prefix= getPrefix(ePackage);
if (prefix == null)
{
prefix = "";
}
EPackage conflict = map.put(prefix, ePackage);
if (conflict != null && conflict.eResource() != null)
{
map.put(prefix, conflict);
}
}
EPackage[] result = new EPackage[map.size()];
map.values().toArray(result);
return result;
}
public void setValue(EObject object, EStructuralFeature feature, Object value, int position)
{
if (extendedMetaData != null)
{
EStructuralFeature targetFeature = extendedMetaData.getAffiliation(object.eClass(), feature);
if (targetFeature != null && targetFeature != feature)
{
EStructuralFeature group = extendedMetaData.getGroup(targetFeature);
if (group != null)
{
targetFeature = group;
}
if (targetFeature.getEType() == EcorePackage.Literals.EFEATURE_MAP_ENTRY)
{
FeatureMap featureMap = (FeatureMap)object.eGet(targetFeature);
EClassifier eClassifier = feature.getEType();
if (eClassifier instanceof EDataType)
{
EDataType eDataType = (EDataType) eClassifier;
EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();
value = createFromString(eFactory, eDataType, (String)value);
}
featureMap.add(feature, value);
return;
}
else
{
// If we are substituting an EAttribute for an EReference...
//
EClassifier eType = feature.getEType();
if (eType instanceof EDataType && targetFeature instanceof EReference)
{
// Create an simple any type wrapper for the attribute value and use that with the EReference.
//
SimpleAnyType simpleAnyType = (SimpleAnyType)EcoreUtil.create(anySimpleType);
simpleAnyType.setInstanceType((EDataType)eType);
simpleAnyType.setRawValue((String)value);
value = simpleAnyType;
}
feature = targetFeature;
}
}
}
int kind = getFeatureKind(feature);
switch (kind)
{
case DATATYPE_SINGLE:
case DATATYPE_IS_MANY:
{
EClassifier eClassifier = feature.getEType();
EDataType eDataType = (EDataType) eClassifier;
EFactory eFactory = eDataType.getEPackage().getEFactoryInstance();
if (kind == DATATYPE_IS_MANY)
{
@SuppressWarnings("unchecked") InternalEList<Object> list = (InternalEList<Object>)object.eGet(feature);
if (position == -2)
{
for (StringTokenizer stringTokenizer = new StringTokenizer((String)value, " "); stringTokenizer.hasMoreTokens(); )
{
String token = stringTokenizer.nextToken();
list.addUnique(createFromString(eFactory, eDataType, token));
}
// Make sure that the list will appear to be set to be empty.
//
if (list.isEmpty())
{
list.clear();
}
}
else if (value == null)
{
list.addUnique(null);
}
else
{
list.addUnique(createFromString(eFactory, eDataType, (String)value));
}
}
else if (value == null)
{
object.eSet(feature, null);
}
else
{
object.eSet(feature, createFromString(eFactory, eDataType, (String) value));
}
break;
}
case IS_MANY_ADD:
case IS_MANY_MOVE:
{
@SuppressWarnings("unchecked") InternalEList<Object> list = (InternalEList<Object>)object.eGet(feature);
if (position == -1)
{
if (object == value)
{
list.add(value);
}
else
{
list.addUnique(value);
}
}
else if (position == -2)
{
list.clear();
}
else if (checkForDuplicates || object == value)
{
int index = list.basicIndexOf(value);
if (index == -1)
{
list.addUnique(position, value);
}
else
{
list.move(position, index);
}
}
else if (kind == IS_MANY_ADD)
{
list.addUnique(position, value);
}
else
{
list.move(position, value);
}
break;
}
default:
{
object.eSet(feature, value);
break;
}
}
}
public List<XMIException> setManyReference(ManyReference reference, String location)
{
EStructuralFeature feature = reference.getFeature();
int kind = getFeatureKind(feature);
EObject object = reference.getObject();
@SuppressWarnings("unchecked") InternalEList<Object> list = (InternalEList<Object>)object.eGet(feature);
List<XMIException> xmiExceptions = new BasicEList<XMIException>();
Object[] values = reference.getValues();
int[] positions = reference.getPositions();
if (kind == IS_MANY_ADD)
{
for (int i = 0, l = values.length; i < l; i++)
{
Object value = values[i];
if (value != null)
{
int position = positions[i];
try
{
if (checkForDuplicates || object == value)
{
int index = list.basicIndexOf(value);
if (index == -1)
{
list.addUnique(position, value);
}
else
{
list.move(position, index);
}
}
else
{
list.addUnique(position, value);
}
}
catch (RuntimeException e)
{
xmiExceptions.add(new IllegalValueException
(object,
feature,
value,
e,
location,
reference.getLineNumber(),
reference.getColumnNumber()
));
}
}
}
}
else
{
for (int i = 0, l = values.length; i < l; i++)
{
Object value = values[i];
if (value != null)
{
try
{
int sourcePosition = list.basicIndexOf(value);
if (sourcePosition != -1)
{
list.move(positions[i], sourcePosition);
}
else
{
list.addUnique(positions[i], value);
}
}
catch (RuntimeException e)
{
xmiExceptions.add(new IllegalValueException
(object,
feature,
value,
e,
location,
reference.getLineNumber(),
reference.getColumnNumber()
));
}
}
}
}
if (xmiExceptions.isEmpty())
{
return null;
}
else
{
return xmiExceptions;
}
}
public void setCheckForDuplicates(boolean checkForDuplicates)
{
this.checkForDuplicates = checkForDuplicates;
}
public void setProcessDanglingHREF(String value)
{
processDanglingHREF = value;
}
public DanglingHREFException getDanglingHREFException()
{
return danglingHREFException;
}
public URI resolve(URI relative, URI base)
{
return uriHandler == null ? relative.resolve(base) : uriHandler.resolve(relative);
}
public void pushContext()
{
namespaceSupport.pushContext();
}
public void popContext()
{
namespaceSupport.popContext();
}
public void popContext(Map<String, EFactory> prefixesToFactories)
{
namespaceSupport.popContext(prefixesToFactories);
}
public void addPrefix(String prefix, String uri)
{
if (!"xml".equals(prefix) && !"xmlns".equals(prefix))
{
uri = (uri.length() == 0) ? null : uri;
namespaceSupport.declarePrefix(prefix, uri);
allPrefixToURI.add(prefix);
allPrefixToURI.add(uri);
}
}
public String getPrefix (String namespaceURI)
{
return namespaceSupport.getPrefix(namespaceURI);
}
public Map<String, String> getAnyContentPrefixToURIMapping()
{
anyPrefixesToURIs.clear();
int count = namespaceSupport.getDeclaredPrefixCount();
int size = allPrefixToURI.size();
while (count-->0)
{
String uri = allPrefixToURI.remove(--size);
String prefix = allPrefixToURI.remove(--size);
anyPrefixesToURIs.put(prefix, uri);
}
return anyPrefixesToURIs;
}
public String getURI(String prefix)
{
return
"xml".equals(prefix) ?
"http://www.w3.org/XML/1998/namespace" :
"xmlns".equals(prefix) ?
ExtendedMetaData.XMLNS_URI :
namespaceSupport.getURI(prefix);
}
public EMap<String, String> getPrefixToNamespaceMap()
{
return prefixesToURIs;
}
public void recordPrefixToURIMapping()
{
for (int i = 0, size = allPrefixToURI.size(); i < size;)
{
String prefix = allPrefixToURI.get(i++);
String uri = allPrefixToURI.get(i++);
String originalURI = prefixesToURIs.get(prefix);
if (uri == null)
{
// xmlns="" declaration
// Example #1: <a><q-name>q</q-name><b xmlns="abc"/></a>
// Example #2: <a xmlns="abc"><b xmlns=""/><c xmlns="abc2"/></a>
// Example #3: <a xmlns:a="abc"><b xmlns:a="abc2"/></a>
seenEmptyStringMapping = true;
if (originalURI != null)
{
// since xmlns="" is default declaration, remove ""->empty_URI mapping
prefixesToURIs.removeKey(prefix);
addNSDeclaration(prefix, originalURI);
}
continue;
}
else if ((seenEmptyStringMapping && prefix.length() == 0))
{
// record default ns declaration as duplicate if seen QName (#1) or seen xmlns="" (#2)
addNSDeclaration(prefix, uri);
}
else if (originalURI != null)
{
if (!uri.equals(originalURI))
{
// record duplicate declaration for a given prefix (#3)
addNSDeclaration(prefix, uri);
}
}
else
{
// recording a first declaration for a given prefix
prefixesToURIs.put(prefix, uri);
}
}
}
public void setPrefixToNamespaceMap(EMap<String, String> prefixToNamespaceMap)
{
for (Map.Entry<String, String> entry : prefixToNamespaceMap)
{
String prefix = entry.getKey();
String namespace = entry.getValue();
EPackage ePackage = null;
if (extendedMetaData == null)
{
ePackage = packageRegistry.getEPackage(namespace);
}
else
{
ePackage = extendedMetaData.getPackage(namespace);
if (ePackage == null)
{
if (XMLResource.XML_SCHEMA_URI.equals(namespace))
{
ePackage = xmlSchemaTypePackage;
}
else
{
ePackage = extendedMetaData.demandPackage(namespace);
}
}
}
if (ePackage != null && !packages.containsKey(ePackage))
{
packages.put(ePackage, prefix);
}
prefixesToURIs.put(prefix, namespace);
}
}
/**
* A helper to encode namespace prefix mappings.
*/
protected static class NamespaceSupport
{
protected String[] namespace = new String [16 * 2];
protected int namespaceSize = 0;
protected int[] context = new int [8];
protected int currentContext = -1;
protected String[] prefixes = new String [16];
public void pushContext()
{
// extend the array, if necessary
if (currentContext + 1 == context.length)
{
int[] contextarray = new int [context.length * 2];
System.arraycopy(context, 0, contextarray, 0, context.length);
context = contextarray;
}
// push context
context[++currentContext] = namespaceSize;
}
public void popContext()
{
namespaceSize = context[currentContext--];
}
public void popContext(Map<String, EFactory> prefixesToFactories)
{
int oldNamespaceSize = namespaceSize;
for (int i = namespaceSize = context[currentContext--]; i < oldNamespaceSize; i += 2)
{
prefixesToFactories.remove(namespace[i]);
}
}
/**
* @param prefix prefix to declare
* @param uri uri that maps to the prefix
* @return true if the prefix existed in the current context and
* its uri has been remapped; false if prefix does not exist in the
* current context
*/
public boolean declarePrefix(String prefix, String uri)
{
// see if prefix already exists in current context
for (int i = namespaceSize; i > context[currentContext]; i -= 2)
{
if (namespace[i - 2].equals(prefix))
{
namespace[i - 1] = uri;
return true;
}
}
// resize array, if needed
if (namespaceSize == namespace.length)
{
String[] namespacearray = new String [namespaceSize * 2];
System.arraycopy(namespace, 0, namespacearray, 0, namespaceSize);
namespace = namespacearray;
}
// bind prefix to uri in current context
namespace[namespaceSize++] = prefix;
namespace[namespaceSize++] = uri;
return false;
}
public String getURI(String prefix)
{
// find prefix in current context
for (int i = namespaceSize; i > 0; i -= 2)
{
if (namespace[i - 2].equals(prefix))
{
return namespace[i - 1];
}
}
// prefix not found
return null;
}
public String getPrefix(String uri)
{
// find uri in current context
for (int i = namespaceSize; i > 0; i -= 2)
{
String knownURI = namespace[i - 1];
if ((knownURI != null)? knownURI.equals(uri) : uri == knownURI)
{
knownURI = getURI(namespace[i - 2]);
if ((knownURI != null)? knownURI.equals(uri) : uri == knownURI)
return namespace[i - 2];
}
}
// uri not found
return null;
}
public int getDeclaredPrefixCount()
{
return (namespaceSize - context[currentContext]) / 2;
}
public String getDeclaredPrefixAt(int index)
{
return namespace[context[currentContext] + index * 2];
} // getDeclaredPrefixAt(int):String
}// namespace context
public void setAnySimpleType(EClass type)
{
anySimpleType = type;
}
public String convertToString(EFactory factory, EDataType dataType, Object value)
{
if (extendedMetaData != null)
{
if (value instanceof List<?>)
{
List<?> list = (List<?>)value;
for (Object item : list)
{
updateQNamePrefix(factory, dataType, item, true);
}
return factory.convertToString(dataType, value);
}
else
{
return updateQNamePrefix(factory, dataType, value, false);
}
}
return factory.convertToString(dataType, value);
}
protected Object createFromString(EFactory eFactory, EDataType eDataType, String value)
{
Object obj = eFactory.createFromString(eDataType, value);
if (extendedMetaData != null)
{
if (obj instanceof List<?>)
{
@SuppressWarnings("unchecked")
List<Object> list = (List<Object>)obj;
for (int i = 0; i < list.size(); i++)
{
Object item = list.get(i);
Object replacement = updateQNameURI(item);
if (replacement != item)
{
list.set(i, replacement);
}
}
}
else
{
obj = updateQNameURI(obj);
}
}
return obj;
}
protected Object updateQNameURI(Object value)
{
if (value instanceof QName)
{
QName qName = (QName)value;
if (qName.getNamespaceURI().length() != 0)
{
throw new IllegalArgumentException("Curly brace notation is not a syntactically valid serialized representation for the QName '" + qName.toString() + "'");
}
String prefix = qName.getPrefix();
String namespace = getURI(prefix);
qName = new org.eclipse.emf.ecore.xml.type.internal.QName(namespace, qName.getLocalPart(), prefix);
if (qName.getPrefix().length() > 0 && namespace == null)
{
throw new IllegalArgumentException("The prefix '" + prefix + "' is not declared for the QName '" + qName.toString() + "'");
}
if (namespace == null)
{
seenEmptyStringMapping = true;
String uri = prefixesToURIs.get("");
if (uri != null)
{
prefixesToURIs.put("", namespace);
addNSDeclaration("", uri);
}
}
return qName;
}
else
{
return value;
}
}
/**
* @param factory
* @param dataType
* @param value a data value to be converted to string
* @param list if the value is part of the list of values
* @return if the value is not part of the list, return string corresponding to value,
* otherwise return null
*/
protected String updateQNamePrefix(EFactory factory, EDataType dataType, Object value, boolean list)
{
if (value instanceof QName)
{
QName qName = (QName)value;
String namespace = qName.getNamespaceURI();
String localPart = qName.getLocalPart();
if (namespace.length() == 0)
{
if (value instanceof org.eclipse.emf.ecore.xml.type.internal.QName)
{
((org.eclipse.emf.ecore.xml.type.internal.QName)qName).setPrefix("");
}
else if (qName.getPrefix().length() != 0)
{
throw new IllegalStateException("The null namespace cannot be bound to a non-null prefix '" + qName + "'");
}
return localPart;
}
String prefix = qName.getPrefix();
EPackage ePackage = extendedMetaData.getPackage(namespace);
if (ePackage == null)
{
int size = extendedMetaData.demandedPackages().size();
ePackage = extendedMetaData.demandPackage(namespace);
if (prefix.length() != 0 && extendedMetaData.demandedPackages().size() > size)
{
ePackage.setNsPrefix(prefix);
}
}
if (!namespace.equals(getNamespaceURI(prefix)))
{
prefix = getPrefix(ePackage, true);
if (value instanceof org.eclipse.emf.ecore.xml.type.internal.QName)
{
((org.eclipse.emf.ecore.xml.type.internal.QName)qName).setPrefix(prefix);
}
}
return list ? null : prefix.length() == 0 ? localPart : prefix + ':' + localPart;
}
return list ? null: factory.convertToString(dataType, value);
}
protected void addNSDeclaration(String prefix, String uri)
{
if (uri != null)
{
List<String> existingPrefixes = urisToPrefixes.get(uri);
if (existingPrefixes == null)
{
int lowerBound = 0;
int index = 1;
String newPrefix;
while (prefixesToURIs.containsKey(newPrefix = prefix + "_" + index))
{
lowerBound = index;
index <<= 1;
}
if (lowerBound != 0)
{
int upperBound = index;
while (lowerBound + 1 < upperBound)
{
index = (lowerBound + upperBound) >> 1;
if (prefixesToURIs.containsKey(prefix + "_" + index))
{
lowerBound = index;
}
else
{
upperBound = index;
}
}
newPrefix = prefix + "_" + (lowerBound + 1);
}
prefixesToURIs.put(newPrefix, uri);
}
}
}
public void setMustHavePrefix(boolean mustHavePrefix)
{
this.mustHavePrefix = mustHavePrefix;
}
}