org.apache.xmlbeans.impl.schema.StscState Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of com.liferay.document.library.opener.onedrive.web
Show all versions of com.liferay.document.library.opener.onedrive.web
Liferay Document Library Opener OneDrive Web
/* 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.SystemProperties;
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 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 boolean _mdefAll;
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);
if (uri.getScheme().equalsIgnoreCase("jar") ||
uri.getScheme().equalsIgnoreCase("zip"))
{
// It may be local or not, depending on the embedded URI
String s = uri.getSchemeSpecificPart();
int i = s.lastIndexOf('!');
return shouldDownloadURI(i > 0 ? s.substring(0, i) : s);
}
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(SystemProperties.getProperty("xmlbean.uniqueparticleattribution", "true"));
_noPvr = options.hasOption(XmlOptions.COMPILE_NO_PVR_RULE) ? true :
!"true".equals(SystemProperties.getProperty("xmlbean.particlerestriction", "true"));
_noAnn = options.hasOption(XmlOptions.COMPILE_NO_ANNOTATIONS) ? true :
!"true".equals(SystemProperties.getProperty("xmlbean.schemaannotations", "true"));
_doingDownloads = options.hasOption(XmlOptions.COMPILE_DOWNLOAD_URLS) ? true :
"true".equals(SystemProperties.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";
String any = "##any";
if (_mdefNamespaces.contains(local))
{
_mdefNamespaces.remove(local);
_mdefNamespaces.add("");
}
if (_mdefNamespaces.contains(any))
{
_mdefNamespaces.remove(any);
_mdefAll = true;
}
}
}
/**
* 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, int kind)
{
if (_config == null)
return null;
return _config.lookupJavanameForQName(qname, kind);
}
/* 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)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "global type", QNameHelper.pretty(name), ((SchemaType) _redefinedGlobalTypes.get(redefined)).getSourceName() } ,
type.getParseObject());
} else {
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)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "global type", QNameHelper.pretty(name), ((SchemaType) _globalTypes.get(name)).getSourceName() },
type.getParseObject());
} else {
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)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "global element", QNameHelper.pretty(name), ((SchemaComponent) _documentTypes.get(name)).getSourceName() },
type.getParseObject());
} else {
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)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "global attribute", QNameHelper.pretty(name), ((SchemaComponent) _attributeTypes.get(name)).getSourceName() },
type.getParseObject());
} else {
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)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "attribute group", QNameHelper.pretty(name), ((SchemaComponent) _redefinedAttributeGroups.get(redefined)).getSourceName() },
attributeGroup.getParseObject());
} else {
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)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "attribute group", QNameHelper.pretty(name), ((SchemaComponent) _attributeGroups.get(name)).getSourceName() },
attributeGroup.getParseObject());
} else {
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)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "model group", QNameHelper.pretty(name), ((SchemaComponent) _redefinedModelGroups.get(redefined)).getSourceName() },
modelGroup.getParseObject());
} else {
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)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
new Object[] { "model group", QNameHelper.pretty(name), ((SchemaComponent) _modelGroups.get(name)).getSourceName() },
modelGroup.getParseObject());
} else {
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 void clearThreadLocals() {
tl_stscStack.remove();
}
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;
}
}