/* Copyright 2004 The Apache Software Foundation
*
* Licensed 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.xmlbeans.impl.schema;
import org.apache.xmlbeans.XmlErrorCodes;
import org.apache.xmlbeans.impl.common.QNameHelper;
import org.apache.xmlbeans.impl.common.ResolverUtil;
import org.apache.xmlbeans.XmlObject;
import org.apache.xmlbeans.SchemaGlobalElement;
import org.apache.xmlbeans.SchemaComponent;
import org.apache.xmlbeans.SchemaType;
import org.apache.xmlbeans.SchemaGlobalAttribute;
import org.apache.xmlbeans.SchemaIdentityConstraint;
import org.apache.xmlbeans.SchemaAttributeGroup;
import org.apache.xmlbeans.SchemaModelGroup;
import org.apache.xmlbeans.SchemaTypeLoader;
import org.apache.xmlbeans.XmlError;
import org.apache.xmlbeans.XmlBeans;
import org.apache.xmlbeans.XmlOptions;
import org.apache.xmlbeans.BindingConfig;
import org.apache.xmlbeans.impl.values.XmlStringImpl;
import org.apache.xmlbeans.impl.values.XmlValueOutOfRangeException;
import org.apache.xmlbeans.impl.util.HexBin;
import java.util.*;
import java.net.URISyntaxException;
import java.net.URI;
import java.net.URL;
import java.io.File;
import java.lang.ref.SoftReference;
import javax.xml.namespace.QName;
import org.apache.xmlbeans.impl.xb.xsdschema.SchemaDocument;
import org.xml.sax.EntityResolver;
/**
* This class represents the state of the SchemaTypeSystemCompiler as it's
* going.
*/
public class StscState
{
private String _givenStsName;
private Collection _errorListener;
private SchemaTypeSystemImpl _target;
private BindingConfig _config;
private Map _compatMap;
private boolean _doingDownloads;
private byte[] _digest = null;
private boolean _noDigest = false;
// EXPERIMENTAL: recovery from compilation errors and partial type systems
private boolean _allowPartial = false;
private int _recoveredErrors = 0;
private SchemaTypeLoader _importingLoader;
private Map _containers = new LinkedHashMap();
private SchemaDependencies _dependencies;
private Map _redefinedGlobalTypes = new LinkedHashMap();
private Map _redefinedModelGroups = new LinkedHashMap();
private Map _redefinedAttributeGroups = new LinkedHashMap();
private Map _globalTypes = new LinkedHashMap();
private Map _globalElements = new LinkedHashMap();
private Map _globalAttributes = new LinkedHashMap();
private Map _modelGroups = new LinkedHashMap();
private Map _attributeGroups = new LinkedHashMap();
private Map _documentTypes = new LinkedHashMap();
private Map _attributeTypes = new LinkedHashMap();
private Map _typesByClassname = new LinkedHashMap();
private Map _misspelledNames = new HashMap();
private Set _processingGroups = new LinkedHashSet();
private Map _idConstraints = new LinkedHashMap();
private Set _namespaces = new HashSet();
private List _annotations = new ArrayList();
private boolean _noUpa;
private boolean _noPvr;
private boolean _noAnn;
private Set _mdefNamespaces = buildDefaultMdefNamespaces();
private EntityResolver _entityResolver;
private File _schemasDir;
private static Set buildDefaultMdefNamespaces()
{
// namespaces which are known to appear in WSDLs redundantly
return new HashSet(
Arrays.asList( new String[] {
"http://www.openuri.org/2002/04/soap/conversation/",
}));
}
/**
* Used to store the new target namespace for a chameleon
* included schema.
*/
public static final Object CHAMELEON_INCLUDE_URI = new Object();
/**
* Only constructed via StscState.start().
*/
private StscState()
{
}
/**
* Initializer for incremental compilation
*/
public void initFromTypeSystem(SchemaTypeSystemImpl system, Set newNamespaces)
{
// setGivenTypeSystemName(system.getName().substring(14));
SchemaContainer[] containers = system.containers();
for (int i = 0; i < containers.length; i++)
{
if (!newNamespaces.contains(containers[i].getNamespace()))
{
// Copy data from the given container
addContainer(containers[i]);
}
}
}
/* CONTAINERS ================================================================*/
void addNewContainer(String namespace)
{
if (_containers.containsKey(namespace))
return;
SchemaContainer container = new SchemaContainer(namespace);
container.setTypeSystem(sts());
addNamespace(namespace);
_containers.put(namespace, container);
}
private void addContainer(SchemaContainer container)
{
_containers.put(container.getNamespace(), container);
List redefModelGroups = container.redefinedModelGroups();
for (int i = 0; i < redefModelGroups.size(); i++)
{
QName name = ((SchemaModelGroup) redefModelGroups.get(i)).getName();
_redefinedModelGroups.put(name, redefModelGroups.get(i));
}
List redefAttrGroups = container.redefinedAttributeGroups();
for (int i = 0; i < redefAttrGroups.size(); i++)
{
QName name = ((SchemaAttributeGroup) redefAttrGroups.get(i)).getName();
_redefinedAttributeGroups.put(name, redefAttrGroups.get(i));
}
List redefTypes = container.redefinedGlobalTypes();
for (int i = 0; i < redefTypes.size(); i++)
{
QName name = ((SchemaType) redefTypes.get(i)).getName();
_redefinedGlobalTypes.put(name, redefTypes.get(i));
}
List globalElems = container.globalElements();
for (int i = 0; i < globalElems.size(); i++)
{
QName name = ((SchemaGlobalElement) globalElems.get(i)).getName();
_globalElements.put(name, globalElems.get(i));
}
List globalAtts = container.globalAttributes();
for (int i = 0; i < globalAtts.size(); i++)
{
QName name = ((SchemaGlobalAttribute) globalAtts.get(i)).getName();
_globalAttributes.put(name, globalAtts.get(i));
}
List modelGroups = container.modelGroups();
for (int i = 0; i < modelGroups.size(); i++)
{
QName name = ((SchemaModelGroup) modelGroups.get(i)).getName();
_modelGroups.put(name, modelGroups.get(i));
}
List attrGroups = container.attributeGroups();
for (int i = 0; i < attrGroups.size(); i++)
{
QName name = ((SchemaAttributeGroup) attrGroups.get(i)).getName();
_attributeGroups.put(name, attrGroups.get(i));
}
List globalTypes = container.globalTypes();
for (int i = 0; i < globalTypes.size(); i++)
{
SchemaType t = (SchemaType) globalTypes.get(i);
QName name = t.getName();
_globalTypes.put(name, t);
if (t.getFullJavaName() != null)
addClassname(t.getFullJavaName(), t);
}
List documentTypes = container.documentTypes();
for (int i = 0; i < documentTypes.size(); i++)
{
SchemaType t = (SchemaType) documentTypes.get(i);
QName name = t.getProperties()[0].getName();
_documentTypes.put(name, t);
if (t.getFullJavaName() != null)
addClassname(t.getFullJavaName(), t);
}
List attributeTypes = container.attributeTypes();
for (int i = 0; i < attributeTypes.size(); i++)
{
SchemaType t = (SchemaType) attributeTypes.get(i);
QName name = t.getProperties()[0].getName();
_attributeTypes.put(name, t);
if (t.getFullJavaName() != null)
addClassname(t.getFullJavaName(), t);
}
List identityConstraints = container.identityConstraints();
for (int i = 0; i < identityConstraints.size(); i++)
{
QName name = ((SchemaIdentityConstraint) identityConstraints.get(i)).getName();
_idConstraints.put(name, identityConstraints.get(i));
}
_annotations.addAll(container.annotations());
_namespaces.add(container.getNamespace());
container.unsetImmutable();
}
SchemaContainer getContainer(String namespace)
{
return (SchemaContainer) _containers.get(namespace);
}
Map getContainerMap()
{
return Collections.unmodifiableMap(_containers);
}
/* DEPENDENCIES ================================================================*/
void registerDependency(String sourceNs, String targetNs)
{
_dependencies.registerDependency(sourceNs, targetNs);
}
void registerContribution(String ns, String fileUrl)
{
_dependencies.registerContribution(ns, fileUrl);
}
SchemaDependencies getDependencies()
{
return _dependencies;
}
void setDependencies(SchemaDependencies deps)
{
_dependencies = deps;
}
boolean isFileProcessed(String url)
{
return _dependencies.isFileRepresented(url);
}
/**
* Initializer for schematypepath
*/
public void setImportingTypeLoader(SchemaTypeLoader loader)
{
_importingLoader = loader;
}
/**
* Initializer for error handling.
*/
public void setErrorListener(Collection errorListener)
{ _errorListener = errorListener; }
/**
* Passes an error on to the current error listener.
* KHK: remove this
*/
public void error(String message, int code, XmlObject loc)
{ addError(_errorListener, message, code, loc); }
/**
* Passes an error on to the current error listener.
*/
public void error(String code, Object[] args, XmlObject loc)
{ addError(_errorListener, code, args, loc); }
/**
* Passes a recovered error on to the current error listener.
*/
public void recover(String code, Object[] args, XmlObject loc)
{ addError(_errorListener, code, args, loc); _recoveredErrors++; }
/**
* Passes an error on to the current error listener.
*/
public void warning(String message, int code, XmlObject loc)
{
addWarning(_errorListener, message, code, loc);
}
/**
* Passes an error on to the current error listener.
*/
public void warning(String code, Object[] args, XmlObject loc)
{
// it's OK for XMLSchema.xsd itself to have reserved type names
if (code == XmlErrorCodes.RESERVED_TYPE_NAME &&
loc.documentProperties().getSourceName() != null &&
loc.documentProperties().getSourceName().indexOf("XMLSchema.xsd") > 0)
return;
addWarning(_errorListener, code, args, loc);
}
/**
* Passes a warning on to the current error listener.
*/
public void info(String message)
{ addInfo(_errorListener, message); }
/**
* Passes a warning on to the current error listener.
*/
public void info(String code, Object[] args)
{ addInfo(_errorListener, code, args); }
// KHK: remove this
public static void addError(Collection errorListener, String message, int code, XmlObject location)
{
XmlError err =
XmlError.forObject(
message,
XmlError.SEVERITY_ERROR,
location);
errorListener.add(err);
}
public static void addError(Collection errorListener, String code, Object[] args, XmlObject location)
{
XmlError err =
XmlError.forObject(
code,
args,
XmlError.SEVERITY_ERROR,
location);
errorListener.add(err);
}
public static void addError(Collection errorListener, String code, Object[] args, File location)
{
XmlError err =
XmlError.forLocation(
code,
args,
XmlError.SEVERITY_ERROR,
location.toURI().toString(), 0, 0, 0);
errorListener.add(err);
}
public static void addError(Collection errorListener, String code, Object[] args, URL location)
{
XmlError err =
XmlError.forLocation(
code,
args,
XmlError.SEVERITY_ERROR,
location.toString(), 0, 0, 0);
errorListener.add(err);
}
// KHK: remove this
public static void addWarning(Collection errorListener, String message, int code, XmlObject location)
{
XmlError err =
XmlError.forObject(
message,
XmlError.SEVERITY_WARNING,
location);
errorListener.add(err);
}
public static void addWarning(Collection errorListener, String code, Object[] args, XmlObject location)
{
XmlError err =
XmlError.forObject(
code,
args,
XmlError.SEVERITY_WARNING,
location);
errorListener.add(err);
}
public static void addInfo(Collection errorListener, String message)
{
XmlError err = XmlError.forMessage(message, XmlError.SEVERITY_INFO);
errorListener.add(err);
}
public static void addInfo(Collection errorListener, String code, Object[] args)
{
XmlError err = XmlError.forMessage(code, args, XmlError.SEVERITY_INFO);
errorListener.add(err);
}
public void setGivenTypeSystemName(String name)
{ _givenStsName = name; }
/**
* Initializer for references to the SchemaTypeLoader
*/
public void setTargetSchemaTypeSystem(SchemaTypeSystemImpl target)
{ _target = target; }
/**
* Accumulates a schema digest...
*/
public void addSchemaDigest(byte[] digest)
{
if (_noDigest)
return;
if (digest == null)
{
_noDigest = true;
_digest = null;
return;
}
if (_digest == null)
_digest = new byte[128/8]; // 128 bits.
int len = _digest.length;
if (digest.length < len)
len = digest.length;
for (int i = 0; i < len; i++)
_digest[i] ^= digest[i];
}
/**
* The SchemaTypeSystem which we're building types on behalf of.
*/
public SchemaTypeSystemImpl sts()
{
if (_target != null)
return _target;
String name = _givenStsName;
if (name == null && _digest != null)
name = "s" + new String(HexBin.encode(_digest));
_target = new SchemaTypeSystemImpl(name);
return _target;
}
/**
* True if the given URI is a local file
*/
public boolean shouldDownloadURI(String uriString)
{
if (_doingDownloads)
return true;
if (uriString == null)
return false;
try
{
URI uri = new URI(uriString);
return uri.getScheme().equalsIgnoreCase("file");
}
catch (Exception e)
{
return false;
}
}
/**
* Initializer for compatMap.
*/
public void setOptions(XmlOptions options)
{
if (options == null)
{
return; // defaults are all false.
}
_allowPartial = options.hasOption("COMPILE_PARTIAL_TYPESYSTEM");
_compatMap = (Map)options.get(XmlOptions.COMPILE_SUBSTITUTE_NAMES);
_noUpa = options.hasOption(XmlOptions.COMPILE_NO_UPA_RULE) ? true :
!"true".equals(System.getProperty("xmlbean.uniqueparticleattribution", "true"));
_noPvr = options.hasOption(XmlOptions.COMPILE_NO_PVR_RULE) ? true :
!"true".equals(System.getProperty("xmlbean.particlerestriction", "true"));
_noAnn = options.hasOption(XmlOptions.COMPILE_NO_ANNOTATIONS) ? true :
!"true".equals(System.getProperty("xmlbean.schemaannotations", "true"));
_doingDownloads = options.hasOption(XmlOptions.COMPILE_DOWNLOAD_URLS) ? true :
"true".equals(System.getProperty("xmlbean.downloadurls", "false"));
_entityResolver = (EntityResolver)options.get(XmlOptions.ENTITY_RESOLVER);
if (_entityResolver == null)
_entityResolver = ResolverUtil.getGlobalEntityResolver();
if (_entityResolver != null)
_doingDownloads = true;
if (options.hasOption(XmlOptions.COMPILE_MDEF_NAMESPACES))
{
_mdefNamespaces.addAll((Collection)options.get(XmlOptions.COMPILE_MDEF_NAMESPACES));
String local = "##local";
if (_mdefNamespaces.contains(local))
{
_mdefNamespaces.remove(local);
_mdefNamespaces.add("");
}
}
}
/**
* May return null if there is no custom entity resolver.
*/
public EntityResolver getEntityResolver()
{
return _entityResolver;
}
/**
* True if no unique particle attribution option is set
*/
public boolean noUpa()
{
return _noUpa;
}
/**
* True if no particle valid (restriciton) option is set
*/
public boolean noPvr()
{
return _noPvr;
}
/**
* True if annotations should be skipped
*/
public boolean noAnn()
{
return _noAnn;
}
/**
* True if a partial SchemaTypeSystem should be produced
*/
// EXPERIMENTAL
public boolean allowPartial()
{
return _allowPartial;
}
/**
* Get count of recovered errors. Not for public.
*/
// EXPERIMENTAL
public int getRecovered()
{
return _recoveredErrors;
}
/**
* Intercepts XML names and translates them
* through the compat map, if any.
*
* Also looks for a default namespace for global definitions.
*/
private QName compatName(QName name, String chameleonNamespace)
{
// first check for a chameleonNamespace namespace
if (name.getNamespaceURI().length() == 0 && chameleonNamespace != null && chameleonNamespace.length() > 0)
name = new QName(chameleonNamespace, name.getLocalPart());
if (_compatMap == null)
return name;
QName subst = (QName)_compatMap.get(name);
if (subst == null)
return name;
return subst;
}
/**
* Initializer for the schema config object.
*/
public void setBindingConfig(BindingConfig config)
throws IllegalArgumentException
{
_config = config;
}
public BindingConfig getBindingConfig()
throws IllegalArgumentException
{
return _config;
}
/**
* Looks up package override for a namespace URI
*/
public String getPackageOverride(String namespace)
{
if (_config == null)
return null;
return _config.lookupPackageForNamespace(namespace);
}
/**
* Looks up package override for a namespace URI
*/
public String getJavaPrefix(String namespace)
{
if (_config == null)
return null;
return _config.lookupPrefixForNamespace(namespace);
}
/**
* Looks up package override for a namespace URI
*/
public String getJavaSuffix(String namespace)
{
if (_config == null)
return null;
return _config.lookupSuffixForNamespace(namespace);
}
/**
* Looks up configured java name for the given qname.
*/
public String getJavaname(QName qname)
{
if (_config == null)
return null;
return _config.lookupJavanameForQName(qname);
}
/* SPELLINGS ======================================================*/
private static String crunchName(QName name)
{
// lowercase, and drop namespace.
return name.getLocalPart().toLowerCase();
}
void addSpelling(QName name, SchemaComponent comp)
{
_misspelledNames.put(crunchName(name), comp);
}
SchemaComponent findSpelling(QName name)
{
return (SchemaComponent)_misspelledNames.get(crunchName(name));
}
/* NAMESPACES ======================================================*/
void addNamespace(String targetNamespace)
{
_namespaces.add(targetNamespace);
}
String[] getNamespaces()
{
return (String[])_namespaces.toArray(new String[_namespaces.size()]);
}
boolean linkerDefinesNamespace(String namespace)
{
return _importingLoader.isNamespaceDefined(namespace);
}
/* TYPES ==========================================================*/
SchemaTypeImpl findGlobalType(QName name, String chameleonNamespace, String sourceNamespace)
{
name = compatName(name, chameleonNamespace);
SchemaTypeImpl result = (SchemaTypeImpl)_globalTypes.get(name);
boolean foundOnLoader = false;
if (result == null)
{
result = (SchemaTypeImpl)_importingLoader.findType(name);
foundOnLoader = result != null;
}
if (!foundOnLoader && sourceNamespace != null)
registerDependency(sourceNamespace, name.getNamespaceURI());
return result;
}
SchemaTypeImpl findRedefinedGlobalType(QName name, String chameleonNamespace, SchemaTypeImpl redefinedBy)
{
QName redefinedName = redefinedBy.getName();
name = compatName(name, chameleonNamespace);
if (name.equals(redefinedName))
{
return (SchemaTypeImpl)_redefinedGlobalTypes.get(redefinedBy);
// BUGBUG: should also link against _importingLoader.findRedefinedType
}
SchemaTypeImpl result = (SchemaTypeImpl)_globalTypes.get(name);
if (result == null)
result = (SchemaTypeImpl)_importingLoader.findType(name);
// no dependency is needed here, necause it's intra-namespace
return result;
}
void addGlobalType(SchemaTypeImpl type, SchemaTypeImpl redefined)
{
if (type != null)
{
QName name = type.getName();
SchemaContainer container = getContainer(name.getNamespaceURI());
assert container != null && container == type.getContainer();
if (redefined != null)
{
if (_redefinedGlobalTypes.containsKey(redefined))
{
if (!ignoreMdef(name))
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "global type", QNameHelper.pretty(name), ((SchemaType) _redefinedGlobalTypes.get(redefined)).getSourceName() } ,
type.getParseObject());
}
else
{
_redefinedGlobalTypes.put(redefined, type);
container.addRedefinedType(type.getRef());
}
}
else
{
if (_globalTypes.containsKey(name))
{
if (!ignoreMdef(name))
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "global type", QNameHelper.pretty(name), ((SchemaType) _globalTypes.get(name)).getSourceName() },
type.getParseObject());
}
else
{
_globalTypes.put(name, type);
container.addGlobalType(type.getRef());
addSpelling(name, type);
}
}
}
}
private boolean ignoreMdef(QName name)
{
return _mdefNamespaces.contains(name.getNamespaceURI());
}
SchemaType[] globalTypes()
{ return (SchemaType[])_globalTypes.values().toArray(new SchemaType[_globalTypes.size()]); }
SchemaType[] redefinedGlobalTypes()
{ return (SchemaType[])_redefinedGlobalTypes.values().toArray(new SchemaType[_redefinedGlobalTypes.size()]); }
/* DOCUMENT TYPES =================================================*/
SchemaTypeImpl findDocumentType(QName name, String chameleonNamespace, String sourceNamespace)
{
name = compatName(name, chameleonNamespace);
SchemaTypeImpl result = (SchemaTypeImpl)_documentTypes.get(name);
boolean foundOnLoader = false;
if (result == null)
{
result = (SchemaTypeImpl)_importingLoader.findDocumentType(name);
foundOnLoader = result != null;
}
if (!foundOnLoader && sourceNamespace != null)
registerDependency(sourceNamespace, name.getNamespaceURI());
return result;
}
void addDocumentType(SchemaTypeImpl type, QName name)
{
if (_documentTypes.containsKey(name))
{
if (!ignoreMdef(name))
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "global element", QNameHelper.pretty(name), ((SchemaComponent) _documentTypes.get(name)).getSourceName() },
type.getParseObject());
}
else
{
_documentTypes.put(name, type);
SchemaContainer container = getContainer(name.getNamespaceURI());
assert container != null && container == type.getContainer();
container.addDocumentType(type.getRef());
}
}
SchemaType[] documentTypes()
{ return (SchemaType[])_documentTypes.values().toArray(new SchemaType[_documentTypes.size()]); }
/* ATTRIBUTE TYPES =================================================*/
SchemaTypeImpl findAttributeType(QName name, String chameleonNamespace, String sourceNamespace)
{
name = compatName(name, chameleonNamespace);
SchemaTypeImpl result = (SchemaTypeImpl)_attributeTypes.get(name);
boolean foundOnLoader = false;
if (result == null)
{
result = (SchemaTypeImpl)_importingLoader.findAttributeType(name);
foundOnLoader = result != null;
}
if (!foundOnLoader && sourceNamespace != null)
registerDependency(sourceNamespace, name.getNamespaceURI());
return result;
}
void addAttributeType(SchemaTypeImpl type, QName name)
{
if (_attributeTypes.containsKey(name))
{
if (!ignoreMdef(name))
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "global attribute", QNameHelper.pretty(name), ((SchemaComponent) _attributeTypes.get(name)).getSourceName() },
type.getParseObject());
}
else
{
_attributeTypes.put(name, type);
SchemaContainer container = getContainer(name.getNamespaceURI());
assert container != null && container == type.getContainer();
container.addAttributeType(type.getRef());
}
}
SchemaType[] attributeTypes()
{ return (SchemaType[])_attributeTypes.values().toArray(new SchemaType[_attributeTypes.size()]); }
/* ATTRIBUTES =====================================================*/
SchemaGlobalAttributeImpl findGlobalAttribute(QName name, String chameleonNamespace, String sourceNamespace)
{
name = compatName(name, chameleonNamespace);
SchemaGlobalAttributeImpl result = (SchemaGlobalAttributeImpl)_globalAttributes.get(name);
boolean foundOnLoader = false;
if (result == null)
{
result = (SchemaGlobalAttributeImpl)_importingLoader.findAttribute(name);
foundOnLoader = result != null;
}
if (!foundOnLoader && sourceNamespace != null)
registerDependency(sourceNamespace, name.getNamespaceURI());
return result;
}
void addGlobalAttribute(SchemaGlobalAttributeImpl attribute)
{
if (attribute != null)
{
QName name = attribute.getName();
_globalAttributes.put(name, attribute);
addSpelling(name, attribute);
SchemaContainer container = getContainer(name.getNamespaceURI());
assert container != null && container == attribute.getContainer();
container.addGlobalAttribute(attribute.getRef());
}
}
SchemaGlobalAttribute[] globalAttributes()
{ return (SchemaGlobalAttribute[])_globalAttributes.values().toArray(new SchemaGlobalAttribute[_globalAttributes.size()]); }
/* ELEMENTS =======================================================*/
SchemaGlobalElementImpl findGlobalElement(QName name, String chameleonNamespace, String sourceNamespace)
{
name = compatName(name, chameleonNamespace);
SchemaGlobalElementImpl result = (SchemaGlobalElementImpl)_globalElements.get(name);
boolean foundOnLoader = false;
if (result == null)
{
result = (SchemaGlobalElementImpl)_importingLoader.findElement(name);
foundOnLoader = result != null;
}
if (!foundOnLoader && sourceNamespace != null)
registerDependency(sourceNamespace, name.getNamespaceURI());
return result;
}
void addGlobalElement(SchemaGlobalElementImpl element)
{
if (element != null)
{
QName name = element.getName();
_globalElements.put(name, element);
SchemaContainer container = getContainer(name.getNamespaceURI());
assert container != null && container == element.getContainer();
container.addGlobalElement(element.getRef());
addSpelling(name, element);
}
}
SchemaGlobalElement[] globalElements()
{ return (SchemaGlobalElement[])_globalElements.values().toArray(new SchemaGlobalElement[_globalElements.size()]); }
/* ATTRIBUTE GROUPS ===============================================*/
SchemaAttributeGroupImpl findAttributeGroup(QName name, String chameleonNamespace, String sourceNamespace)
{
name = compatName(name, chameleonNamespace);
SchemaAttributeGroupImpl result = (SchemaAttributeGroupImpl)_attributeGroups.get(name);
boolean foundOnLoader = false;
if (result == null)
{
result = (SchemaAttributeGroupImpl)_importingLoader.findAttributeGroup(name);
foundOnLoader = result != null;
}
if (!foundOnLoader && sourceNamespace != null)
registerDependency(sourceNamespace, name.getNamespaceURI());
return result;
}
SchemaAttributeGroupImpl findRedefinedAttributeGroup(QName name, String chameleonNamespace, SchemaAttributeGroupImpl redefinedBy)
{
QName redefinitionFor = redefinedBy.getName();
name = compatName(name, chameleonNamespace);
if (name.equals(redefinitionFor))
{
return (SchemaAttributeGroupImpl)_redefinedAttributeGroups.get(redefinedBy);
// BUGBUG: should also link against _importingLoader.findRedefinedAttributeGroup
}
SchemaAttributeGroupImpl result = (SchemaAttributeGroupImpl)_attributeGroups.get(name);
if (result == null)
result = (SchemaAttributeGroupImpl)_importingLoader.findAttributeGroup(name);
return result;
}
void addAttributeGroup(SchemaAttributeGroupImpl attributeGroup, SchemaAttributeGroupImpl redefined)
{
if (attributeGroup != null)
{
QName name = attributeGroup.getName();
SchemaContainer container = getContainer(name.getNamespaceURI());
assert container != null && container == attributeGroup.getContainer();
if (redefined != null)
{
if (_redefinedAttributeGroups.containsKey(redefined))
{
if (!ignoreMdef(name))
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "attribute group", QNameHelper.pretty(name), ((SchemaComponent) _redefinedAttributeGroups.get(redefined)).getSourceName() },
attributeGroup.getParseObject());
}
else
{
_redefinedAttributeGroups.put(redefined, attributeGroup);
container.addRedefinedAttributeGroup(attributeGroup.getRef());
}
}
else
{
if (_attributeGroups.containsKey( name ))
{
if (!ignoreMdef(name))
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "attribute group", QNameHelper.pretty(name), ((SchemaComponent) _attributeGroups.get(name)).getSourceName() },
attributeGroup.getParseObject());
}
else
{
_attributeGroups.put(attributeGroup.getName(), attributeGroup);
addSpelling(attributeGroup.getName(), attributeGroup);
container.addAttributeGroup(attributeGroup.getRef());
}
}
}
}
SchemaAttributeGroup[] attributeGroups()
{ return (SchemaAttributeGroup[])_attributeGroups.values().toArray(new SchemaAttributeGroup[_attributeGroups.size()]); }
SchemaAttributeGroup[] redefinedAttributeGroups()
{ return (SchemaAttributeGroup[])_redefinedAttributeGroups.values().toArray(new SchemaAttributeGroup[_redefinedAttributeGroups.size()]); }
/* MODEL GROUPS ===================================================*/
SchemaModelGroupImpl findModelGroup(QName name, String chameleonNamespace, String sourceNamespace)
{
name = compatName(name, chameleonNamespace);
SchemaModelGroupImpl result = (SchemaModelGroupImpl)_modelGroups.get(name);
boolean foundOnLoader = false;
if (result == null)
{
result = (SchemaModelGroupImpl)_importingLoader.findModelGroup(name);
foundOnLoader = result != null;
}
if (!foundOnLoader && sourceNamespace != null)
registerDependency(sourceNamespace, name.getNamespaceURI());
return result;
}
SchemaModelGroupImpl findRedefinedModelGroup(QName name, String chameleonNamespace, SchemaModelGroupImpl redefinedBy)
{
QName redefinitionFor = redefinedBy.getName();
name = compatName(name, chameleonNamespace);
if (name.equals(redefinitionFor))
{
return (SchemaModelGroupImpl)_redefinedModelGroups.get(redefinedBy);
// BUGBUG: should also link against _importingLoader.findRedefinedModelGroup
}
SchemaModelGroupImpl result = (SchemaModelGroupImpl)_modelGroups.get(name);
if (result == null)
result = (SchemaModelGroupImpl)_importingLoader.findModelGroup(name);
return result;
}
void addModelGroup(SchemaModelGroupImpl modelGroup, SchemaModelGroupImpl redefined)
{
if (modelGroup != null)
{
QName name = modelGroup.getName();
SchemaContainer container = getContainer(name.getNamespaceURI());
assert container != null && container == modelGroup.getContainer();
if (redefined != null)
{
if (_redefinedModelGroups.containsKey(redefined))
{
if (!ignoreMdef(name))
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "model group", QNameHelper.pretty(name), ((SchemaComponent) _redefinedModelGroups.get(redefined)).getSourceName() },
modelGroup.getParseObject());
}
else
{
_redefinedModelGroups.put(redefined, modelGroup);
container.addRedefinedModelGroup(modelGroup.getRef());
}
}
else
{
if (_modelGroups.containsKey(name))
{
if (!ignoreMdef(name))
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "model group", QNameHelper.pretty(name), ((SchemaComponent) _modelGroups.get(name)).getSourceName() },
modelGroup.getParseObject());
}
else
{
_modelGroups.put(modelGroup.getName(), modelGroup);
addSpelling(modelGroup.getName(), modelGroup);
container.addModelGroup(modelGroup.getRef());
}
}
}
}
SchemaModelGroup[] modelGroups()
{ return (SchemaModelGroup[])_modelGroups.values().toArray(new SchemaModelGroup[_modelGroups.size()]); }
SchemaModelGroup[] redefinedModelGroups()
{ return (SchemaModelGroup[])_redefinedModelGroups.values().toArray(new SchemaModelGroup[_redefinedModelGroups.size()]); }
/* IDENTITY CONSTRAINTS ===========================================*/
SchemaIdentityConstraintImpl findIdConstraint(QName name, String chameleonNamespace, String sourceNamespace)
{
name = compatName(name, chameleonNamespace);
if (sourceNamespace != null)
registerDependency(sourceNamespace, name.getNamespaceURI());
return (SchemaIdentityConstraintImpl)_idConstraints.get(name);
}
void addIdConstraint(SchemaIdentityConstraintImpl idc)
{
if (idc != null)
{
QName name = idc.getName();
SchemaContainer container = getContainer(name.getNamespaceURI());
assert container != null && container == idc.getContainer();
if (_idConstraints.containsKey(name))
{
if (!ignoreMdef(name))
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "identity constraint", QNameHelper.pretty(name), ((SchemaComponent) _idConstraints.get(name)).getSourceName() },
idc.getParseObject());
}
else
{
_idConstraints.put(name, idc);
addSpelling(idc.getName(), idc);
container.addIdentityConstraint(idc.getRef());
}
}
}
SchemaIdentityConstraintImpl[] idConstraints()
{ return (SchemaIdentityConstraintImpl[])_idConstraints.values().toArray(new SchemaIdentityConstraintImpl[_idConstraints.size()]); }
/* ANNOTATIONS ===========================================*/
void addAnnotation(SchemaAnnotationImpl ann, String targetNamespace)
{
if (ann != null)
{
SchemaContainer container = getContainer(targetNamespace);
assert container != null && container == ann.getContainer();
_annotations.add(ann);
container.addAnnotation(ann);
}
}
List annotations()
{ return _annotations; }
/* RECURSION AVOIDANCE ============================================*/
boolean isProcessing(Object obj)
{
return _processingGroups.contains(obj);
}
void startProcessing(Object obj)
{
assert(!_processingGroups.contains(obj));
_processingGroups.add(obj);
}
void finishProcessing(Object obj)
{
assert(_processingGroups.contains(obj));
_processingGroups.remove(obj);
}
Object[] getCurrentProcessing()
{
return _processingGroups.toArray();
}
/* JAVAIZATION ====================================================*/
Map typesByClassname()
{ return Collections.unmodifiableMap(_typesByClassname); }
void addClassname(String classname, SchemaType type)
{ _typesByClassname.put(classname, type); }
/**
* Stack management if (heaven help us) we ever need to do
* nested compilation of schema type system.
*/
private static final class StscStack
{
StscState current;
ArrayList stack = new ArrayList();
final StscState push()
{
stack.add(current);
current = new StscState();
return current;
}
final void pop()
{
current = (StscState)stack.get(stack.size() - 1);
stack.remove(stack.size() - 1);
}
}
private static ThreadLocal tl_stscStack = new ThreadLocal();
public static StscState start()
{
StscStack stscStack = (StscStack) tl_stscStack.get();
if (stscStack==null)
{
stscStack = new StscStack();
tl_stscStack.set(stscStack);
}
return stscStack.push();
}
public static StscState get()
{
return ((StscStack) tl_stscStack.get()).current;
}
public static void end()
{
StscStack stscStack = (StscStack) tl_stscStack.get();
stscStack.pop();
if (stscStack.stack.size()==0)
tl_stscStack.set(null); // this is required to release all the references in this classloader
// which will enable class unloading and avoid OOM in PermGen
}
private final static XmlValueRef XMLSTR_PRESERVE = buildString("preserve");
private final static XmlValueRef XMLSTR_REPLACE = buildString("preserve");
private final static XmlValueRef XMLSTR_COLLAPSE = buildString("preserve");
static final SchemaType[] EMPTY_ST_ARRAY = new SchemaType[0];
static final SchemaType.Ref[] EMPTY_STREF_ARRAY = new SchemaType.Ref[0];
private final static XmlValueRef[] FACETS_NONE = new XmlValueRef[]
{ null, null, null, null, null, null, null, null, null,
null, null, null };
private final static boolean[] FIXED_FACETS_NONE = new boolean[]
{ false, false, false, false, false, false, false, false, false,
false, false, false };
private final static XmlValueRef[] FACETS_WS_COLLAPSE = new XmlValueRef[]
{ null, null, null, null, null, null, null, null, null,
build_wsstring(SchemaType.WS_COLLAPSE), null, null };
private final static boolean[] FIXED_FACETS_WS = new boolean[]
{ false, false, false, false, false, false, false, false, false,
true, false, false };
final static XmlValueRef[] FACETS_UNION = FACETS_NONE;
final static boolean[] FIXED_FACETS_UNION = FIXED_FACETS_NONE;
final static XmlValueRef[] FACETS_LIST = FACETS_WS_COLLAPSE;
final static boolean[] FIXED_FACETS_LIST = FIXED_FACETS_WS;
static XmlValueRef build_wsstring(int wsr)
{
switch (wsr)
{
case SchemaType.WS_PRESERVE:
return XMLSTR_PRESERVE;
case SchemaType.WS_REPLACE:
return XMLSTR_REPLACE;
case SchemaType.WS_COLLAPSE:
return XMLSTR_COLLAPSE;
}
return null;
}
static XmlValueRef buildString(String str)
{
if (str == null)
return null;
try
{
XmlStringImpl i = new XmlStringImpl();
i.set(str);
i.setImmutable();
return new XmlValueRef(i);
}
catch (XmlValueOutOfRangeException e)
{
return null;
}
}
public void notFoundError(QName itemName, int code, XmlObject loc, boolean recovered)
{
String expected;
String expectedName = QNameHelper.pretty(itemName);
String found = null;
String foundName = null;
String sourceName = null;
if (recovered)
_recoveredErrors++;
switch (code)
{
case SchemaType.TYPE:
expected = "type";
break;
case SchemaType.ELEMENT:
expected = "element";
break;
case SchemaType.ATTRIBUTE:
expected = "attribute";
break;
case SchemaType.MODEL_GROUP:
expected = "model group";
break;
case SchemaType.ATTRIBUTE_GROUP:
expected = "attribute group";
break;
case SchemaType.IDENTITY_CONSTRAINT:
expected = "identity constraint";
break;
default:
assert(false);
expected = "definition";
break;
}
SchemaComponent foundComponent = findSpelling(itemName);
QName name;
if (foundComponent != null)
{
name = foundComponent.getName();
if (name != null)
{
switch (foundComponent.getComponentType())
{
case SchemaComponent.TYPE:
found = "type";
sourceName = ((SchemaType)foundComponent).getSourceName();
break;
case SchemaComponent.ELEMENT:
found = "element";
sourceName = ((SchemaGlobalElement)foundComponent).getSourceName();
break;
case SchemaComponent.ATTRIBUTE:
found = "attribute";
sourceName = ((SchemaGlobalAttribute)foundComponent).getSourceName();
break;
case SchemaComponent.ATTRIBUTE_GROUP:
found = "attribute group";
break;
case SchemaComponent.MODEL_GROUP:
found = "model group";
break;
}
if (sourceName != null)
{
sourceName = sourceName.substring(sourceName.lastIndexOf('/') + 1);
}
if (!name.equals(itemName))
{
foundName = QNameHelper.pretty(name);
}
}
}
if (found == null)
{
// error with no help
error(XmlErrorCodes.SCHEMA_QNAME_RESOLVE,
new Object[] { expected, expectedName }, loc);
}
else {
// error with help
error(XmlErrorCodes.SCHEMA_QNAME_RESOLVE$HELP,
new Object[] {
expected,
expectedName,
found,
(foundName == null ? new Integer(0) : new Integer(1)),
foundName,
(sourceName == null ? new Integer(0) : new Integer(1)),
sourceName
},
loc);
}
}
/**
* Produces the "sourceName" (to be used within the schema project
* source file copies) from the URI of the original source.
*
* Returns null if none.
*/
public String sourceNameForUri(String uri)
{
return (String)_sourceForUri.get(uri);
}
/**
* Returns the whole sourceCopyMap, mapping URI's that have
* been read to "sourceName" local names that have been used
* to tag the types.
*/
public Map sourceCopyMap()
{
return Collections.unmodifiableMap(_sourceForUri);
}
/**
* The base URI to use for nice filenames when saving sources.
*/
public void setBaseUri(URI uri)
{
_baseURI = uri;
}
private final static String PROJECT_URL_PREFIX = "project://local";
public String relativize(String uri)
{
return relativize(uri, false);
}
public String computeSavedFilename(String uri)
{
return relativize(uri, true);
}
private String relativize(String uri, boolean forSavedFilename)
{
if (uri == null)
return null;
// deal with things that do not look like absolute uris
if (uri.startsWith("/"))
{
uri = PROJECT_URL_PREFIX + uri.replace('\\', '/');
}
else
{
// looks like a URL?
int colon = uri.indexOf(':');
if (colon <= 1 || !uri.substring(0, colon).matches("^\\w+$"))
uri = PROJECT_URL_PREFIX + "/" + uri.replace('\\', '/');
}
// now relativize against that...
if (_baseURI != null)
{
try
{
URI relative = _baseURI.relativize(new URI(uri));
if (!relative.isAbsolute())
return relative.toString();
else
uri = relative.toString();
}
catch (URISyntaxException e)
{
}
}
if (!forSavedFilename)
return uri;
int lastslash = uri.lastIndexOf('/');
String dir = QNameHelper.hexsafe(lastslash == -1 ? "" : uri.substring(0, lastslash));
int question = uri.indexOf('?', lastslash + 1);
if (question == -1)
return dir + "/" + uri.substring(lastslash + 1);
String query = QNameHelper.hexsafe(question == -1 ? "" : uri.substring(question));
// if encoded query part is longer than 64 characters, just drop it
if (query.startsWith(QNameHelper.URI_SHA1_PREFIX))
return dir + "/" + uri.substring(lastslash + 1, question);
else
return dir + "/" + uri.substring(lastslash + 1, question) + query;
}
/**
* Notes another URI that has been consumed during compilation
* (this is the URI that is in the document .NAME property)
*/
public void addSourceUri(String uri, String nameToUse)
{
if (uri == null)
return;
if (nameToUse == null)
nameToUse = computeSavedFilename(uri);
_sourceForUri.put(uri, nameToUse);
}
/**
* Returns the error listener being filled in during this compilation
*/
public Collection getErrorListener()
{
return _errorListener;
}
/**
* Returns the schema type loader to use for processing s4s
*/
public SchemaTypeLoader getS4SLoader()
{
return _s4sloader;
}
Map _sourceForUri = new HashMap();
URI _baseURI = URI.create(PROJECT_URL_PREFIX + "/");
SchemaTypeLoader _s4sloader = XmlBeans.typeLoaderForClassLoader(SchemaDocument.class.getClassLoader());
public File getSchemasDir()
{
return _schemasDir;
}
public void setSchemasDir(File _schemasDir)
{
this._schemasDir = _schemasDir;
}
}