org.apache.xerces.impl.xs.SchemaGrammar Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of xerces2-xsd11 Show documentation
Show all versions of xerces2-xsd11 Show documentation
A processor for parsing, validating, serializing and manipulating XML, written in Java
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.xerces.impl.xs;
import java.lang.ref.SoftReference;
import java.util.Vector;
import org.apache.xerces.impl.Constants;
import org.apache.xerces.impl.dv.SchemaDVFactory;
import org.apache.xerces.impl.dv.ValidatedInfo;
import org.apache.xerces.impl.dv.XSSimpleType;
import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl;
import org.apache.xerces.impl.xs.alternative.XSTypeAlternativeImpl;
import org.apache.xerces.impl.xs.identity.IdentityConstraint;
import org.apache.xerces.impl.xs.util.ObjectListImpl;
import org.apache.xerces.impl.xs.util.SimpleLocator;
import org.apache.xerces.impl.xs.util.StringListImpl;
import org.apache.xerces.impl.xs.util.XSNamedMap4Types;
import org.apache.xerces.impl.xs.util.XSNamedMapImpl;
import org.apache.xerces.impl.xs.util.XSObjectListImpl;
import org.apache.xerces.parsers.DOMParser;
import org.apache.xerces.parsers.SAXParser;
import org.apache.xerces.parsers.XML11Configuration;
import org.apache.xerces.util.SymbolHash;
import org.apache.xerces.util.SymbolTable;
import org.apache.xerces.xni.NamespaceContext;
import org.apache.xerces.xni.grammars.XMLGrammarDescription;
import org.apache.xerces.xni.grammars.XSGrammar;
import org.apache.xerces.xs.StringList;
import org.apache.xerces.xs.XSAnnotation;
import org.apache.xerces.xs.XSAttributeDeclaration;
import org.apache.xerces.xs.XSAttributeGroupDefinition;
import org.apache.xerces.xs.XSConstants;
import org.apache.xerces.xs.XSElementDeclaration;
import org.apache.xerces.xs.XSIDCDefinition;
import org.apache.xerces.xs.XSModel;
import org.apache.xerces.xs.XSModelGroupDefinition;
import org.apache.xerces.xs.XSNamedMap;
import org.apache.xerces.xs.XSNamespaceItem;
import org.apache.xerces.xs.XSNotationDeclaration;
import org.apache.xerces.xs.XSObjectList;
import org.apache.xerces.xs.XSTypeDefinition;
import org.apache.xerces.xs.XSWildcard;
import org.apache.xerces.xs.datatypes.ObjectList;
import org.xml.sax.SAXException;
/**
* This class is to hold all schema component declaration that are declared
* within one namespace.
*
* The Grammar class this class extends contains what little
* commonality there is between XML Schema and DTD grammars. It's
* useful to distinguish grammar objects from other kinds of object
* when they exist in pools or caches.
*
* @xerces.internal
*
* @author Sandy Gao, IBM
* @author Elena Litani, IBM
*
* @version $Id$
*/
public class SchemaGrammar implements XSGrammar, XSNamespaceItem {
// the target namespace of grammar
String fTargetNamespace;
// global decls: map from decl name to decl object
SymbolHash fGlobalAttrDecls;
SymbolHash fGlobalAttrGrpDecls;
SymbolHash fGlobalElemDecls;
SymbolHash fGlobalGroupDecls;
SymbolHash fGlobalNotationDecls;
SymbolHash fGlobalIDConstraintDecls;
SymbolHash fGlobalTypeDecls;
// extended global decls: map from schema location + decl name to decl object
// key is location,name
SymbolHash fGlobalAttrDeclsExt;
SymbolHash fGlobalAttrGrpDeclsExt;
SymbolHash fGlobalElemDeclsExt;
SymbolHash fGlobalGroupDeclsExt;
SymbolHash fGlobalNotationDeclsExt;
SymbolHash fGlobalIDConstraintDeclsExt;
SymbolHash fGlobalTypeDeclsExt;
// A global map of all global element declarations - used for substitution group computation
// (handy when sharing components by reference, since we might end up with duplicate components
// that are not added to either of the global element declarations above)
SymbolHash fAllGlobalElemDecls;
// the XMLGrammarDescription member
XSDDescription fGrammarDescription = null;
// annotations associated with the "root" schema of this targetNamespace
XSAnnotationImpl [] fAnnotations = null;
// number of annotations declared
int fNumAnnotations;
// symbol table for constructing parsers (annotation support)
private SymbolTable fSymbolTable = null;
// parsers for annotation support
private SoftReference fSAXParser = null;
private SoftReference fDOMParser = null;
// is this grammar immutable? (fully constructed and not changeable)
private boolean fIsImmutable = false;
//
// Constructors
//
// needed to make BuiltinSchemaGrammar work.
protected SchemaGrammar() {}
/**
* Default constructor.
*
* @param targetNamespace
* @param grammarDesc the XMLGrammarDescription corresponding to this objec
* at the least a systemId should always be known.
* @param symbolTable needed for annotation support
*/
public SchemaGrammar(String targetNamespace, XSDDescription grammarDesc,
SymbolTable symbolTable) {
this(targetNamespace, grammarDesc, symbolTable, Constants.SCHEMA_VERSION_1_0);
}
/**
* Default constructor.
*
* @param targetNamespace
* @param grammarDesc the XMLGrammarDescription corresponding to this objec
* at the least a systemId should always be known.
* @param symbolTable needed for annotation support
* @param schemaVersion the XML schema version
*/
public SchemaGrammar(String targetNamespace, XSDDescription grammarDesc,
SymbolTable symbolTable, short schemaVersion) {
fTargetNamespace = targetNamespace;
fGrammarDescription = grammarDesc;
fSymbolTable = symbolTable;
// REVISIT: the initial sizes being chosen for each SymbolHash
// may not be ideal and could still be tuned. They were chosen
// somewhat arbitrarily to reduce the initial footprint of
// SymbolHash buckets from 1,515 to 177 (about 12% of the
// default size).
fGlobalAttrDecls = new SymbolHash(12);
fGlobalAttrGrpDecls = new SymbolHash(5);
fGlobalElemDecls = new SymbolHash(25);
fGlobalGroupDecls = new SymbolHash(5);
fGlobalNotationDecls = new SymbolHash(1);
fGlobalIDConstraintDecls = new SymbolHash(3);
// Extended tables
fGlobalAttrDeclsExt = new SymbolHash(12);
fGlobalAttrGrpDeclsExt = new SymbolHash(5);
fGlobalElemDeclsExt = new SymbolHash(25);
fGlobalGroupDeclsExt = new SymbolHash(5);
fGlobalNotationDeclsExt = new SymbolHash(1);
fGlobalIDConstraintDeclsExt = new SymbolHash(3);
fGlobalTypeDeclsExt = new SymbolHash(25);
// All global elements table
fAllGlobalElemDecls = new SymbolHash(25);
// if we are parsing S4S, put built-in types in first
// they might get overwritten by the types from S4S, but that's
// considered what the application wants to do.
if (fTargetNamespace == SchemaSymbols.URI_SCHEMAFORSCHEMA){
fGlobalTypeDecls = getS4SGrammar(schemaVersion).fGlobalTypeDecls.makeClone();
}
else {
fGlobalTypeDecls = new SymbolHash(25);
}
} // (String, XSDDescription, SymbolTable, short)
// Clone an existing schema grammar
public SchemaGrammar(SchemaGrammar grammar) {
fTargetNamespace = grammar.fTargetNamespace;
fGrammarDescription = grammar.fGrammarDescription.makeClone();
//fGrammarDescription.fContextType |= XSDDescription.CONTEXT_COLLISION; // REVISIT
fSymbolTable = grammar.fSymbolTable; // REVISIT
fGlobalAttrDecls = grammar.fGlobalAttrDecls.makeClone();
fGlobalAttrGrpDecls = grammar.fGlobalAttrGrpDecls.makeClone();
fGlobalElemDecls = grammar.fGlobalElemDecls.makeClone();
fGlobalGroupDecls = grammar.fGlobalGroupDecls.makeClone();
fGlobalNotationDecls = grammar.fGlobalNotationDecls.makeClone();
fGlobalIDConstraintDecls = grammar.fGlobalIDConstraintDecls.makeClone();
fGlobalTypeDecls = grammar.fGlobalTypeDecls.makeClone();
// Extended tables
fGlobalAttrDeclsExt = grammar.fGlobalAttrDeclsExt.makeClone();
fGlobalAttrGrpDeclsExt = grammar.fGlobalAttrGrpDeclsExt.makeClone();
fGlobalElemDeclsExt = grammar.fGlobalElemDeclsExt.makeClone();
fGlobalGroupDeclsExt = grammar.fGlobalGroupDeclsExt.makeClone();
fGlobalNotationDeclsExt = grammar.fGlobalNotationDeclsExt.makeClone();
fGlobalIDConstraintDeclsExt = grammar.fGlobalIDConstraintDeclsExt.makeClone();
fGlobalTypeDeclsExt = grammar.fGlobalTypeDeclsExt.makeClone();
// All global elements table
fAllGlobalElemDecls = grammar.fAllGlobalElemDecls.makeClone();
// Annotations associated with the "root" schema of this targetNamespace
fNumAnnotations = grammar.fNumAnnotations;
if (fNumAnnotations > 0) {
fAnnotations = new XSAnnotationImpl[grammar.fAnnotations.length];
System.arraycopy(grammar.fAnnotations, 0, fAnnotations, 0, fNumAnnotations);
}
// All substitution group information declared in this namespace
fSubGroupCount = grammar.fSubGroupCount;
if (fSubGroupCount > 0) {
fSubGroups = new XSElementDecl[grammar.fSubGroups.length];
System.arraycopy(grammar.fSubGroups, 0, fSubGroups, 0, fSubGroupCount);
}
// Array to store complex type decls for constraint checking
fCTCount = grammar.fCTCount;
if (fCTCount > 0) {
fComplexTypeDecls = new XSComplexTypeDecl[grammar.fComplexTypeDecls.length];
fCTLocators = new SimpleLocator[grammar.fCTLocators.length];
System.arraycopy(grammar.fComplexTypeDecls, 0, fComplexTypeDecls, 0, fCTCount);
System.arraycopy(grammar.fCTLocators, 0, fCTLocators, 0, fCTCount);
}
// Groups being redefined by restriction
fRGCount = grammar.fRGCount;
if (fRGCount > 0) {
fRedefinedGroupDecls = new XSGroupDecl[grammar.fRedefinedGroupDecls.length];
fRGLocators = new SimpleLocator[grammar.fRGLocators.length];
System.arraycopy(grammar.fRedefinedGroupDecls, 0, fRedefinedGroupDecls, 0, fRGCount);
System.arraycopy(grammar.fRGLocators, 0, fRGLocators, 0, fRGCount/2);
}
// List of imported grammars
if (grammar.fImported != null) {
fImported = new Vector();
for (int i=0; i(SchemaGrammar)
// number of built-in XSTypes we need to create for base and full
// datatype set
private static final int BASICSET_COUNT = 29;
private static final int FULLSET_COUNT = 46;
private static final int GRAMMAR_XS = 1;
private static final int GRAMMAR_XSI = 2;
// this class makes sure the static, built-in schema grammars
// are immutable.
public static class BuiltinSchemaGrammar extends SchemaGrammar {
private static final String EXTENDED_SCHEMA_FACTORY_CLASS = "org.apache.xerces.impl.dv.xs.ExtendedSchemaDVFactoryImpl";
private static final String SCHEMA11_FACTORY_CLASS = "org.apache.xerces.impl.dv.xs.Schema11DVFactoryImpl";
/**
* Special constructor to create the grammars for the schema namespaces
*
* @param grammar
*/
public BuiltinSchemaGrammar(int grammar, short schemaVersion) {
SchemaDVFactory schemaFactory;
if (schemaVersion == Constants.SCHEMA_VERSION_1_0) {
schemaFactory = SchemaDVFactory.getInstance();
}
else if (schemaVersion == Constants.SCHEMA_VERSION_1_1) {
schemaFactory = SchemaDVFactory.getInstance(SCHEMA11_FACTORY_CLASS);
}
else {
schemaFactory = SchemaDVFactory.getInstance(EXTENDED_SCHEMA_FACTORY_CLASS);
}
if (grammar == GRAMMAR_XS) {
// target namespace
fTargetNamespace = SchemaSymbols.URI_SCHEMAFORSCHEMA;
// grammar description
fGrammarDescription = new XSDDescription();
fGrammarDescription.fContextType = XSDDescription.CONTEXT_PREPARSE;
fGrammarDescription.setNamespace(SchemaSymbols.URI_SCHEMAFORSCHEMA);
// no global decls other than types
fGlobalAttrDecls = new SymbolHash(1);
fGlobalAttrGrpDecls = new SymbolHash(1);
fGlobalElemDecls = new SymbolHash(1);
fGlobalGroupDecls = new SymbolHash(1);
fGlobalNotationDecls = new SymbolHash(1);
fGlobalIDConstraintDecls = new SymbolHash(1);
// no extended global decls
fGlobalAttrDeclsExt = new SymbolHash(1);
fGlobalAttrGrpDeclsExt = new SymbolHash(1);
fGlobalElemDeclsExt = new SymbolHash(1);
fGlobalGroupDeclsExt = new SymbolHash(1);
fGlobalNotationDeclsExt = new SymbolHash(1);
fGlobalIDConstraintDeclsExt = new SymbolHash(1);
fGlobalTypeDeclsExt = new SymbolHash(1);
// all global element decls table
fAllGlobalElemDecls = new SymbolHash(1);
// get all built-in types
fGlobalTypeDecls = schemaFactory.getBuiltInTypes();
// assign the built-in schema grammar as the XSNamespaceItem
// for each of the built-in simple type definitions.
int length = fGlobalTypeDecls.getLength();
XSTypeDefinition [] typeDefinitions = new XSTypeDefinition[length];
fGlobalTypeDecls.getValues(typeDefinitions, 0);
for (int i = 0; i < length; ++i) {
XSTypeDefinition xtd = typeDefinitions[i];
if (xtd instanceof XSSimpleTypeDecl) {
((XSSimpleTypeDecl) xtd).setNamespaceItem(this);
}
}
// add anyType
final XSComplexTypeDecl anyType = getXSAnyType(schemaVersion);
fGlobalTypeDecls.put(anyType.getName(), anyType);
}
else if (grammar == GRAMMAR_XSI) {
// target namespace
fTargetNamespace = SchemaSymbols.URI_XSI;
// grammar description
fGrammarDescription = new XSDDescription();
fGrammarDescription.fContextType = XSDDescription.CONTEXT_PREPARSE;
fGrammarDescription.setNamespace(SchemaSymbols.URI_XSI);
// no global decls other than attributes
fGlobalAttrGrpDecls = new SymbolHash(1);
fGlobalElemDecls = new SymbolHash(1);
fGlobalGroupDecls = new SymbolHash(1);
fGlobalNotationDecls = new SymbolHash(1);
fGlobalIDConstraintDecls = new SymbolHash(1);
fGlobalTypeDecls = new SymbolHash(1);
// no extended global decls
fGlobalAttrDeclsExt = new SymbolHash(1);
fGlobalAttrGrpDeclsExt = new SymbolHash(1);
fGlobalElemDeclsExt = new SymbolHash(1);
fGlobalGroupDeclsExt = new SymbolHash(1);
fGlobalNotationDeclsExt = new SymbolHash(1);
fGlobalIDConstraintDeclsExt = new SymbolHash(1);
fGlobalTypeDeclsExt = new SymbolHash(1);
// no all global element decls
fAllGlobalElemDecls = new SymbolHash(1);
// 4 attributes, so initialize the size as 4*2 = 8
fGlobalAttrDecls = new SymbolHash(8);
String name = null;
String tns = null;
XSSimpleType type = null;
short scope = XSConstants.SCOPE_GLOBAL;
// xsi:type
name = SchemaSymbols.XSI_TYPE;
tns = SchemaSymbols.URI_XSI;
type = schemaFactory.getBuiltInType(SchemaSymbols.ATTVAL_QNAME);
fGlobalAttrDecls.put(name, new BuiltinAttrDecl(name, tns, type, scope));
// xsi:nil
name = SchemaSymbols.XSI_NIL;
tns = SchemaSymbols.URI_XSI;
type = schemaFactory.getBuiltInType(SchemaSymbols.ATTVAL_BOOLEAN);
fGlobalAttrDecls.put(name, new BuiltinAttrDecl(name, tns, type, scope));
XSSimpleType anyURI = schemaFactory.getBuiltInType(SchemaSymbols.ATTVAL_ANYURI);
// xsi:schemaLocation
name = SchemaSymbols.XSI_SCHEMALOCATION;
tns = SchemaSymbols.URI_XSI;
type = schemaFactory.createTypeList("#AnonType_schemaLocation", SchemaSymbols.URI_XSI, (short)0, anyURI, null);
if (type instanceof XSSimpleTypeDecl) {
((XSSimpleTypeDecl)type).setAnonymous(true);
}
fGlobalAttrDecls.put(name, new BuiltinAttrDecl(name, tns, type, scope));
// xsi:noNamespaceSchemaLocation
name = SchemaSymbols.XSI_NONAMESPACESCHEMALOCATION;
tns = SchemaSymbols.URI_XSI;
type = anyURI;
fGlobalAttrDecls.put(name, new BuiltinAttrDecl(name, tns, type, scope));
}
} // (int)
// return the XMLGrammarDescription corresponding to this
// object
public XMLGrammarDescription getGrammarDescription() {
return fGrammarDescription.makeClone();
} // getGrammarDescription(): XMLGrammarDescription
// override these methods solely so that these
// objects cannot be modified once they're created.
public void setImportedGrammars(Vector importedGrammars) {
// ignore
}
public void addGlobalAttributeDecl(XSAttributeDecl decl) {
// ignore
}
public void addGlobalAttributeDecl(XSAttributeDecl decl, String location) {
// ignore
}
public void addGlobalAttributeGroupDecl(XSAttributeGroupDecl decl) {
// ignore
}
public void addGlobalAttributeGroupDecl(XSAttributeGroupDecl decl, String location) {
// ignore
}
public void addGlobalElementDecl(XSElementDecl decl) {
// ignore
}
public void addGlobalElementDecl(XSElementDecl decl, String location) {
// ignore
}
public void addGlobalElementDeclAll(XSElementDecl decl) {
// ignore
}
public void addGlobalGroupDecl(XSGroupDecl decl) {
// ignore
}
public void addGlobalGroupDecl(XSGroupDecl decl, String location) {
// ignore
}
public void addGlobalNotationDecl(XSNotationDecl decl) {
// ignore
}
public void addGlobalNotationDecl(XSNotationDecl decl, String location) {
// ignore
}
public void addGlobalTypeDecl(XSTypeDefinition decl) {
// ignore
}
public void addGlobalTypeDecl(XSTypeDefinition decl, String location) {
// ignore
}
public void addGlobalComplexTypeDecl(XSComplexTypeDecl decl) {
// ignore
}
public void addGlobalComplexTypeDecl(XSComplexTypeDecl decl, String location) {
// ignore
}
public void addGlobalSimpleTypeDecl(XSSimpleType decl) {
// ignore
}
public void addGlobalSimpleTypeDecl(XSSimpleType decl, String location) {
// ignore
}
public void addComplexTypeDecl(XSComplexTypeDecl decl, SimpleLocator locator) {
// ignore
}
public void addRedefinedGroupDecl(XSGroupDecl derived, XSGroupDecl base, SimpleLocator locator) {
// ignore
}
public synchronized void addDocument(Object document, String location) {
// ignore
}
// annotation support
synchronized DOMParser getDOMParser() {
return null;
}
synchronized SAXParser getSAXParser() {
return null;
}
}
/**
* A partial schema for schemas for validating annotations.
*
* @xerces.internal
*
* @author Michael Glavassevich, IBM
*/
public static final class Schema4Annotations extends SchemaGrammar {
/**
* Singleton instance.
*/
private static final Schema4Annotations INSTANCE_10 = new Schema4Annotations(Constants.SCHEMA_VERSION_1_0);
private static final Schema4Annotations INSTANCE_Extended = new Schema4Annotations(Constants.SCHEMA_VERSION_1_0_EXTENDED);
private static final Schema4Annotations INSTANCE_11 = new Schema4Annotations(Constants.SCHEMA_VERSION_1_1);
public static Schema4Annotations getSchema4Annotations(short schemaVersion) {
if (schemaVersion == Constants.SCHEMA_VERSION_1_0) {
return INSTANCE_10;
}
else if (schemaVersion == Constants.SCHEMA_VERSION_1_1) {
return INSTANCE_11;
}
return INSTANCE_Extended;
}
/**
* Special constructor to create a schema
* capable of validating annotations.
*/
private Schema4Annotations(short schemaVersion) {
// target namespace
fTargetNamespace = SchemaSymbols.URI_SCHEMAFORSCHEMA;
// grammar description
fGrammarDescription = new XSDDescription();
fGrammarDescription.fContextType = XSDDescription.CONTEXT_PREPARSE;
fGrammarDescription.setNamespace(SchemaSymbols.URI_SCHEMAFORSCHEMA);
// no global decls other than types and
// element declarations for , and .
fGlobalAttrDecls = new SymbolHash(1);
fGlobalAttrGrpDecls = new SymbolHash(1);
fGlobalElemDecls = new SymbolHash(6);
fGlobalGroupDecls = new SymbolHash(1);
fGlobalNotationDecls = new SymbolHash(1);
fGlobalIDConstraintDecls = new SymbolHash(1);
// no extended global decls
fGlobalAttrDeclsExt = new SymbolHash(1);
fGlobalAttrGrpDeclsExt = new SymbolHash(1);
fGlobalElemDeclsExt = new SymbolHash(6);
fGlobalGroupDeclsExt = new SymbolHash(1);
fGlobalNotationDeclsExt = new SymbolHash(1);
fGlobalIDConstraintDeclsExt = new SymbolHash(1);
fGlobalTypeDeclsExt = new SymbolHash(1);
// all global element declarations
fAllGlobalElemDecls = new SymbolHash(6);
// get all built-in types
fGlobalTypeDecls = getS4SGrammar(schemaVersion).fGlobalTypeDecls;
// create element declarations for , and
XSElementDecl annotationDecl = createAnnotationElementDecl(SchemaSymbols.ELT_ANNOTATION);
XSElementDecl documentationDecl = createAnnotationElementDecl(SchemaSymbols.ELT_DOCUMENTATION);
XSElementDecl appinfoDecl = createAnnotationElementDecl(SchemaSymbols.ELT_APPINFO);
// add global element declarations
fGlobalElemDecls.put(annotationDecl.fName, annotationDecl);
fGlobalElemDecls.put(documentationDecl.fName, documentationDecl);
fGlobalElemDecls.put(appinfoDecl.fName, appinfoDecl);
fGlobalElemDeclsExt.put(","+annotationDecl.fName, annotationDecl);
fGlobalElemDeclsExt.put(","+documentationDecl.fName, documentationDecl);
fGlobalElemDeclsExt.put(","+appinfoDecl.fName, appinfoDecl);
fAllGlobalElemDecls.put(annotationDecl, annotationDecl);
fAllGlobalElemDecls.put(documentationDecl, documentationDecl);
fAllGlobalElemDecls.put(appinfoDecl, appinfoDecl);
// create complex type declarations for , and
XSComplexTypeDecl annotationType = new XSComplexTypeDecl();
XSComplexTypeDecl documentationType = new XSComplexTypeDecl();
XSComplexTypeDecl appinfoType = new XSComplexTypeDecl();
// set the types on their element declarations
annotationDecl.fType = annotationType;
documentationDecl.fType = documentationType;
appinfoDecl.fType = appinfoType;
// create attribute groups for , and
XSAttributeGroupDecl annotationAttrs = new XSAttributeGroupDecl();
XSAttributeGroupDecl documentationAttrs = new XSAttributeGroupDecl();
XSAttributeGroupDecl appinfoAttrs = new XSAttributeGroupDecl();
// fill in attribute groups
{
// create and fill attribute uses for , and
XSAttributeUseImpl annotationIDAttr = new XSAttributeUseImpl();
annotationIDAttr.fAttrDecl = new XSAttributeDecl();
annotationIDAttr.fAttrDecl.setValues(SchemaSymbols.ATT_ID, null, (XSSimpleType) fGlobalTypeDecls.get(SchemaSymbols.ATTVAL_ID),
XSConstants.VC_NONE, XSConstants.SCOPE_LOCAL, null, annotationType, null, false);
annotationIDAttr.fUse = SchemaSymbols.USE_OPTIONAL;
annotationIDAttr.fConstraintType = XSConstants.VC_NONE;
XSAttributeUseImpl documentationSourceAttr = new XSAttributeUseImpl();
documentationSourceAttr.fAttrDecl = new XSAttributeDecl();
documentationSourceAttr.fAttrDecl.setValues(SchemaSymbols.ATT_SOURCE, null, (XSSimpleType) fGlobalTypeDecls.get(SchemaSymbols.ATTVAL_ANYURI),
XSConstants.VC_NONE, XSConstants.SCOPE_LOCAL, null, documentationType, null, false);
documentationSourceAttr.fUse = SchemaSymbols.USE_OPTIONAL;
documentationSourceAttr.fConstraintType = XSConstants.VC_NONE;
XSAttributeUseImpl documentationLangAttr = new XSAttributeUseImpl();
documentationLangAttr.fAttrDecl = new XSAttributeDecl();
documentationLangAttr.fAttrDecl.setValues("lang".intern(), NamespaceContext.XML_URI, (XSSimpleType) fGlobalTypeDecls.get(SchemaSymbols.ATTVAL_LANGUAGE),
XSConstants.VC_NONE, XSConstants.SCOPE_LOCAL, null, documentationType, null, false);
documentationLangAttr.fUse = SchemaSymbols.USE_OPTIONAL;
documentationLangAttr.fConstraintType = XSConstants.VC_NONE;
XSAttributeUseImpl appinfoSourceAttr = new XSAttributeUseImpl();
appinfoSourceAttr.fAttrDecl = new XSAttributeDecl();
appinfoSourceAttr.fAttrDecl.setValues(SchemaSymbols.ATT_SOURCE, null, (XSSimpleType) fGlobalTypeDecls.get(SchemaSymbols.ATTVAL_ANYURI),
XSConstants.VC_NONE, XSConstants.SCOPE_LOCAL, null, appinfoType, null, false);
appinfoSourceAttr.fUse = SchemaSymbols.USE_OPTIONAL;
appinfoSourceAttr.fConstraintType = XSConstants.VC_NONE;
// create lax attribute wildcard for , and
XSWildcardDecl otherAttrs = new XSWildcardDecl();
otherAttrs.fNamespaceList = new String [] {fTargetNamespace, null};
otherAttrs.fType = XSWildcard.NSCONSTRAINT_NOT;
otherAttrs.fProcessContents = XSWildcard.PC_LAX;
// add attribute uses and wildcards to attribute groups for , and
annotationAttrs.addAttributeUse(annotationIDAttr);
annotationAttrs.fAttributeWC = otherAttrs;
documentationAttrs.addAttributeUse(documentationSourceAttr);
documentationAttrs.addAttributeUse(documentationLangAttr);
documentationAttrs.fAttributeWC = otherAttrs;
appinfoAttrs.addAttributeUse(appinfoSourceAttr);
appinfoAttrs.fAttributeWC = otherAttrs;
}
// create particles for
XSParticleDecl annotationParticle = createUnboundedModelGroupParticle();
{
XSModelGroupImpl annotationChoice = new XSModelGroupImpl();
annotationChoice.fCompositor = XSModelGroupImpl.MODELGROUP_CHOICE;
annotationChoice.fParticleCount = 2;
annotationChoice.fParticles = new XSParticleDecl[2];
annotationChoice.fParticles[0] = createChoiceElementParticle(appinfoDecl);
annotationChoice.fParticles[1] = createChoiceElementParticle(documentationDecl);
annotationParticle.fValue = annotationChoice;
}
// create wildcard particle for and
XSParticleDecl anyWCSequenceParticle = createUnboundedAnyWildcardSequenceParticle();
// fill complex types
XSComplexTypeDecl anyType = getXSAnyType(schemaVersion);
annotationType.setValues("#AnonType_" + SchemaSymbols.ELT_ANNOTATION, fTargetNamespace, anyType,
XSConstants.DERIVATION_RESTRICTION, XSConstants.DERIVATION_NONE, (short) (XSConstants.DERIVATION_EXTENSION | XSConstants.DERIVATION_RESTRICTION),
XSComplexTypeDecl.CONTENTTYPE_ELEMENT, false, annotationAttrs, null, annotationParticle, XSObjectListImpl.EMPTY_LIST, null);
annotationType.setName("#AnonType_" + SchemaSymbols.ELT_ANNOTATION);
annotationType.setIsAnonymous();
documentationType.setValues("#AnonType_" + SchemaSymbols.ELT_DOCUMENTATION, fTargetNamespace, anyType,
XSConstants.DERIVATION_RESTRICTION, XSConstants.DERIVATION_NONE, (short) (XSConstants.DERIVATION_EXTENSION | XSConstants.DERIVATION_RESTRICTION),
XSComplexTypeDecl.CONTENTTYPE_MIXED, false, documentationAttrs, null, anyWCSequenceParticle, XSObjectListImpl.EMPTY_LIST, null);
documentationType.setName("#AnonType_" + SchemaSymbols.ELT_DOCUMENTATION);
documentationType.setIsAnonymous();
appinfoType.setValues("#AnonType_" + SchemaSymbols.ELT_APPINFO, fTargetNamespace, anyType,
XSConstants.DERIVATION_RESTRICTION, XSConstants.DERIVATION_NONE, (short) (XSConstants.DERIVATION_EXTENSION | XSConstants.DERIVATION_RESTRICTION),
XSComplexTypeDecl.CONTENTTYPE_MIXED, false, appinfoAttrs, null, anyWCSequenceParticle, XSObjectListImpl.EMPTY_LIST, null);
appinfoType.setName("#AnonType_" + SchemaSymbols.ELT_APPINFO);
appinfoType.setIsAnonymous();
} // (int)
// return the XMLGrammarDescription corresponding to this
// object
public XMLGrammarDescription getGrammarDescription() {
return fGrammarDescription.makeClone();
} // getGrammarDescription(): XMLGrammarDescription
// override these methods solely so that these
// objects cannot be modified once they're created.
public void setImportedGrammars(Vector importedGrammars) {
// ignore
}
public void addGlobalAttributeDecl(XSAttributeDecl decl) {
// ignore
}
public void addGlobalAttributeDecl(XSAttributeGroupDecl decl, String location) {
// ignore
}
public void addGlobalAttributeGroupDecl(XSAttributeGroupDecl decl) {
// ignore
}
public void addGlobalAttributeGroupDecl(XSAttributeGroupDecl decl, String location) {
// ignore
}
public void addGlobalElementDecl(XSElementDecl decl) {
// ignore
}
public void addGlobalElementDecl(XSElementDecl decl, String location) {
// ignore
}
public void addGlobalElementDeclAll(XSElementDecl decl) {
// ignore
}
public void addGlobalGroupDecl(XSGroupDecl decl) {
// ignore
}
public void addGlobalGroupDecl(XSGroupDecl decl, String location) {
// ignore
}
public void addGlobalNotationDecl(XSNotationDecl decl) {
// ignore
}
public void addGlobalNotationDecl(XSNotationDecl decl, String location) {
// ignore
}
public void addGlobalTypeDecl(XSTypeDefinition decl) {
// ignore
}
public void addGlobalTypeDecl(XSTypeDefinition decl, String location) {
// ignore
}
public void addGlobalComplexTypeDecl(XSComplexTypeDecl decl) {
// ignore
}
public void addGlobalComplexTypeDecl(XSComplexTypeDecl decl, String location) {
// ignore
}
public void addGlobalSimpleTypeDecl(XSSimpleType decl) {
// ignore
}
public void addGlobalSimpleTypeDecl(XSSimpleType decl, String location) {
// ignore
}
public void addComplexTypeDecl(XSComplexTypeDecl decl, SimpleLocator locator) {
// ignore
}
public void addRedefinedGroupDecl(XSGroupDecl derived, XSGroupDecl base, SimpleLocator locator) {
// ignore
}
public synchronized void addDocument(Object document, String location) {
// ignore
}
// annotation support
synchronized DOMParser getDOMParser() {
return null;
}
synchronized SAXParser getSAXParser() {
return null;
}
//
// private helper methods
//
private XSElementDecl createAnnotationElementDecl(String localName) {
XSElementDecl eDecl = new XSElementDecl();
eDecl.fName = localName;
eDecl.fTargetNamespace = fTargetNamespace;
eDecl.setIsGlobal();
eDecl.fBlock = (XSConstants.DERIVATION_EXTENSION |
XSConstants.DERIVATION_RESTRICTION | XSConstants.DERIVATION_SUBSTITUTION);
eDecl.setConstraintType(XSConstants.VC_NONE);
return eDecl;
}
private XSParticleDecl createUnboundedModelGroupParticle() {
XSParticleDecl particle = new XSParticleDecl();
particle.fMinOccurs = 0;
particle.fMaxOccurs = SchemaSymbols.OCCURRENCE_UNBOUNDED;
particle.fType = XSParticleDecl.PARTICLE_MODELGROUP;
return particle;
}
private XSParticleDecl createChoiceElementParticle(XSElementDecl ref) {
XSParticleDecl particle = new XSParticleDecl();
particle.fMinOccurs = 1;
particle.fMaxOccurs = 1;
particle.fType = XSParticleDecl.PARTICLE_ELEMENT;
particle.fValue = ref;
return particle;
}
private XSParticleDecl createUnboundedAnyWildcardSequenceParticle() {
XSParticleDecl particle = createUnboundedModelGroupParticle();
XSModelGroupImpl sequence = new XSModelGroupImpl();
sequence.fCompositor = XSModelGroupImpl.MODELGROUP_SEQUENCE;
sequence.fParticleCount = 1;
sequence.fParticles = new XSParticleDecl[1];
sequence.fParticles[0] = createAnyLaxWildcardParticle();
particle.fValue = sequence;
return particle;
}
private XSParticleDecl createAnyLaxWildcardParticle() {
XSParticleDecl particle = new XSParticleDecl();
particle.fMinOccurs = 1;
particle.fMaxOccurs = 1;
particle.fType = XSParticleDecl.PARTICLE_WILDCARD;
XSWildcardDecl anyWC = new XSWildcardDecl();
anyWC.fNamespaceList = null;
anyWC.fType = XSWildcard.NSCONSTRAINT_ANY;
anyWC.fProcessContents = XSWildcard.PC_LAX;
particle.fValue = anyWC;
return particle;
}
}
// Grammar methods
// return the XMLGrammarDescription corresponding to this
// object
public XMLGrammarDescription getGrammarDescription() {
return fGrammarDescription;
} // getGrammarDescription(): XMLGrammarDescription
// DTDGrammar methods
public boolean isNamespaceAware () {
return true;
} // isNamespaceAware():boolean
Vector fImported = null;
public void setImportedGrammars(Vector importedGrammars) {
fImported = importedGrammars;
}
public Vector getImportedGrammars() {
return fImported;
}
/**
* Returns this grammar's target namespace.
*/
public final String getTargetNamespace() {
return fTargetNamespace;
} // getTargetNamespace():String
/**
* register one global attribute
*/
public void addGlobalAttributeDecl(XSAttributeDecl decl) {
fGlobalAttrDecls.put(decl.fName, decl);
decl.setNamespaceItem(this);
}
public void addGlobalAttributeDecl(XSAttributeDecl decl, String location) {
fGlobalAttrDeclsExt.put(((location!=null) ? location : "") + "," + decl.fName, decl);
if (decl.getNamespaceItem() == null) {
decl.setNamespaceItem(this);
}
}
/**
* register one global attribute group
*/
public void addGlobalAttributeGroupDecl(XSAttributeGroupDecl decl) {
fGlobalAttrGrpDecls.put(decl.fName, decl);
decl.setNamespaceItem(this);
}
public void addGlobalAttributeGroupDecl(XSAttributeGroupDecl decl, String location) {
fGlobalAttrGrpDeclsExt.put(((location!=null) ? location : "") + "," + decl.fName, decl);
if (decl.getNamespaceItem() == null) {
decl.setNamespaceItem(this);
}
}
/**
* register one global element
*/
public void addGlobalElementDeclAll(XSElementDecl decl) {
if (fAllGlobalElemDecls.get(decl) == null) {
fAllGlobalElemDecls.put(decl, decl);
// if there is a substitution group affiliation, store in an array,
// for further constraint checking: UPA, PD, EDC
if (decl.fSubGroup != null) {
if (fSubGroupCount == fSubGroups.length)
fSubGroups = resize(fSubGroups, fSubGroupCount+INC_SIZE);
fSubGroups[fSubGroupCount++] = decl;
}
}
}
public void addGlobalElementDecl(XSElementDecl decl) {
fGlobalElemDecls.put(decl.fName, decl);
decl.setNamespaceItem(this);
}
public void addGlobalElementDecl(XSElementDecl decl, String location) {
fGlobalElemDeclsExt.put(((location != null) ? location : "") + "," + decl.fName, decl);
if (decl.getNamespaceItem() == null) {
decl.setNamespaceItem(this);
}
}
/**
* register one global group
*/
public void addGlobalGroupDecl(XSGroupDecl decl) {
fGlobalGroupDecls.put(decl.fName, decl);
decl.setNamespaceItem(this);
}
public void addGlobalGroupDecl(XSGroupDecl decl, String location) {
fGlobalGroupDeclsExt.put(((location!=null) ? location : "") + "," + decl.fName, decl);
if (decl.getNamespaceItem() == null) {
decl.setNamespaceItem(this);
}
}
/**
* register one global notation
*/
public void addGlobalNotationDecl(XSNotationDecl decl) {
fGlobalNotationDecls.put(decl.fName, decl);
decl.setNamespaceItem(this);
}
public void addGlobalNotationDecl(XSNotationDecl decl, String location) {
fGlobalNotationDeclsExt.put(((location!=null) ? location : "") + "," +decl.fName, decl);
if (decl.getNamespaceItem() == null) {
decl.setNamespaceItem(this);
}
}
/**
* register one global type
*/
public void addGlobalTypeDecl(XSTypeDefinition decl) {
fGlobalTypeDecls.put(decl.getName(), decl);
if (decl instanceof XSComplexTypeDecl) {
((XSComplexTypeDecl) decl).setNamespaceItem(this);
}
else if (decl instanceof XSSimpleTypeDecl) {
((XSSimpleTypeDecl) decl).setNamespaceItem(this);
}
}
public void addGlobalTypeDecl(XSTypeDefinition decl, String location) {
fGlobalTypeDeclsExt.put(((location!=null) ? location : "") + "," + decl.getName(), decl);
if (decl.getNamespaceItem() == null) {
if (decl instanceof XSComplexTypeDecl) {
((XSComplexTypeDecl) decl).setNamespaceItem(this);
}
else if (decl instanceof XSSimpleTypeDecl) {
((XSSimpleTypeDecl) decl).setNamespaceItem(this);
}
}
}
/**
* register one global complex type
*/
public void addGlobalComplexTypeDecl(XSComplexTypeDecl decl) {
fGlobalTypeDecls.put(decl.getName(), decl);
decl.setNamespaceItem(this);
}
public void addGlobalComplexTypeDecl(XSComplexTypeDecl decl, String location) {
fGlobalTypeDeclsExt.put(((location!=null) ? location : "") + "," + decl.getName(), decl);
if (decl.getNamespaceItem() == null) {
decl.setNamespaceItem(this);
}
}
/**
* register one global simple type
*/
public void addGlobalSimpleTypeDecl(XSSimpleType decl) {
fGlobalTypeDecls.put(decl.getName(), decl);
if (decl instanceof XSSimpleTypeDecl) {
((XSSimpleTypeDecl) decl).setNamespaceItem(this);
}
}
public void addGlobalSimpleTypeDecl(XSSimpleType decl, String location) {
fGlobalTypeDeclsExt.put(((location != null) ? location : "") + "," + decl.getName(), decl);
if (decl.getNamespaceItem() == null && decl instanceof XSSimpleTypeDecl) {
((XSSimpleTypeDecl) decl).setNamespaceItem(this);
}
}
/**
* register one identity constraint
*/
public final void addIDConstraintDecl(XSElementDecl elmDecl, IdentityConstraint decl) {
elmDecl.addIDConstraint(decl);
fGlobalIDConstraintDecls.put(decl.getIdentityConstraintName(), decl);
}
public final void addIDConstraintDecl(XSElementDecl elmDecl, IdentityConstraint decl, String location) {
fGlobalIDConstraintDeclsExt.put(((location != null) ? location : "") + "," + decl.getIdentityConstraintName(), decl);
}
/**
* register one type alternative
*/
public final void addTypeAlternative(XSElementDecl elmDecl, XSTypeAlternativeImpl typeAlt) {
elmDecl.addTypeAlternative(typeAlt);
}
/**
* get one global attribute
*/
public final XSAttributeDecl getGlobalAttributeDecl(String declName) {
return(XSAttributeDecl)fGlobalAttrDecls.get(declName);
}
public final XSAttributeDecl getGlobalAttributeDecl(String declName, String location) {
return(XSAttributeDecl)fGlobalAttrDeclsExt.get(((location != null) ? location : "") + "," + declName);
}
/**
* get one global attribute group
*/
public final XSAttributeGroupDecl getGlobalAttributeGroupDecl(String declName) {
return(XSAttributeGroupDecl)fGlobalAttrGrpDecls.get(declName);
}
public final XSAttributeGroupDecl getGlobalAttributeGroupDecl(String declName, String location) {
return(XSAttributeGroupDecl)fGlobalAttrGrpDeclsExt.get(((location != null) ? location : "") + "," + declName);
}
/**
* get one global element
*/
public final XSElementDecl getGlobalElementDecl(String declName) {
return(XSElementDecl)fGlobalElemDecls.get(declName);
}
public final XSElementDecl getGlobalElementDecl(String declName, String location) {
return(XSElementDecl)fGlobalElemDeclsExt.get(((location != null) ? location : "") + "," + declName);
}
/**
* get one global group
*/
public final XSGroupDecl getGlobalGroupDecl(String declName) {
return(XSGroupDecl)fGlobalGroupDecls.get(declName);
}
public final XSGroupDecl getGlobalGroupDecl(String declName, String location) {
return(XSGroupDecl)fGlobalGroupDeclsExt.get(((location != null) ? location : "") + "," + declName);
}
/**
* get one global notation
*/
public final XSNotationDecl getGlobalNotationDecl(String declName) {
return(XSNotationDecl)fGlobalNotationDecls.get(declName);
}
public final XSNotationDecl getGlobalNotationDecl(String declName, String location) {
return(XSNotationDecl)fGlobalNotationDeclsExt.get(((location != null) ? location : "") + "," + declName);
}
/**
* get one global type
*/
public final XSTypeDefinition getGlobalTypeDecl(String declName) {
return(XSTypeDefinition)fGlobalTypeDecls.get(declName);
}
public final XSTypeDefinition getGlobalTypeDecl(String declName, String location) {
return(XSTypeDefinition)fGlobalTypeDeclsExt.get(((location != null) ? location : "") + "," + declName);
}
/**
* get one identity constraint
*/
public final IdentityConstraint getIDConstraintDecl(String declName) {
return(IdentityConstraint)fGlobalIDConstraintDecls.get(declName);
}
public final IdentityConstraint getIDConstraintDecl(String declName, String location) {
return(IdentityConstraint)fGlobalIDConstraintDeclsExt.get(((location != null) ? location : "") + "," + declName);
}
/**
* get one identity constraint
*/
public final boolean hasIDConstraints() {
return fGlobalIDConstraintDecls.getLength() > 0;
}
// array to store complex type decls
private static final int INITIAL_SIZE = 16;
private static final int INC_SIZE = 16;
private int fCTCount = 0;
private XSComplexTypeDecl[] fComplexTypeDecls = new XSComplexTypeDecl[INITIAL_SIZE];
private SimpleLocator[] fCTLocators = new SimpleLocator[INITIAL_SIZE];
// an array to store groups being redefined by restriction
// even-numbered elements are the derived groups, odd-numbered ones their bases
private static final int REDEFINED_GROUP_INIT_SIZE = 2;
private int fRGCount = 0;
private XSGroupDecl[] fRedefinedGroupDecls = new XSGroupDecl[REDEFINED_GROUP_INIT_SIZE];
private SimpleLocator[] fRGLocators = new SimpleLocator[REDEFINED_GROUP_INIT_SIZE/2];
// a flag to indicate whether we have checked the 3 constraints on this
// grammar.
boolean fFullChecked = false;
/**
* add one complex type decl: for later constraint checking
*/
public void addComplexTypeDecl(XSComplexTypeDecl decl, SimpleLocator locator) {
if (fCTCount == fComplexTypeDecls.length) {
fComplexTypeDecls = resize(fComplexTypeDecls, fCTCount+INC_SIZE);
fCTLocators = resize(fCTLocators, fCTCount+INC_SIZE);
}
fCTLocators[fCTCount] = locator;
fComplexTypeDecls[fCTCount++] = decl;
}
/**
* add a group redefined by restriction: for later constraint checking
*/
public void addRedefinedGroupDecl(XSGroupDecl derived, XSGroupDecl base, SimpleLocator locator) {
if (fRGCount == fRedefinedGroupDecls.length) {
// double array size each time.
fRedefinedGroupDecls = resize(fRedefinedGroupDecls, fRGCount << 1);
fRGLocators = resize(fRGLocators, fRGCount);
}
fRGLocators[fRGCount/2] = locator;
fRedefinedGroupDecls[fRGCount++] = derived;
fRedefinedGroupDecls[fRGCount++] = base;
}
/**
* get all complex type decls: for later constraint checking
*/
final XSComplexTypeDecl[] getUncheckedComplexTypeDecls() {
if (fCTCount < fComplexTypeDecls.length) {
fComplexTypeDecls = resize(fComplexTypeDecls, fCTCount);
fCTLocators = resize(fCTLocators, fCTCount);
}
return fComplexTypeDecls;
}
/**
* get the error locator of all complex type decls
*/
final SimpleLocator[] getUncheckedCTLocators() {
if (fCTCount < fCTLocators.length) {
fComplexTypeDecls = resize(fComplexTypeDecls, fCTCount);
fCTLocators = resize(fCTLocators, fCTCount);
}
return fCTLocators;
}
/**
* get all redefined groups: for later constraint checking
*/
final XSGroupDecl[] getRedefinedGroupDecls() {
if (fRGCount < fRedefinedGroupDecls.length) {
fRedefinedGroupDecls = resize(fRedefinedGroupDecls, fRGCount);
fRGLocators = resize(fRGLocators, fRGCount/2);
}
return fRedefinedGroupDecls;
}
/**
* get the error locator of all redefined groups
*/
final SimpleLocator[] getRGLocators() {
if (fRGCount < fRedefinedGroupDecls.length) {
fRedefinedGroupDecls = resize(fRedefinedGroupDecls, fRGCount);
fRGLocators = resize(fRGLocators, fRGCount/2);
}
return fRGLocators;
}
/**
* after the first-round checking, some types don't need to be checked
* against UPA again. here we trim the array to the proper size.
*/
final void setUncheckedTypeNum(int newSize) {
fCTCount = newSize;
fComplexTypeDecls = resize(fComplexTypeDecls, fCTCount);
fCTLocators = resize(fCTLocators, fCTCount);
}
// used to store all substitution group information declared in
// this namespace
private int fSubGroupCount = 0;
private XSElementDecl[] fSubGroups = new XSElementDecl[INITIAL_SIZE];
/**
* get all substitution group information: for the 3 constraint checking
*/
final XSElementDecl[] getSubstitutionGroups() {
if (fSubGroupCount < fSubGroups.length)
fSubGroups = resize(fSubGroups, fSubGroupCount);
return fSubGroups;
}
// anyType and anySimpleType: because there are so many places where
// we need direct access to these two types
private final static XSComplexTypeDecl fAnyType = new XSAnyType();
private final static XSComplexTypeDecl fAnyTypeExtended = new XSAnyTypeExtended();
private final static XSComplexTypeDecl fAnyType11 = new XS11AnyType();
public static XSComplexTypeDecl getXSAnyType(short schemaVersion) {
if (schemaVersion == Constants.SCHEMA_VERSION_1_0) {
return fAnyType;
}
else if (schemaVersion == Constants.SCHEMA_VERSION_1_1) {
return fAnyType11;
}
return fAnyTypeExtended;
}
public static boolean isAnyType(XSTypeDefinition type) {
return type == fAnyType || type == fAnyType11 || type == fAnyTypeExtended;
}
public static class XSAnyType extends XSComplexTypeDecl {
public XSAnyType () {
fName = SchemaSymbols.ATTVAL_ANYTYPE;
super.fTargetNamespace = SchemaSymbols.URI_SCHEMAFORSCHEMA;
fBaseType = this;
fDerivedBy = XSConstants.DERIVATION_RESTRICTION;
fContentType = XSComplexTypeDecl.CONTENTTYPE_MIXED;
fParticle = createParticle();
fAttrGrp = createAttrGrp();
}
// overridden methods
public void setValues(String name, String targetNamespace,
XSTypeDefinition baseType, short derivedBy, short schemaFinal,
short block, short contentType,
boolean isAbstract, XSAttributeGroupDecl attrGrp,
XSSimpleType simpleType, XSParticleDecl particle) {
// don't allow this.
}
public void setName(String name){
// don't allow this.
}
public void setIsAbstractType() {
// null implementation
}
public void setContainsTypeID() {
// null implementation
}
public void setIsAnonymous() {
// null implementation
}
public void reset() {
// null implementation
}
public XSObjectList getAnnotations() {
return XSObjectListImpl.EMPTY_LIST;
}
public XSNamespaceItem getNamespaceItem() {
return SG_SchemaNS;
}
private XSAttributeGroupDecl createAttrGrp() {
XSWildcardDecl wildcard = new XSWildcardDecl();
wildcard.fProcessContents = XSWildcardDecl.PC_LAX;
XSAttributeGroupDecl attrGrp = new XSAttributeGroupDecl();
attrGrp.fAttributeWC = wildcard;
return attrGrp;
}
private XSParticleDecl createParticle() {
// the wildcard used in anyType (content and attribute)
// the spec will change strict to skip for anyType
XSWildcardDecl wildcard = new XSWildcardDecl();
wildcard.fProcessContents = XSWildcardDecl.PC_LAX;
// the particle for the content wildcard
XSParticleDecl particleW = new XSParticleDecl();
particleW.fMinOccurs = 0;
particleW.fMaxOccurs = SchemaSymbols.OCCURRENCE_UNBOUNDED;
particleW.fType = XSParticleDecl.PARTICLE_WILDCARD;
particleW.fValue = wildcard;
// the model group of a sequence of the above particle
XSModelGroupImpl group = new XSModelGroupImpl();
group.fCompositor = XSModelGroupImpl.MODELGROUP_SEQUENCE;
group.fParticleCount = 1;
group.fParticles = new XSParticleDecl[1];
group.fParticles[0] = particleW;
// the content of anyType: particle of the above model group
XSParticleDecl particleG = new XSParticleDecl();
particleG.fType = XSParticleDecl.PARTICLE_MODELGROUP;
particleG.fValue = group;
return particleG;
}
}
private static class XS11AnyType extends XSAnyType {
public XSNamespaceItem getNamespaceItem() {
return SG_Schema11NS;
}
}
private static class XSAnyTypeExtended extends XSAnyType {
public XSNamespaceItem getNamespaceItem() {
return SG_SchemaNSExtended;
}
}
private static class BuiltinAttrDecl extends XSAttributeDecl {
public BuiltinAttrDecl(String name, String tns,
XSSimpleType type, short scope) {
fName = name;
super.fTargetNamespace = tns;
fType = type;
fScope = scope;
}
public void setValues(String name, String targetNamespace,
XSSimpleType simpleType, short constraintType, short scope,
ValidatedInfo valInfo, XSComplexTypeDecl enclosingCT) {
// ignore this call.
}
public void reset () {
// also ignore this call.
}
public XSAnnotation getAnnotation() {
return null;
}
public XSNamespaceItem getNamespaceItem() {
return SG_XSI;
}
} // class BuiltinAttrDecl
// the grammars to hold components of the schema namespace
private final static BuiltinSchemaGrammar SG_SchemaNS = new BuiltinSchemaGrammar(GRAMMAR_XS, Constants.SCHEMA_VERSION_1_0);
private final static BuiltinSchemaGrammar SG_SchemaNSExtended = new BuiltinSchemaGrammar(GRAMMAR_XS, Constants.SCHEMA_VERSION_1_0_EXTENDED);
private final static BuiltinSchemaGrammar SG_Schema11NS = new BuiltinSchemaGrammar(GRAMMAR_XS, Constants.SCHEMA_VERSION_1_1);
public final static XSSimpleType fAnySimpleType = (XSSimpleType)SG_SchemaNS.getGlobalTypeDecl(SchemaSymbols.ATTVAL_ANYSIMPLETYPE);
public final static XSSimpleType fAnyAtomicType = (XSSimpleType)SG_Schema11NS.getGlobalTypeDecl(SchemaSymbols.ATTVAL_ANYATOMICTYPE);
// the grammars to hold components of the schema-instance namespace
public final static BuiltinSchemaGrammar SG_XSI = new BuiltinSchemaGrammar(GRAMMAR_XSI, Constants.SCHEMA_VERSION_1_0);
private final static BuiltinSchemaGrammar SG_XSI11 = new BuiltinSchemaGrammar(GRAMMAR_XSI, Constants.SCHEMA_VERSION_1_1);
public static SchemaGrammar getS4SGrammar(short schemaVersion) {
if (schemaVersion == Constants.SCHEMA_VERSION_1_0) {
return SG_SchemaNS;
}
else if (schemaVersion == Constants.SCHEMA_VERSION_1_1) {
return SG_Schema11NS;
}
return SG_SchemaNSExtended;
}
public static SchemaGrammar getXSIGrammar(short schemaVersion) {
if (schemaVersion == Constants.SCHEMA_VERSION_1_1) {
return SG_XSI11;
}
return SG_XSI;
}
static final XSComplexTypeDecl[] resize(XSComplexTypeDecl[] oldArray, int newSize) {
XSComplexTypeDecl[] newArray = new XSComplexTypeDecl[newSize];
System.arraycopy(oldArray, 0, newArray, 0, Math.min(oldArray.length, newSize));
return newArray;
}
static final XSGroupDecl[] resize(XSGroupDecl[] oldArray, int newSize) {
XSGroupDecl[] newArray = new XSGroupDecl[newSize];
System.arraycopy(oldArray, 0, newArray, 0, Math.min(oldArray.length, newSize));
return newArray;
}
static final XSElementDecl[] resize(XSElementDecl[] oldArray, int newSize) {
XSElementDecl[] newArray = new XSElementDecl[newSize];
System.arraycopy(oldArray, 0, newArray, 0, Math.min(oldArray.length, newSize));
return newArray;
}
static final SimpleLocator[] resize(SimpleLocator[] oldArray, int newSize) {
SimpleLocator[] newArray = new SimpleLocator[newSize];
System.arraycopy(oldArray, 0, newArray, 0, Math.min(oldArray.length, newSize));
return newArray;
}
// XSNamespaceItem methods
// the max index / the max value of XSObject type
private static final short MAX_COMP_IDX = XSTypeDefinition.SIMPLE_TYPE;
private static final boolean[] GLOBAL_COMP = {false, // null
true, // attribute
true, // element
true, // type
false, // attribute use
true, // attribute group
true, // group
false, // model group
false, // particle
false, // wildcard
true, // idc
true, // notation
false, // annotation
false, // facet
false, // multi value facet
true, // complex type
true // simple type
};
// store a certain kind of components from all namespaces
private XSNamedMap[] fComponents = null;
private ObjectList[] fComponentsExt = null;
// store the documents and their locations contributing to this namespace
// REVISIT: use StringList and XSObjectList for there fields.
private Vector fDocuments = null;
private Vector fLocations = null;
public synchronized void addDocument(Object document, String location) {
if (fDocuments == null) {
fDocuments = new Vector();
fLocations = new Vector();
}
fDocuments.addElement(document);
fLocations.addElement(location);
}
public synchronized void removeDocument(int index) {
if (fDocuments != null &&
index >= 0 &&
index < fDocuments.size()) {
fDocuments.removeElementAt(index);
fLocations.removeElementAt(index);
}
}
/**
* [schema namespace]
* @see [schema namespace]
* @return The target namespace of this item.
*/
public String getSchemaNamespace() {
return fTargetNamespace;
}
// annotation support
synchronized DOMParser getDOMParser() {
if (fDOMParser != null) {
DOMParser parser = (DOMParser) fDOMParser.get();
if (parser != null) {
return parser;
}
}
// REVISIT: when schema handles XML 1.1, will need to
// revisit this (and the practice of not prepending an XML decl to the annotation string
XML11Configuration config = new XML11Configuration(fSymbolTable);
// note that this should never produce errors or require
// entity resolution, so just a barebones configuration with
// a couple of feature set will do fine
config.setFeature(Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACES_FEATURE, true);
config.setFeature(Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE, false);
DOMParser parser = new DOMParser(config);
try {
parser.setFeature(Constants.XERCES_FEATURE_PREFIX + Constants.DEFER_NODE_EXPANSION_FEATURE, false);
}
catch (SAXException exc) {}
fDOMParser = new SoftReference(parser);
return parser;
}
synchronized SAXParser getSAXParser() {
if (fSAXParser != null) {
SAXParser parser = (SAXParser) fSAXParser.get();
if (parser != null) {
return parser;
}
}
// REVISIT: when schema handles XML 1.1, will need to
// revisit this (and the practice of not prepending an XML decl to the annotation string
XML11Configuration config = new XML11Configuration(fSymbolTable);
// note that this should never produce errors or require
// entity resolution, so just a barebones configuration with
// a couple of feature set will do fine
config.setFeature(Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACES_FEATURE, true);
config.setFeature(Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE, false);
SAXParser parser = new SAXParser(config);
fSAXParser = new SoftReference(parser);
return parser;
}
/**
* [schema components]: a list of top-level components, i.e. element
* declarations, attribute declarations, etc.
* @param objectType The type of the declaration, i.e.
* ELEMENT_DECLARATION
. Note that
* XSTypeDefinition.SIMPLE_TYPE
and
* XSTypeDefinition.COMPLEX_TYPE
can also be used as the
* objectType
to retrieve only complex types or simple
* types, instead of all types.
* @return A list of top-level definition of the specified type in
* objectType
or an empty XSNamedMap
if no
* such definitions exist.
*/
public synchronized XSNamedMap getComponents(short objectType) {
if (objectType <= 0 || objectType > MAX_COMP_IDX ||
!GLOBAL_COMP[objectType]) {
return XSNamedMapImpl.EMPTY_MAP;
}
if (fComponents == null)
fComponents = new XSNamedMap[MAX_COMP_IDX+1];
// get the hashtable for this type of components
if (fComponents[objectType] == null) {
SymbolHash table = null;
switch (objectType) {
case XSConstants.TYPE_DEFINITION:
case XSTypeDefinition.COMPLEX_TYPE:
case XSTypeDefinition.SIMPLE_TYPE:
table = fGlobalTypeDecls;
break;
case XSConstants.ATTRIBUTE_DECLARATION:
table = fGlobalAttrDecls;
break;
case XSConstants.ELEMENT_DECLARATION:
table = fGlobalElemDecls;
break;
case XSConstants.ATTRIBUTE_GROUP:
table = fGlobalAttrGrpDecls;
break;
case XSConstants.MODEL_GROUP_DEFINITION:
table = fGlobalGroupDecls;
break;
case XSConstants.NOTATION_DECLARATION:
table = fGlobalNotationDecls;
break;
case XSConstants.IDENTITY_CONSTRAINT:
table = this.fGlobalIDConstraintDecls;
break;
}
// for complex/simple types, create a special implementation,
// which take specific types out of the hash table
if (objectType == XSTypeDefinition.COMPLEX_TYPE ||
objectType == XSTypeDefinition.SIMPLE_TYPE) {
fComponents[objectType] = new XSNamedMap4Types(fTargetNamespace, table, objectType);
}
else {
fComponents[objectType] = new XSNamedMapImpl(fTargetNamespace, table);
}
}
return fComponents[objectType];
}
public synchronized ObjectList getComponentsExt(short objectType) {
if (objectType <= 0 || objectType > MAX_COMP_IDX ||
!GLOBAL_COMP[objectType]) {
return ObjectListImpl.EMPTY_LIST;
}
if (fComponentsExt == null)
fComponentsExt = new ObjectList[MAX_COMP_IDX+1];
// get the hashtable for this type of components
if (fComponentsExt[objectType] == null) {
SymbolHash table = null;
switch (objectType) {
case XSConstants.TYPE_DEFINITION:
case XSTypeDefinition.COMPLEX_TYPE:
case XSTypeDefinition.SIMPLE_TYPE:
table = fGlobalTypeDeclsExt;
break;
case XSConstants.ATTRIBUTE_DECLARATION:
table = fGlobalAttrDeclsExt;
break;
case XSConstants.ELEMENT_DECLARATION:
table = fGlobalElemDeclsExt;
break;
case XSConstants.ATTRIBUTE_GROUP:
table = fGlobalAttrGrpDeclsExt;
break;
case XSConstants.MODEL_GROUP_DEFINITION:
table = fGlobalGroupDeclsExt;
break;
case XSConstants.NOTATION_DECLARATION:
table = fGlobalNotationDeclsExt;
break;
case XSConstants.IDENTITY_CONSTRAINT:
table = this.fGlobalIDConstraintDeclsExt;
break;
}
Object[] entries = table.getEntries();
fComponentsExt[objectType] = new ObjectListImpl(entries, entries.length);
}
return fComponentsExt[objectType];
}
public synchronized void resetComponents() {
fComponents = null;
fComponentsExt = null;
}
/**
* Convenience method. Returns a top-level simple or complex type
* definition.
* @param name The name of the definition.
* @return An XSTypeDefinition
or null if such definition
* does not exist.
*/
public XSTypeDefinition getTypeDefinition(String name) {
return getGlobalTypeDecl(name);
}
/**
* Convenience method. Returns a top-level attribute declaration.
* @param name The name of the declaration.
* @return A top-level attribute declaration or null if such declaration
* does not exist.
*/
public XSAttributeDeclaration getAttributeDeclaration(String name) {
return getGlobalAttributeDecl(name);
}
/**
* Convenience method. Returns a top-level element declaration.
* @param name The name of the declaration.
* @return A top-level element declaration or null if such declaration
* does not exist.
*/
public XSElementDeclaration getElementDeclaration(String name) {
return getGlobalElementDecl(name);
}
/**
* Convenience method. Returns a top-level attribute group definition.
* @param name The name of the definition.
* @return A top-level attribute group definition or null if such
* definition does not exist.
*/
public XSAttributeGroupDefinition getAttributeGroup(String name) {
return getGlobalAttributeGroupDecl(name);
}
/**
* Convenience method. Returns a top-level model group definition.
*
* @param name The name of the definition.
* @return A top-level model group definition definition or null if such
* definition does not exist.
*/
public XSModelGroupDefinition getModelGroupDefinition(String name) {
return getGlobalGroupDecl(name);
}
/**
* Convenience method. Returns a top-level notation declaration.
*
* @param name The name of the declaration.
* @return A top-level notation declaration or null if such declaration
* does not exist.
*/
public XSNotationDeclaration getNotationDeclaration(String name) {
return getGlobalNotationDecl(name);
}
public XSIDCDefinition getIDCDefinition(String name) {
return getIDConstraintDecl(name);
}
/**
* [document location]
* @see [document location]
* @return a list of document information item
*/
public StringList getDocumentLocations() {
return new StringListImpl(fLocations);
}
/**
* Return an XSModel
that represents components in this schema
* grammar.
*
* @return an XSModel
representing this schema grammar
*/
public XSModel toXSModel() {
return new XSModelImpl(new SchemaGrammar[]{this});
}
public XSModel toXSModel(XSGrammar[] grammars) {
if (grammars == null || grammars.length == 0)
return toXSModel();
int len = grammars.length;
boolean hasSelf = false;
for (int i = 0; i < len; i++) {
if (grammars[i] == this) {
hasSelf = true;
break;
}
}
SchemaGrammar[] gs = new SchemaGrammar[hasSelf ? len : len+1];
for (int i = 0; i < len; i++)
gs[i] = (SchemaGrammar)grammars[i];
if (!hasSelf)
gs[len] = this;
return new XSModelImpl(gs);
}
/**
* @see org.apache.xerces.xs.XSNamespaceItem#getAnnotations()
*/
public XSObjectList getAnnotations() {
if (fNumAnnotations == 0) {
return XSObjectListImpl.EMPTY_LIST;
}
return new XSObjectListImpl(fAnnotations, fNumAnnotations);
}
public void addAnnotation(XSAnnotationImpl annotation) {
if (annotation == null) {
return;
}
if (fAnnotations == null) {
fAnnotations = new XSAnnotationImpl[2];
}
else if (fNumAnnotations == fAnnotations.length) {
XSAnnotationImpl[] newArray = new XSAnnotationImpl[fNumAnnotations << 1];
System.arraycopy(fAnnotations, 0, newArray, 0, fNumAnnotations);
fAnnotations = newArray;
}
fAnnotations[fNumAnnotations++] = annotation;
}
public void setImmutable(boolean isImmutable) {
fIsImmutable = isImmutable;
}
public boolean isImmutable() {
return fIsImmutable;
}
} // class SchemaGrammar