/**
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided
* that the following conditions are met:
*
* 1. Redistributions of source code must retain copyright
* statements and notices. Redistributions must also contain a
* copy of this document.
*
* 2. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the
* following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. The name "Exolab" must not be used to endorse or promote
* products derived from this Software without prior written
* permission of Intalio, Inc. For written permission,
* please contact info@exolab.org.
*
* 4. Products derived from this Software may not be called "Exolab"
* nor may "Exolab" appear in their names without prior written
* permission of Intalio, Inc. Exolab is a registered
* trademark of Intalio, Inc.
*
* 5. Due credit should be given to the Exolab Project
* (http://www.exolab.org/).
*
* THIS SOFTWARE IS PROVIDED BY INTALIO, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
* NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* INTALIO, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 1999-2003 (C) Intalio, Inc. All Rights Reserved.
*
* $Id$
*/
package org.exolab.castor.xml.schema;
import org.exolab.castor.xml.Namespaces;
import org.exolab.castor.xml.ValidationException;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;
import java.util.Hashtable;
import java.util.Enumeration;
/**
* A class representing an XML Schema Definition. This class also
* contains some Factory methods for creating Top-Level structures.
*
* @author <a href="mailto:kvisco@intalio.com">Keith Visco</a>
* @version $Revision$ $Date: 2006-04-26 13:58:52 -0600 (Wed, 26 Apr 2006) $
*/
public class Schema extends Annotated {
/** SerialVersionUID */
private static final long serialVersionUID = -8130246250710502508L;
//-----------------------------/
//- Class Fields / Constants -/
//-----------------------------/
/*
// Old schema namespaces, left here for
// reference
April 2000 Working Draft Namespace
= "http://www.w3.org/1999/XMLSchema";
October 2000 Candidate Release Namespace
= "http://www.w3.org/2000/10/XMLSchema";
*/
/**
* The Namespace supported by the W3C XML Schema
* Recommendation.
*/
public static final String DEFAULT_SCHEMA_NS
= "http://www.w3.org/2001/XMLSchema";
/**
* The Namespace supported by the W3C XML Schema
* Recommendation for the built-in types:
* xsi:type, xsi:nil, and xsi:schemaLocation.
*/
public static final String XSI_NAMESPACE
= "http://www.w3.org/2001/XMLSchema-instance";
/**
* Null argument error message
*/
private static final String NULL_ARGUMENT
= "A null argument was passed to " +
Schema.class.getName() + "#";
/**
* The SimpleTypesFactory used by this Schema
*/
private static SimpleTypesFactory simpleTypesFactory
= new SimpleTypesFactory();
//--------------------/
//- Member Variables -/
//--------------------/
/**
* The attributeFormDefault property
**/
private Form _attributeFormDefault = null;
/**
* The global AttribteGroups for this Schema
**/
private Map<String, AttributeGroup> _attributeGroups = new Hashtable<String, AttributeGroup>();
/**
* The global attributes for this Schema
**/
private Map<String, AttributeDecl> _attributes = new Hashtable<String, AttributeDecl>();
/**
* The value of the block attribute.
**/
private BlockList _block = null;
/**
* A list of defined architypes
**/
private Map<String, ComplexType> _complexTypes = new Hashtable<String, ComplexType>();
/**
* The elementFormDefault attribute for this Schema
**/
private Form _elementFormDefault = null;
/**
* A list of defined elements
**/
private Map<String, ElementDecl> _elements = new Hashtable<String, ElementDecl>();
/**
* The value of the final attribute.
**/
private FinalList _final = null;
/**
* A list of defined top-levels groups
*/
private Map<String, ModelGroup> _groups = new Hashtable<String, ModelGroup>();
/**
* A list of defined <redefine>
*/
private Map<String, RedefineSchema> _redefineSchemas = new Hashtable<String, RedefineSchema>();
/**
* The ID for this Schema
**/
private String _id = null;
/**
* A list of imported schemas
**/
private Map<String, Schema> _importedSchemas = new Hashtable<String, Schema>();
/**
* A list of included schemas meant to be used only
* when the cache mechanism is enabled.
**/
private Map<String, Schema> _cachedincludedSchemas = new Hashtable<String, Schema>();
/**
* A list of XML Schema files included in this schema
**/
private Vector<String> _includedSchemas = new Vector<String>();
/**
* A list of namespaces declared in this schema
*/
private Namespaces _namespaces = new Namespaces();
/**
* The schemaLocation hint provided in the 'import' tag.
* By default the schemaLocation is the locator of the SaxUnmarshaller
**/
private String _schemaLocation = null;
/**
* The namespace of this XML Schema (ie the namespace
* of the W3C Schema supported by this Schema).
**/
private String _schemaNamespace = null;
/**
* A list of defined SimpleTypes
**/
private Hashtable<String, SimpleType> _simpleTypes = new Hashtable<String, SimpleType>();
/**
* The targetNamespace for this Schema
**/
private String _targetNamespace = null;
/**
* The version information as specified by the version
* attribute
**/
private String _version = null;
/**
* A reference to the master schema used when this
* instance of Schema is used in another schema
* (redefine, include or import)
*/
private Schema _masterSchema = null;
//----------------/
//- Constructors -/
//----------------/
/**
* Creates a new Schema definition
*/
public Schema() {
this(null, DEFAULT_SCHEMA_NS);
}
/**
* Creates a new Schema definition
*
* @param schemaNS the namespace of the XML Schema itself. Note
* this is not the same as the targetNamespace.
*/
public Schema(String schemaNS) {
this(null, schemaNS);
}
/**
* Creates a new Schema definition
*
* @param prefix the desired namespace prefix for the schemaNS.
* @param schemaNamespace the namespace of the XML Schema itself. Note
* this is not the same as the targetNamespace.
*/
public Schema(String prefix, String schemaNamespace) {
super();
if (schemaNamespace == null) {
_schemaNamespace = DEFAULT_SCHEMA_NS;
} else {
_schemaNamespace = schemaNamespace;
}
//-- declare default namespace bindings
if (prefix == null) {
prefix = "";
}
addNamespace(prefix, _schemaNamespace);
}
/**
* Adds the given attribute definition to this Schema definition
*
* @param attribute the AttributeDecl to add
* @sexception SchemaException if an AttributeDecl
* already exisits with the same name
**/
public void addAttribute(AttributeDecl attribute)
throws SchemaException
{
if (attribute == null) return;
String name = attribute.getName();
if (attribute.getSchema() != this) {
String err = "invalid attempt to add an AttributeDecl which ";
err += "belongs to a different Schema; " + name;
throw new SchemaException(err);
}
if ( (name == null) && (attribute.isReference()) ) {
String err = "Error attempting to add a top-level AttributeDecl that " +
"is a reference. Top-level attributes can only be attribute declarations: " +
attribute.getName(false);
throw new SchemaException(err);
}
//-- we check if the attribute is not already present in the schema
//-- the attribute can be already added
//-- the attribute can be part of a schema redefinition
//-- the attribute can be part of a cached included schema
Object obj = getAttribute(name);
if (obj == attribute) return;
if (obj != null) {
String err = "Error attempting to add an AttributeDecl to this " +
"Schema definition, an AttributeDecl already exists with " +
"the given name: ";
throw new SchemaException(err + name);
}
_attributes.put(name, attribute);
//--set the parent
attribute.setParent(this);
} //-- addAttribute
/**
* Adds the given attribute group definition to this Schema
* definition.
*
* @param attrGroup the AttributeGroupDecl to add
* @exception SchemaException if an AttributeGroupDecl
* already exisits with the same name
**/
public void addAttributeGroup(AttributeGroupDecl attrGroup)
throws SchemaException
{
if (attrGroup == null) return;
String name = attrGroup.getName();
//-- handle namespace prefix, if necessary
int idx = name.indexOf(':');
if (idx >= 0)
{
String nsPrefix = name.substring(0,idx);
name = name.substring(idx + 1);
String ns = _namespaces.getNamespaceURI(nsPrefix);
if (ns == null) {
String err = "addAttributeGroup: ";
err += "Namespace prefix not recognized '"+nsPrefix+"'";
throw new IllegalArgumentException(err);
}
if (!ns.equals(_targetNamespace)) {
String err = "AttributeGroup has different namespace " +
"than this Schema definition.";
throw new IllegalArgumentException(err);
}
}
if (attrGroup.getSchema() != this) {
String err = "invalid attempt to add an AttributeGroup which ";
err += "belongs to a different Schema; " + name;
throw new SchemaException(err);
}
Object obj = getAttributeGroup(name);
if (obj == attrGroup) return;
boolean redefine = attrGroup.isRedefined();
if (obj != null && !redefine) {
String err = "Error attempting to add an AttributeGroup to this " +
"Schema definition, an AttributeGroup already exists with " +
"the given name: ";
throw new SchemaException(err + name);
}
_attributeGroups.put(name, attrGroup);
} //-- addAttributeGroup
/**
* Adds the given Complextype definition to this Schema defintion
* @param complexType the Complextype to add to this Schema
* @exception SchemaException if the Complextype does not have
* a name or if another Complextype already exists with the same name
**/
public synchronized void addComplexType(ComplexType complexType)
throws SchemaException
{
String name = complexType.getName();
if (name == null) {
String err = "a global ComplexType must contain a name.";
throw new SchemaException(err);
}
if (complexType.getSchema() != this) {
String err = "invalid attempt to add an ComplexType which ";
err += "belongs to a different Schema; type name: " + name;
throw new SchemaException(err);
}
//-- we check if the complexType is not already present in the schema
//-- the complexType can be already added
//-- the complexType can be part of a schema redefinition
//-- the complexType can be part of a cached included schema
if (getComplexType(name) != null && !complexType.isRedefined()) {
String err = "a ComplexType already exists with the given name: ";
throw new SchemaException(err + name);
}
_complexTypes.put(name, complexType);
complexType.setParent(this);
} //-- addComplextype
/**
* Adds the given Element declaration to this Schema defintion
* @param elementDecl the ElementDecl to add to this SchemaDef
* @exception SchemaException when an ElementDecl already
* exists with the same name as the given ElementDecl
**/
public void addElementDecl(ElementDecl elementDecl)
throws SchemaException
{
String name = elementDecl.getName(true);
if ( (name == null) && (elementDecl.isReference()) ) {
String err = "Error attempting to add a top-level Element that " +
"is a reference. Top-level elements can only be element declarations: " +
elementDecl.getName(false);
throw new SchemaException(err);
}
if (name == null) {
String err = "an element declaration must contain a name.";
throw new SchemaException(err);
}
if (getElementDecl(name) != null) {
String err = "an element declaration already exists with the given name: ";
throw new SchemaException(err + name);
}
_elements.put(name, elementDecl);
elementDecl.setParent(this);
} //-- addElementDecl
/**
* Adds the given Group declaration to this Schema definition
* @param group the Group to add to this SchemaDef
* @exception SchemaException when an Group already
* exists with the same name as the given Group
**/
public void addModelGroup(ModelGroup group)
throws SchemaException
{
String name = group.getName();
if (name == null) {
String err = "a group declaration must contain a name.";
throw new SchemaException(err);
}
if (getModelGroup(name) != null && !group.isRedefined()) {
String err = "a group declaration already exists with the given name: ";
throw new SchemaException(err + name);
}
_groups.put(name, group);
group.setParent(this);
} //-- addModelGroup
/**
* Adds the given redefinition of structures to this Schema definition.
* This structure is mainly used to allow the writing of an XML schema that
* contains redefinitions. The validation process is permissive since the method
* won't check that the XML Schema is already imported nor will it check that the
* redefined structures exist.
*
* @param schema the Group to add to this SchemaDef
* @exception SchemaException when an redefintion already
* exists with the same name as the given ElementDecl
**/
public void addRedefineSchema(RedefineSchema schema) throws SchemaException
{
String uri = schema.getSchemaLocation();
if ( (uri == null) && (schema.hasRedefinition()) ) {
String err = "A <redefine> structure with no 'schemaLocation' attribute must contain only <annotation> elements";
throw new SchemaException(err);
}
if (_redefineSchemas.get(uri) != null) {
String err = "The redefinition for schema:"+ uri +" can only be used once.";
throw new SchemaException(err);
}
_redefineSchemas.put(uri, schema);
} //-- addModelGroup
/**
* Adds the given Schema definition to this Schema definition as an imported schenma
* @param schema the Schema to add to this Schema as an imported schema
* @exception SchemaException if the Schema already exists
*/
public synchronized void addImportedSchema(Schema schema)
throws SchemaException
{
String targetNamespace = schema.getTargetNamespace();
if (targetNamespace == null) targetNamespace = "";
if (_importedSchemas.get(targetNamespace)!=null)
{
String err = "a Schema has already been imported with the given namespace: ";
throw new SchemaException(err + targetNamespace);
}
_importedSchemas.put(targetNamespace, schema);
} //-- addImportedSchema
/**
* Caches the given Schema definition as an included XML Schema of this
* Schema definition.
*
* @param schema the Schema to add to this Schema as a cached included schema.
* @exception SchemaException if the Schema already exists
*/
public synchronized void cacheIncludedSchema(Schema schema)
throws SchemaException
{
String schemaLocation = schema.getSchemaLocation();
if (schemaLocation == null) schemaLocation= "";
if (_cachedincludedSchemas.get(schemaLocation)!=null)
{
String err = "a Schema has already been included with the given schemaLocation: ";
throw new SchemaException(err + schemaLocation);
}
_cachedincludedSchemas.put(schemaLocation, schema);
} //-- addImportedSchema
/**
* Adds to the namespaces declared in this Schema
*/
public void addNamespace(String prefix, String ns) {
_namespaces.addNamespace(prefix, ns);
} //-- setNamespaces
/**
* Adds the given SimpletType definition to this Schema defintion
* @param simpleType the SimpleType to add to this Schema
* @exception SchemaException if the SimpleType does not have
* a name or if another SimpleType already exists with the same name
**/
public synchronized void addSimpleType(SimpleType simpleType)
throws SchemaException
{
String name = simpleType.getName();
if ((name == null) || (name.length() == 0)) {
String err = "No name found for top-level SimpleType. " +
" A top-level SimpleType must have a name.";
throw new SchemaException(err);
}
if (simpleType.getSchema() != this) {
String err = "invalid attempt to add a SimpleType which ";
err += "belongs to a different Schema; type name: " + name;
throw new SchemaException(err);
}
if (getSimpleType(name, _targetNamespace) != null && !simpleType.isRedefined()) {
String err = "a SimpleType already exists with the given name: ";
throw new SchemaException(err + name);
}
simpleType.setParent(this);
_simpleTypes.put(name, simpleType);
} //-- addSimpleType
/**
* Creates a new ComplexType using this Schema as the owning Schema
* document. A call to #addComplexType must still be made in order
* to add the complexType to this Schema.
* @return the new ComplexType
**/
public ComplexType createComplexType() {
return new ComplexType(this);
} //-- createComplexType
/**
* Creates a new ComplexType using this Schema as the owning Schema
* document. A call to #addComplexType must still be made in order
* to add the complexType to this Schema.
* @param name the name of the ComplexType
* @return the new ComplexType
**/
public ComplexType createComplexType(String name) {
return new ComplexType(this, name);
} //-- createComplexType
/**
* Creates a new SimpleType using this Schema as the owning Schema
* document. A call to #addSimpleType must till be made in order
* to add the SimpleType to this Schema.
* @param name the name of the SimpleType
* @param baseName the name of the SimpleType's base type
* @param derivation the name of the derivation method (""/"list"/"restriction")
* @return the new SimpleType.
**/
public SimpleType createSimpleType(String name, String baseName, String derivation)
{
return simpleTypesFactory.createUserSimpleType(this, name, baseName, derivation, true);
} //-- createSimpleType
/**
* Creates a new SimpleType using this Schema as the owning Schema
* document. A call to #addSimpleType must till be made in order
* to add the SimpleType to this Schema if the type is to be global.
* @param name the name of the SimpleType
* @param baseType the base type of the SimpleType to create
* @return the new SimpleType.
**/
public SimpleType createSimpleType(String name, SimpleType baseType)
{
return simpleTypesFactory.createUserSimpleType(this, name, baseType, "restriction");
} //-- createSimpleType
/**
* Returns the attributeFormDefault property of this Schema.
*
* @return the attributeFormDefault property of this Schema, or null
* if no default Form was set. If no default Form has been set, the
* user should assume Form.Unqualified.
**/
public Form getAttributeFormDefault() {
return _attributeFormDefault;
} //-- getAttributeFormDefault
/**
* Returns an Enumeration of all top-level Attribute declarations
* @return an Enumeration of all top-level Attribute declarations
**/
public Collection<AttributeDecl> getAttributes() {
Vector<AttributeDecl> result = new Vector<AttributeDecl>(_attributes.size()*2);
result.addAll(_attributes.values());
Collection<Schema> cachedincluded = _cachedincludedSchemas.values();
for (Schema includedSchema : cachedincluded) {
Collection<AttributeDecl> tempAtt = includedSchema.getAttributes();
for (AttributeDecl attributeDecl : tempAtt) {
result.add(attributeDecl);
}
}
Collection<RedefineSchema> redefinition = _redefineSchemas.values();
for (RedefineSchema redefineSchema : redefinition) {
Schema tempSchema = redefineSchema.getOriginalSchema();
//-- a redefinition doesn't always contain a schema
if (tempSchema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- an structure and its type.
tempSchema.setMasterSchema(this);
Collection<AttributeDecl> tempAtt = tempSchema.getAttributes();
for (AttributeDecl attributeDecl : tempAtt) {
result.add(attributeDecl);
}
}
}
return result;
}
/**
* Returns the top-level Attribute associated with the given name.
*
* @return the Attribute associated with the given name,
* or null if no Attribute association is found.
**/
public AttributeDecl getAttribute(String name) {
//-- Null?
if (name == null) {
String err = NULL_ARGUMENT + "getAttribute: ";
err += "'name' cannot be null.";
throw new IllegalArgumentException(err);
}
//-- Namespace prefix?
String canonicalName = name;
String nsprefix = "";
String ns = _targetNamespace;
int colon = name.indexOf(':');
if (colon != -1)
{
canonicalName = name.substring(colon + 1);
nsprefix = name.substring(0,colon);
ns = _namespaces.getNamespaceURI(nsprefix);
if (ns == null) {
String err = "getAttribute: ";
err += "Namespace prefix not recognized '"+name+"'";
throw new IllegalArgumentException(err);
}
}
if ((ns==null) || (ns.equals(_targetNamespace)) ) {
AttributeDecl tempAtt = _attributes.get(canonicalName);
if (tempAtt == null) {
Collection<Schema> cacheIncluded = _cachedincludedSchemas.values();
boolean found = false;
for (Schema includedSchema : cacheIncluded) {
tempAtt = includedSchema.getAttribute(canonicalName);
if (tempAtt != null) {
found = true;
break;
}
}
// boolean found = false;
// while (cacheIncluded.hasMoreElements() && !found) {
// Schema temp = cacheIncluded.nextElement();
// tempAtt = temp.getAttribute(canonicalName);
// if (tempAtt != null)
// found = true;
// }
//--look in the redefinition
if (!found) {
Iterator<RedefineSchema> redefinition = _redefineSchemas.values().iterator();
while (redefinition.hasNext() && !found) {
Schema tempSchema = redefinition.next().getOriginalSchema();
if (tempSchema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- an structure and its type.
tempSchema.setMasterSchema(this);
tempAtt = tempSchema.getAttribute(canonicalName);
if (tempAtt != null)
found = true;
}
}
}
}
return tempAtt;
}
Schema schema = getImportedSchema(ns);
if (schema!=null) {
AttributeDecl att = schema.getAttribute(canonicalName);
return att;
}
return null;
} //-- getAttribute
/**
* Returns an Enumeration of all top-level AttributeGroup declarations
* @return an Enumeration of all top-level AttributeGroup declarations
**/
public Collection<AttributeGroup> getAttributeGroups() {
Vector<AttributeGroup> result = new Vector<AttributeGroup>(_attributeGroups.size()*2);
result.addAll(_attributeGroups.values());
Collection<Schema> cachedincluded = _cachedincludedSchemas.values();
for (Schema includedSchema : cachedincluded) {
Collection<AttributeGroup> tempAtt = includedSchema.getAttributeGroups();
for (AttributeGroup attributeGroup : tempAtt) {
result.add(attributeGroup);
}
}
Collection<RedefineSchema> redefinition = _redefineSchemas.values();
for (RedefineSchema redefineSchema : redefinition) {
//1-- Add the AttributeGroups from the RedefineSchema
for (AttributeGroup attributeGroup : redefineSchema.enumerateAttributeGroups()) {
result.add(attributeGroup);
}
//2-- Add the AttributeGroups from the Original Schema of the
//-- RedefineSchema Structure by making sure that the AttributeGroups
//-- are not redefined.
Schema tempSchema = redefineSchema.getOriginalSchema();
//-- a redefinition doesn't always contain a schema
if (tempSchema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- a structure and its type.
tempSchema.setMasterSchema(this);
for (AttributeGroup attributeGroup : tempSchema.getAttributeGroups()) {
boolean alreadyRedefined = true;
if (attributeGroup instanceof AttributeGroupDecl) {
alreadyRedefined = redefineSchema.hasAttributeGroupRedefinition(((AttributeGroupDecl)attributeGroup).getName());
}
if (!alreadyRedefined) {
result.add(attributeGroup);
}
}
}
}
return result;
} //-- getAttributeGroups
/**
* Returns the AttributeGroup associated with the given name.
*
* @return the AttributeGroup associated with the given name,
* or null if no AttributeGroup association is found.
**/
public AttributeGroup getAttributeGroup(String name) {
//-- Null?
if (name == null) {
String err = NULL_ARGUMENT + "getAttributeGroup: ";
err += "'name' cannot be null.";
throw new IllegalArgumentException(err);
}
AttributeGroup result = null;
//-- Namespace prefix?
String canonicalName = name;
String nsprefix = "";
String ns = _targetNamespace;
int colon = name.indexOf(':');
if (colon != -1)
{
canonicalName = name.substring(colon + 1);
nsprefix = name.substring(0,colon);
ns = _namespaces.getNamespaceURI(nsprefix);
if (ns == null) {
String err = "getAttributeGroup: ";
err += "Namespace prefix not recognized '"+name+"'";
throw new IllegalArgumentException(err);
}
}
if ((ns==null) || (ns.equals(_targetNamespace)) ) {
result = _attributeGroups.get(canonicalName);
if (result == null) {
Iterator<Schema> cacheIncluded = _cachedincludedSchemas.values().iterator();
boolean found = false;
while (cacheIncluded.hasNext() && !found) {
Schema temp = cacheIncluded.next();
result = temp.getAttributeGroup(canonicalName);
if (result != null) {
found = true;
}
}
//--we look in the redefinitions
if (!found) {
//-- Search through the redefinition:
Iterator<RedefineSchema> redefinitions = getRedefineSchema().iterator();
while (redefinitions.hasNext() && !found) {
RedefineSchema redefine = redefinitions.next();
//-- the AttributeGroup can be redefined
if (redefine.hasAttributeGroupRedefinition(canonicalName)) {
result = redefine.getAttributeGroup(canonicalName);
if (result != null)
found = true;
break;
}
//-- or if can be part of the Original Schema of the Redefined structures.
Schema schema = redefine.getOriginalSchema();
if (schema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- an structure and its type.
schema.setMasterSchema(this);
result = schema.getAttributeGroup(name);
}
}
}//--end of redefinition
}//--result == null
}
else {
Schema schema = getImportedSchema(ns);
if (schema!=null)
result = schema.getAttributeGroup(canonicalName);
}
return result;
} //-- getAttributeGroup
/**
* Returns the default BlockList for this Schema.
*
* @return the default BlockList for this Schema.
**/
public BlockList getBlockDefault() {
return _block;
} //-- getBlockDefault
/**
* Gets a built in type's name given its code.
*/
public String getBuiltInTypeName(int builtInTypeCode) {
return simpleTypesFactory.getBuiltInTypeName(builtInTypeCode);
} //-- getBuiltInTypeName
/**
* Returns the ComplexType of associated with the given name
* @return the ComplexType of associated with the given name, or
* null if no ComplexType with the given name was found.
**/
public ComplexType getComplexType(String name) {
//-- Null?
if (name == null) {
String err = NULL_ARGUMENT + "getComplexType: ";
err += "'name' cannot be null.";
throw new IllegalArgumentException(err);
}
ComplexType result = null;
//-- Namespace prefix?
String canonicalName = name;
String nsprefix = "";
String ns = _targetNamespace;
int colon = name.indexOf(':');
if (colon != -1)
{
canonicalName = name.substring(colon + 1);
nsprefix = name.substring(0,colon);
ns = _namespaces.getNamespaceURI(nsprefix);
if (ns == null) {
String err = "getComplexType: ";
err += "Namespace prefix not recognized '"+name+"'";
throw new IllegalArgumentException(err);
}
}
//-- Get GetComplexType object
if ((ns==null) || (ns.equals(_targetNamespace)) ) {
result = _complexTypes.get(canonicalName);
if (result == null) {
boolean found = false;
//-- check for any included schemas that are cached
Iterator<Schema> cacheIncluded = _cachedincludedSchemas.values().iterator();
while (cacheIncluded.hasNext() && !found) {
Schema temp = cacheIncluded.next();
result = temp.getComplexType(canonicalName);
if (result != null)
found = true;
}
if (!found) {
//--we might face a redefinition
Iterator<RedefineSchema> redefinitions = getRedefineSchema().iterator();
while (redefinitions.hasNext() && result == null) {
RedefineSchema redefine = redefinitions.next();
//-- the ComplexType can be redefined
if (redefine.hasComplexTypeRedefinition(canonicalName)) {
result = redefine.getComplexType(canonicalName);
if (result != null)
found = true;
break;
}
Schema schema = redefine.getOriginalSchema();
if (schema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- an structure and its type.
schema.setMasterSchema(this);
result = schema.getComplexType(canonicalName);
}
}
}
}
}
else {
Schema schema = getImportedSchema(ns);
if (schema!=null) {
result = schema.getComplexType(canonicalName);
}
}
return result;
} //-- getComplexType
/**
* Returns an Enumeration of all top-level ComplexType declarations
* @return an Enumeration of all top-level ComplexType declarations
**/
public Collection<ComplexType> getComplexTypes() {
Vector<ComplexType> result = new Vector<ComplexType>(_complexTypes.size()*2);
result.addAll(_complexTypes.values());
Collection<Schema> cachedincluded = _cachedincludedSchemas.values();
for (Schema includedSchema : cachedincluded) {
Collection<ComplexType> tempEnum = includedSchema.getComplexTypes();
for (ComplexType complexType : tempEnum) {
result.add(complexType);
}
}
Collection<RedefineSchema> redefinition = _redefineSchemas.values();
for (RedefineSchema redefineSchema : redefinition) {
//1-- Add the ComplexType from the RedefineSchema
for (ComplexType complexType : redefineSchema.enumerateComplexTypes()) {
result.add(complexType);
}
Schema tempSchema = redefineSchema.getOriginalSchema();
//-- a redefinition doesn't always contain a schema
if (tempSchema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- an structure and its type.
tempSchema.setMasterSchema(this);
Iterator<ComplexType> tempEnum = tempSchema.getComplexTypes().iterator();
while (tempEnum.hasNext()) {
ComplexType tempType = tempEnum.next();
if (!redefineSchema.hasComplexTypeRedefinition(tempType.getName()))
result.add(tempType);
}
}
}
return result;
} //-- getComplextypes
/**
* Returns the ElementDecl of associated with the given name
* @return the ElementDecl of associated with the given name, or
* null if no ElementDecl with the given name was found.
**/
public ElementDecl getElementDecl(String name) {
String ns = null;
if (name == null) {
String err = NULL_ARGUMENT + "getElementDecl: ";
err += " 'name' can not be null";
throw new IllegalArgumentException(err);
}
ElementDecl result = null;
int idx = name.indexOf(':');
if (idx >= 0)
{
String nsPrefix = name.substring(0,idx);
name = name.substring(idx + 1);
ns = _namespaces.getNamespaceURI(nsPrefix);
if (ns == null) {
String err = "getElementDecl: ";
err += "Namespace prefix not recognized '"+nsPrefix+"'";
throw new IllegalArgumentException(err);
}
}
if ((ns==null) || (ns.equals(_targetNamespace)) ) {
result = _elements.get(name);
if (result == null) {
//-- check for any included schemas that are cached
Iterator<Schema> cacheIncluded = _cachedincludedSchemas.values().iterator();
boolean found = false;
while (cacheIncluded.hasNext() && !found) {
Schema temp = cacheIncluded.next();
result = temp.getElementDecl(name);
if (result != null)
found = true;
}
//--look in the redefinition
if (!found) {
Iterator<RedefineSchema> redefinition = _redefineSchemas.values().iterator();
while (redefinition.hasNext() && !found) {
Schema schema = redefinition.next().getOriginalSchema();
if (schema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- an structure and its type.
schema.setMasterSchema(this);
result = schema.getElementDecl(name);
if (result != null)
found = true;
}
}
}
}
}
else {
Schema schema = getImportedSchema(ns);
if (schema!=null) {
result = schema.getElementDecl(name);
}
}
return result;
} //--getElementDecl
/**
* Returns an Enumeration of all top-level element declarations
* @return an Enumeration of all top-level element declarations
**/
public Collection<ElementDecl> getElementDecls() {
Vector<ElementDecl> result = new Vector<ElementDecl>(_elements.size()*2);
result.addAll(_elements.values());
Collection<Schema> cachedincluded = _cachedincludedSchemas.values();
for (Schema includedSchema : cachedincluded) {
Collection<ElementDecl> tempEnum = includedSchema.getElementDecls();
for (ElementDecl elementDecl : tempEnum) {
result.add(elementDecl);
}
}
Collection<RedefineSchema> redefinition = _redefineSchemas.values();
for (RedefineSchema redefineSchema : redefinition) {
Schema tempSchema = redefineSchema.getOriginalSchema();
//-- a redefinition doesn't always contain a schema
if (tempSchema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- an structure and its type.
tempSchema.setMasterSchema(this);
Collection<ElementDecl> redefinedElementDeclarations = tempSchema.getElementDecls();
for (ElementDecl elementDecl : redefinedElementDeclarations) {
result.add(elementDecl);
}
}
}
return result;
} //-- getElementDecls
/**
* Returns the elementFormDefault property of this Schema.
*
* @return the elementFormDefault property of this Schema, or null
* if no default Form was set. If no default Form has been set, the
* user should assume Form.Unqualified.
**/
public Form getElementFormDefault() {
return _elementFormDefault;
} //-- getElementFormDefault
/**
* Returns the default FinalList for this Schema.
*
* @return final the default FinalList for this Schema.
**/
public FinalList getFinalDefault() {
return _final;
} //-- getFinalDefault
/**
* Returns the SimpleType associated with the given name,
* or null if no such SimpleType exists.
*
* @param name the name of the SimpleType. The name may
* be a QName (contain a namespace prefix).
* @return the SimpleType associated with the given name,
* or null if no such SimpleType exists.
**/
public SimpleType getSimpleType(String name) {
//-- name must not be null
if (name == null) {
String err = NULL_ARGUMENT + "getSimpleType: ";
err += "'name' cannot be null.";
throw new IllegalArgumentException(err);
}
//-- Handle namespace resolution?
String nsPrefix = "";
String ns = null;
int colon = name.indexOf(':');
if (colon >= 0) {
nsPrefix = name.substring(0,colon);
name = name.substring(colon + 1);
ns = _namespaces.getNamespaceURI(nsPrefix);
if (ns == null) {
String err = "getSimpleType: ";
err += "Namespace prefix not recognised '"+nsPrefix+"'";
err += "for simpleType:"+name;
throw new IllegalArgumentException(err);
}
}
else {
ns = _namespaces.getNamespaceURI(nsPrefix);
}
//--if at this point, there is no namespace
//--then we assume it is the targetNamespace
if (ns == null)
ns = _targetNamespace;
return getSimpleType(name, ns);
} //-- getSimpleType
/**
* Returns the SimpleType associated with the given name
* and namespace, or null if no such SimpleType exists.
*
* @param name the name of the simpleType. It is an error
* if this name contains a prefix, it must be an NCName.
* @param namespace the namespace URI of the simpleType.
* @return the SimpleType, or null if no such SimpleType exists.
**/
public SimpleType getSimpleType(String name, String namespace) {
//-- name must not be null
if (name == null) {
String err = NULL_ARGUMENT + "getSimpleType: ";
err += "'name' cannot be null.";
throw new IllegalArgumentException(err);
}
//--Is the declaration in the default namespace (if any)
boolean isDefaultNS = false;
if (namespace == null) {
namespace = _namespaces.getNamespaceURI("");
isDefaultNS = true;
}
//-- Get SimpleType object
SimpleType result = null;
if ((namespace == null) || (isDefaultNS)) {
//-- first check user-defined types
result = _simpleTypes.get(name);
if (result != null) {
//-- resolve deferred type if necessary
if (result.getType() != result) {
//-- can result.getType ever return null?
//-- We can check, just in case.
if (result.getType() != null) {
result = (SimpleType)result.getType();
result.setParent(this);
_simpleTypes.put(name, result);
}
}
}
//-- otherwise try built-in types
else {
result= simpleTypesFactory.getBuiltInType(name);
//if we have a built-in type not declared in the good namespace -> Exception
if ( (result != null) && (!_schemaNamespace.equals(namespace))) {
String err = "getSimpleType: the simple type '"+name+
"' has not been declared in XML Schema namespace.";
throw new IllegalArgumentException(err);
}
}
}
else if (namespace.equals(_schemaNamespace)) {
result= simpleTypesFactory.getBuiltInType(name);
if (result == null) {
String err = "getSimpleType: the simple type '"+name+
"' is not a built-in type as defined in XML Schema specification.";
throw new IllegalArgumentException(err);
}
}
else if (namespace.equals(_targetNamespace)) {
result = _simpleTypes.get(name);
if (result != null) {
//-- resolve deferred type if necessary
if (result.getType() != result) {
//-- can result.getType ever return null?
//-- We can check, just in case.
if (result.getType() != null) {
result = (SimpleType)result.getType();
result.setParent(this);
_simpleTypes.put(name, result);
}
}
}
if (result == null) {
//-- check the cached included schema
Iterator<Schema> cacheIncluded = _cachedincludedSchemas.values().iterator();
boolean found = false;
while (cacheIncluded.hasNext() && !found) {
Schema temp = cacheIncluded.next();
result = temp.getSimpleType(name, namespace);
if (result != null)
found = true;
}
if (!found) {
//--we might face a redefinition
Iterator<RedefineSchema> redefinitions = getRedefineSchema().iterator();
while (redefinitions.hasNext() && result == null) {
RedefineSchema redefine = redefinitions.next();
//-- the SimpleType can be redefined
if (redefine.hasSimpleTypeRedefinition(name)) {
result = redefine.getSimpleType(name);
if (result != null)
found = true;
break;
}
Schema schema = redefine.getOriginalSchema();
if (schema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- an structure and its type.
schema.setMasterSchema(this);
result = schema.getSimpleType(name, namespace);
}
}
}
}
}
else {
Schema schema = getImportedSchema(namespace);
if (schema != null) {
result = schema.getSimpleType(name, namespace);
}
}
//-- Result could be a deferredSimpleType => getType will resolve it
if (result!=null)
result= (SimpleType)result.getType();
return result;
} //-- getSimpleType
/**
* Returns an Enumeration of all SimpleType declarations
* @return an Enumeration of all SimpleType declarations
**/
public Collection<SimpleType> getSimpleTypes() {
//-- clean up "deferred types" if necessary
Enumeration<SimpleType> enumeration = _simpleTypes.elements();
while(enumeration.hasMoreElements()) {
SimpleType type = enumeration.nextElement();
if (type != type.getType()) {
//-- resolve deferred type if necessary
if (type.getType() != null) {
String name = type.getName();
type = (SimpleType)type.getType();
type.setParent(this);
_simpleTypes.put(name, type);
}
}
}
Vector<SimpleType> result = new Vector<SimpleType>(_simpleTypes.size()*2);
result.addAll(_simpleTypes.values());
Collection<Schema> cachedincluded = _cachedincludedSchemas.values();
for (Schema includedSchema : cachedincluded) {
Collection<SimpleType> tempEnum = includedSchema.getSimpleTypes();
for (SimpleType simpleType : tempEnum) {
result.add(simpleType);
}
}
Collection<RedefineSchema> redefinition = _redefineSchemas.values();
for (RedefineSchema redefineSchema : redefinition) {
//1-- Add the SimpleType from the RedefineSchema
for (SimpleType simpleType : redefineSchema.enumerateSimpleTypes()) {
result.add(simpleType);
}
Schema tempSchema = redefineSchema.getOriginalSchema();
//-- a redefinition doesn't always contain a schema
if (tempSchema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- an structure and its type.
tempSchema.setMasterSchema(this);
Collection<SimpleType> tempEnum = tempSchema.getSimpleTypes();
for (SimpleType simpleType : tempEnum) {
if (!redefineSchema.hasSimpleTypeRedefinition(simpleType.getName())) {
result.add(simpleType);
}
}
}
}
return result;
} //-- getSimpleTypes
/**
* Returns the schemaLocation hint provided of this schema
* @return the schemaLocation hint provided of this schema
*/
public String getSchemaLocation() {
return _schemaLocation;
}
/**
* Returns the ModeGroup of associated with the given name
* @return the ModelGroup of associated with the given name, or
* null if no ModelGroup with the given name was found.
**/
public ModelGroup getModelGroup(String name) {
String ns = null;
if (name == null) {
String err = NULL_ARGUMENT + "getModelGroup: ";
err += " 'name' can not be null";
throw new IllegalArgumentException(err);
}
ModelGroup result = null;
int idx = name.indexOf(':');
if (idx >= 0)
{
String nsPrefix = name.substring(0,idx);
name = name.substring(idx + 1);
ns = _namespaces.getNamespaceURI(nsPrefix);
if (ns == null) {
String err = "getModelGroup: ";
err += "Namespace prefix not recognized '"+nsPrefix+"'";
throw new IllegalArgumentException(err);
}
}
if ((ns==null) || (ns.equals(_targetNamespace)) ) {
result = _groups.get(name);
if (result == null) {
//-- check for any included schemas that are cached
Iterator<Schema> cacheIncluded = _cachedincludedSchemas.values().iterator();
boolean found = false;
while (cacheIncluded.hasNext() && !found) {
Schema temp = cacheIncluded.next();
result = temp.getModelGroup(name);
if (result != null)
found = true;
}
if (!found) {
//--we might face a redefinition
Iterator<RedefineSchema> redefinitions = getRedefineSchema().iterator();
while (redefinitions.hasNext() && result == null) {
RedefineSchema redefine = redefinitions.next();
//-- the ModelGroup can be redefined
if (redefine.hasGroupRedefinition(name)) {
result = redefine.getModelGroup(name);
if (result != null)
found = true;
break;
}
Schema schema = redefine.getOriginalSchema();
if (schema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- an structure and its type.
schema.setMasterSchema(this);
result = schema.getModelGroup(name);
}
}
}
}
}
else {
Schema schema = getImportedSchema(ns);
if (schema!=null) {
result = schema.getModelGroup(name);
}
}
return result;
} //--getModelGroup
/**
* Returns an Enumeration of all top-level ModelGroup declarations
* @return an Enumeration of all top-level ModelGroup declarations
**/
public Collection<ModelGroup> getModelGroups() {
Vector<ModelGroup> result = new Vector<ModelGroup>(_groups.size()*2);
result.addAll(_groups.values());
Collection<Schema> cachedincluded = _cachedincludedSchemas.values();
for (Schema includedSchema : cachedincluded) {
Collection<ModelGroup> tempEnum = includedSchema.getModelGroups();
for (ModelGroup modelGroup : tempEnum) {
result.add(modelGroup);
}
}
Collection<RedefineSchema> redefinition = _redefineSchemas.values();
for (RedefineSchema redefineSchema : redefinition) {
//1-- Add the AttributeGroups from the RedefineSchema
for (ModelGroup modelGroup : redefineSchema.enumerateGroups()) {
result.add(modelGroup);
}
Schema tempSchema = redefineSchema.getOriginalSchema();
//-- a redefinition doesn't always contain a schema
if (tempSchema != null) {
//-- Sets the master schema
//-- The master schema will help resolving the links at runtime between
//-- an structure and its type.
tempSchema.setMasterSchema(this);
for (ModelGroup modelGroup : tempSchema.getModelGroups()) {
if (!redefineSchema.hasGroupRedefinition(modelGroup.getName()))
result.add(modelGroup);
}
}
}
return result;
} //-- getmodelGroup
/**
* Returns the Id for this Schema, as specified by the
* Id attribute, or null if no Id exists.
*
* @return the Id for this Scheam, or null if no Id exists
**/
public String getId() {
return _id;
} //-- getId
/**
* Returns the imported schemas of this schema
* @return the hashtable of the imported schemas
*/
public Collection<Schema> getImportedSchema() {
return _importedSchemas.values();
}
/**
* Returns the imported schema with the given namespace
*
* @param ns the namespace of the imported schema to return
* @return the imported schema
*/
public Schema getImportedSchema(String ns) {
return getImportedSchema(ns, null);
} //-- getImportedSchema
/**
* Returns an enumeration of redefined schemas.
* @return an enumeration of redefined schemas.
*/
public Collection<RedefineSchema> getRedefineSchema() {
return _redefineSchemas.values();
}
/**
* Returns the redefined schema corresponding schemaLocation.
* @param schemaLocation the string corresponding to the schemaLocation.
* @return the redefined schema corresponding schemaLocation.
*/
public RedefineSchema getRedefineSchema(String schemaLocation) {
RedefineSchema result = _redefineSchemas.get(schemaLocation);
return result;
}
/**
* Returns the cached included schema with the given SchemaLocation
*
* @param schemaLocation the schemaLocation value used as a key to store the
* cached included XML schema
* @return the cached included XML schema
*/
public Schema getCachedIncludedSchema(String schemaLocation) {
return _cachedincludedSchemas.get(schemaLocation);
} //-- getCachedIncludedSchema
/**
* Returns an enumeration of all the included schemas that are cached
* in this XML Schema Definition.
*
* @return an enumeration of all the included schemas that are cached
* in this XML Schema Definition.
*
*/
public Collection<Schema> getCachedIncludedSchemas() {
return _cachedincludedSchemas.values();
}
/**
* Returns the imported schema with the given namespace
*
* @param ns the namespace of the imported schema to return
* @param localOnly a boolean that indicates only local imports
* should be searched.
* @return the imported schema
*/
public Schema getImportedSchema(String ns, boolean localOnly) {
if (localOnly) {
return _importedSchemas.get(ns);
}
return getImportedSchema(ns, null);
} //-- getImportedSchema
/**
* Returns the imported schema with the given namespace
*
* @param ns the namespace of the imported schema to return
* @return the imported schema
*/
private Schema getImportedSchema(String ns, Schema caller) {
//-- Check for recursive calls
if (caller == this) {
return null;
}
//-- Associate caller if necessary
if (caller == null) {
caller = this;
}
Schema result = _importedSchemas.get(ns);
//--maybe we are the schema imported is at
//--a depth > 1
if (result == null) {
Iterator<Schema> schemas = _importedSchemas.values().iterator();
while (schemas.hasNext()) {
Schema temp = schemas.next();
result = temp.getImportedSchema(ns, caller);
if (result != null) {
break;
}
}
}
return result;
}
/**
* Returns the namespace associated with the given prefix.
*
* @return the namespace associated with the given prefix,
* or null if no associated namespace exists.
*/
public final String getNamespace(String prefix) {
if (prefix == null) prefix = "";
return _namespaces.getNamespaceURI(prefix);
} //-- getNamespace
/**
* Returns the namespaces declared for this Schema
*
* @return the namespaces declared for this Schema
*/
public Namespaces getNamespaces() {
return _namespaces;
} //-- getNamespaces
/**
* Indicates that the given XML Schema file has been processed via an <xs:include>
*/
public void addInclude(String include)
{
_includedSchemas.addElement(include);
} //-- addInclude
/**
* Returns True if the given XML Schema has already been included via <xs:include>
* @return True if the file specified has already been processed
*/
public boolean includeProcessed(String includeFile)
{
return _includedSchemas.contains(includeFile);
} //-- includeProcessed
/**
* Returns the namespace of the XML Schema
* <BR />
* Note: This is not the same as targetNamespace. This is
* the namespace of "XML Schema" itself and not the namespace of the
* schema that is represented by this object model
* (see #getTargetNamespace).
* @return the namespace of the XML Schema
*
**/
public String getSchemaNamespace() {
return _schemaNamespace;
} //-- getSchemaNamespace
/**
* Returns the target namespace for this Schema, or null if no
* namespace has been defined.
* @return the target namespace for this Schema, or null if no
* namespace has been defined
**/
public String getTargetNamespace() {
return this._targetNamespace;
} //-- getTargetNamespace
/**
* Returns the version information of the XML Schema definition
* represented by this Schema instance.
*
* @return the version information of the XML Schema
* definition, or null if no version information exists.
**/
public String getVersion() {
return _version;
} //-- getVersion
/**
* Returns True if the namespace is known to this schema
* @param namespaceURL the namespace URL
* @return True if the namespace was declared in the schema
*/
public boolean isKnownNamespace(String namespaceURL)
{
return (_namespaces.getNamespacePrefix(namespaceURL) != null);
}
/**
* Removes the given top level ComplexType from this Schema
* @param complexType the ComplexType to remove
* @return true if the complexType has been removed, or
* false if the complexType wasn't top level or
* didn't exist in this Schema
**/
public boolean removeComplexType(ComplexType complexType) {
boolean result = false;
if (complexType.isTopLevel()) {
if (_complexTypes.containsValue(complexType)) {
_complexTypes.remove(complexType.getName());
complexType.setParent(null);
result = true;
}
if (!result) {
//--check the cached included schemas
Iterator<Schema> cacheIncluded = _cachedincludedSchemas.values().iterator();
while (cacheIncluded.hasNext() && !result) {
Schema temp = cacheIncluded.next();
result = temp.removeComplexType(complexType);
}
//--Still false?
if (!result) {
//--check the redefinition
Iterator<RedefineSchema> redefinitions = getRedefineSchema().iterator();
while (redefinitions.hasNext() && !result) {
RedefineSchema redefine = redefinitions.next();
result = redefine.removeComplexType(complexType);
}
}
}
}
return result;
} //-- removeComplexType
/**
* Removes the given top level Element from this Schema
* @param element the ElementDecl to remove
* @return true if the ElementDecl has been removed, or
* false if the ElementDecl wasn't top level or
* didn't exist in this Schema
**/
public boolean removeElement(ElementDecl element) {
boolean result = false;
if (_elements.containsValue(element)) {
_elements.remove(element.getName());
result = true;
}
if (!result) {
//--check the cached included schemas
Iterator<Schema> cacheIncluded = _cachedincludedSchemas.values().iterator();
while (cacheIncluded.hasNext() && !result) {
Schema temp = cacheIncluded.next();
result = temp.removeElement(element);
}
}
return result;
} //-- removeElement
/**
* Removes the given top level Attribute from this Schema
* @param attribute the AttributeDecl to remove
* @return true if the AttributeDecl has been removed, or
* false if the AttributeDecl wasn't top level or
* didn't exist in this Schema
*/
public boolean removeAttribute(AttributeDecl attribute) {
boolean result = false;
if (_attributes.containsValue(attribute)) {
_attributes.remove(attribute.getName());
result = true;
}
if (result == false) {
//--check the cached included schemas
Iterator<Schema> cacheIncluded = _cachedincludedSchemas.values().iterator();
while (cacheIncluded.hasNext() && !result) {
Schema temp = cacheIncluded.next();
result = temp.removeAttribute(attribute);
}
}
return false;
} //-- removeAttribute
/**
* Removes the given top level ModelGroup definition from this Schema
* @param group the ModelGroup definition to remove
* @return true if the ModelGroup definition has been removed, or
* false if the ModelGroup definition wasn't top level or
* didn't exist in this Schema.
*/
public boolean removeGroup(ModelGroup group) {
boolean result = false;
if (_groups.containsValue(group)) {
_groups.remove(group.getName());
result = true;
}
if (!result) {
//--check the cached included schemas
Iterator<Schema> cacheIncluded = _cachedincludedSchemas.values().iterator();
while (cacheIncluded.hasNext() && !result) {
Schema temp = cacheIncluded.next();
result = temp.removeGroup(group);
}
if (!result) {
//--check the redefinition
Iterator<RedefineSchema> redefinitions = getRedefineSchema().iterator();
while (redefinitions.hasNext() && !result) {
RedefineSchema redefine = redefinitions.next();
result = redefine.removeGroup(group);
}
}
}
return result;
} //-- removeGroup
/**
* Removes the given AttributeGroup definition from this Schema
* @param group the AttributeGroup definition to remove
* @return true if the AttributeGroup definition has been removed.
*/
public boolean removeAttributeGroup(AttributeGroupDecl group) {
boolean result = false;
if (_attributeGroups.containsValue(group)) {
_attributeGroups.remove(group.getName());
result = true;
}
if (result == false) {
//--check the cached included schemas
Iterator<Schema> cacheIncluded = _cachedincludedSchemas.values().iterator();
while (cacheIncluded.hasNext() && !result) {
Schema temp = cacheIncluded.next();
result = temp.removeAttributeGroup(group);
}
if (!result) {
//--check the redefinition
Iterator<RedefineSchema> redefinitions = getRedefineSchema().iterator();
while (redefinitions.hasNext() && !result) {
RedefineSchema redefine = redefinitions.next();
result = redefine.removeAttributeGroup(group);
}
}
}
return result;
} //-- removeGroup
/**
* Removes the given cached included schema from this Schema definition's
* list of cached included schema.
*
* @param schema the Schema to remove from this Schema's redefinition list
*
* @return true if the Schema was removed, otherwise false
*/
public synchronized boolean removeCachedIncludedSchema(Schema schema)
{
if (schema == null) return false;
String schemaLocation = schema.getSchemaLocation();
Schema tmp = _cachedincludedSchemas.get(schemaLocation);
if (schema.equals(tmp)) {
_cachedincludedSchemas.remove(schemaLocation);
return true;
}
return false;
} //-- removeImportedSchema
/**
* Removes the given Schema definition from this Schema definition's
* list of imported schenma
*
* @param schema the Schema to remove from this Schema's import list
*
* @return true if the Schema was removed, otherwise false
*/
public synchronized boolean removeImportedSchema(Schema schema)
{
if (schema == null) return false;
String targetNamespace = schema.getTargetNamespace();
if (targetNamespace == null) targetNamespace = "";
Schema tmp = _importedSchemas.get(targetNamespace);
if (schema.equals(tmp)) {
_importedSchemas.remove(targetNamespace);
return true;
}
return false;
} //-- removeImportedSchema
/**
* Removes the namespace from the set of namespace declarations for
* this Schema definition.
*
* @param prefix the namespace prefix of the namespace to remove.
*/
public boolean removeNamespace(String prefix) {
if (prefix == null) prefix = "";
return _namespaces.removeNamespace(prefix);
} //-- removeNamespace
/**
* Removes the given redefined structure from this Schema definition's
* list of redefinitions.
*
* @param schema the Schema to remove from this Schema's redefinition list
*
* @return true if the Schema was removed, otherwise false
*/
public synchronized boolean removeRedefineSchema(RedefineSchema schema)
{
if (schema == null) return false;
String schemaLocation = schema.getSchemaLocation();
RedefineSchema tmp = _redefineSchemas.get(schemaLocation);
if (schema.equals(tmp)) {
_redefineSchemas.remove(schemaLocation);
return true;
}
return false;
} //-- removeRedefineSchema
/**
* Removes the given top level SimpleType from this Schema
* @param simpleType the SimpleType to remove
* @return true if the SimpleType has been removed, or
* false if the SimpleType wasn't top level or
* didn't exist in this Schema
**/
public boolean removeSimpleType(SimpleType simpleType) {
boolean result = false;
if (_simpleTypes.containsValue(simpleType)) {
_simpleTypes.remove(simpleType.getName());
result = true;
}
if (result == false) {
//--check the cached included schemas
Iterator<Schema> cacheIncluded = _cachedincludedSchemas.values().iterator();
while (cacheIncluded.hasNext() && !result) {
Schema temp = cacheIncluded.next();
result = temp.removeSimpleType(simpleType);
}
if (!result) {
//--check the redefinition
Iterator<RedefineSchema> redefinitions = getRedefineSchema().iterator();
while (redefinitions.hasNext() && !result) {
RedefineSchema redefine = redefinitions.next();
result = redefine.removeSimpleType(simpleType);
}
}
}
return result;
} //-- removeSimpleType
/**
* Sets the attributeFormDefault property of this Schema.
*
* @param attributeFormDefault the Form value of the attributeFormDefault
* property for this Schema.
**/
public void setAttributeFormDefault(Form attributeFormDefault) {
_attributeFormDefault = attributeFormDefault;
} //-- setAttributeFormDefault
/**
* Sets the default BlockList for this Schema.
*
* @param block the default BlockList to set for this Schema.
**/
public void setBlockDefault(BlockList block) {
_block = block;
} //-- setBlockDefault
/**
* Sets the default Block values for this Schema.
*
* @param block the default Block values to set for this Schema.
**/
public void setBlockDefault(String block) {
_block = new BlockList(block);
} //-- setBlockDefault
/**
* Sets the elementFormDefault property of this Schema.
*
* @param elementFormDefault the Form value of the elementFormDefault
* property for this Schema.
**/
public void setElementFormDefault(Form elementFormDefault) {
_elementFormDefault = elementFormDefault;
} //-- setElementFormDefault
/**
* Sets the default FinalList for this Schema.
*
* @param finalList the default FinalList to set for this Schema.
**/
public void setFinalDefault(FinalList finalList) {
_final = finalList;
} //-- setFinalDefault
/**
* Sets the default final values for this Schema.
*
* @param finalValues the default final values to set for this Schema.
**/
public void setFinalDefault(String finalValues) {
_final = new FinalList(finalValues);
} //-- setFinalDefault
/**
* Set the schemaLocation for this schema. This is useful
* when this schema has been imported by another schema
* @param schemaLocation the location hint for this Schema
*/
public void setSchemaLocation(String schemaLocation) {
_schemaLocation = schemaLocation;
}
/**
* Returns the first simple or complex type which name equals TypeName
*/
public XMLType getType(String typeName)
{
//-- Null?
if (typeName == null) {
String err = NULL_ARGUMENT + "Schema#getType: ";
err += "'name' cannot be null.";
throw new IllegalArgumentException(err);
}
XMLType result = null;
String localName = typeName;
String prefix = "";
String ns = null;
int colon = typeName.indexOf(':');
if (colon >= 0) {
localName = typeName.substring(colon + 1);
prefix = typeName.substring(0,colon);
ns = _namespaces.getNamespaceURI(prefix);
if (ns == null) {
String err = "Schema#getType: ";
err += "Namespace prefix not recognised '"+typeName+"'";
throw new IllegalArgumentException(err);
}
}
//-- use default namespace if necessary
if (ns == null) {
ns = _namespaces.getNamespaceURI(prefix);
}
//--if at this point, there is no namespace
//--then we assume it is the targetNamespace
if (ns == null) {
//--SHOULD WE THROW AN EXCEPTION?
ns = _targetNamespace;
}
//1--support for anyType
if (localName.equals(SchemaNames.ANYTYPE)) {
//--if 'anyType' in the default schema namespace-->type is anyType
if (ns.equals(DEFAULT_SCHEMA_NS)) {
result = new AnyType(this);
}
}//--anyType
IllegalArgumentException exception = null;
//2--look for a simpleType
if (result == null) {
try {
result= getSimpleType(localName, ns);
} catch (IllegalArgumentException iox) {
exception = iox;
}
}
//3--look for a complexType
if (result == null) {
try {
result = getComplexType(typeName);
} catch (IllegalArgumentException iox) {
exception = iox;
}
}
if ((result == null) && (exception != null))
throw exception;
return result;
}
/**
* Sets the Id for this Schema
*
* @param id the Id for this Schema
**/
public void setId(String id) {
this._id = id;
} //-- setId
/**
* Sets the target namespace for this Schema
* @param targetNamespace the target namespace for this Schema
* @see "§ 2.7 XML Schema Part 1: Structures"
**/
public void setTargetNamespace(String targetNamespace) {
if (targetNamespace != null) {
targetNamespace = targetNamespace.trim();
if (targetNamespace.length() == 0)
throw new IllegalStateException("an empty string is not a valid namespace.");
}
_targetNamespace = targetNamespace;
} //-- setTargetNamespace
/**
* Sets the version information for the XML Schema defintion
* represented by this Schema instance.
*
* @param version the version for this XML Schema defination.
**/
public void setVersion(String version) {
_version = version;
} //-- setVersion
/** Gets the type factory, package private */
static SimpleTypesFactory getTypeFactory() { return simpleTypesFactory; }
//-------------------------------/
//- Implementation of Structure -/
//-------------------------------/
/**
* Returns the type of this Schema Structure
* @return the type of this Schema Structure
**/
public short getStructureType() {
return Structure.SCHEMA;
} //-- getStructureType
/**
* Checks the validity of this {@link Schema} definition.
*
* @throws ValidationException when this {@link Schema} definition
* is invalid.
**/
public void validate() throws ValidationException {
//-- Note: This method needs to be completed.
//-- top-level complexTypes
for (ComplexType complexType : _complexTypes.values()) {
complexType.validate();
}
//-- top-level simpleTypes
for (SimpleType simpleType : _simpleTypes.values()) {
simpleType.validate();
}
//-- top-level elements
for (ElementDecl element : _elements.values()) {
element.validate();
}
//-- top-level attributes
for (AttributeDecl attribute : _attributes.values()) {
attribute.validate();
}
//-- top-level groups
for (ModelGroup group : _groups.values()) {
group.validate();
}
//-- top-level attribute groups
} //-- validate
//-- private methods:
/**
* Returns the namespace prefix associated with the
* given namespace. If more than one prefix has been
* associated, the first one found will be returned.
*
* @return the namespace prefix associaed with the
* given namespace.
**/
public String getNamespacePrefix(String namespace) {
return _namespaces.getNamespacePrefix(namespace);
}
/**
* Returns the master schema in which this instance of schema
* is used at runtime. This method is meant to be used at runtime.
*
* @return the master schema in which this instance of schema
* is used at runtime. This method is meant to be used at runtime.
*/
protected Schema getMasterSchema() {
return _masterSchema;
}
/**
* Sets the master schema in which this instance of schema
* is used at runtime. This method is meant to be used at runtime.
* A master schema is a schema in which this instance of Schema is
* included, redefined or imported.
*
* @param masterSchema the master schema in which this instance of schema
* is used at runtime. This method is meant to be used at runtime.
*/
protected void setMasterSchema(Schema masterSchema) {
_masterSchema = masterSchema;
}
} //-- Schema