| Methods Summary |
|---|
| 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 | addComplexTypeDecl(XSComplexTypeDecl decl, org.apache.xerces.impl.xs.util.SimpleLocator locator)add one complex type decl: for later constraint checking
if (fCTCount == fComplexTypeDecls.length) {
fComplexTypeDecls = resize(fComplexTypeDecls, fCTCount+INC_SIZE);
fCTLocators = resize(fCTLocators, fCTCount+INC_SIZE);
}
fCTLocators[fCTCount] = locator;
fComplexTypeDecls[fCTCount++] = decl;
|
| public synchronized void | addDocument(java.lang.Object document, java.lang.String location)
if (fDocuments == null) {
fDocuments = new Vector();
fLocations = new Vector();
}
fDocuments.addElement(document);
fLocations.addElement(location);
|
| public void | addGlobalAttributeDecl(XSAttributeDecl decl)register one global attribute
fGlobalAttrDecls.put(decl.fName, decl);
|
| public void | addGlobalAttributeGroupDecl(XSAttributeGroupDecl decl)register one global attribute group
fGlobalAttrGrpDecls.put(decl.fName, decl);
|
| public void | addGlobalElementDecl(XSElementDecl decl)register one global element
fGlobalElemDecls.put(decl.fName, 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 | addGlobalGroupDecl(XSGroupDecl decl)register one global group
fGlobalGroupDecls.put(decl.fName, decl);
|
| public void | addGlobalNotationDecl(XSNotationDecl decl)register one global notation
fGlobalNotationDecls.put(decl.fName, decl);
|
| public void | addGlobalTypeDecl(org.apache.xerces.xs.XSTypeDefinition decl)register one global type
fGlobalTypeDecls.put(decl.getName(), decl);
|
| public final void | addIDConstraintDecl(XSElementDecl elmDecl, org.apache.xerces.impl.xs.identity.IdentityConstraint decl)register one identity constraint
elmDecl.addIDConstraint(decl);
fGlobalIDConstraintDecls.put(decl.getIdentityConstraintName(), decl);
|
| public void | addRedefinedGroupDecl(XSGroupDecl derived, XSGroupDecl base, org.apache.xerces.impl.xs.util.SimpleLocator locator)add a group redefined by restriction: for later constraint checking
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;
|
| public org.apache.xerces.xs.XSObjectList | getAnnotations()
return new XSObjectListImpl(fAnnotations, fNumAnnotations);
|
| public org.apache.xerces.xs.XSAttributeDeclaration | getAttributeDeclaration(java.lang.String name)Convenience method. Returns a top-level attribute declaration.
return getGlobalAttributeDecl(name);
|
| public org.apache.xerces.xs.XSAttributeGroupDefinition | getAttributeGroup(java.lang.String name)Convenience method. Returns a top-level attribute group definition.
return getGlobalAttributeGroupDecl(name);
|
| public synchronized org.apache.xerces.xs.XSNamedMap | getComponents(short objectType)[schema components]: a list of top-level components, i.e. element
declarations, attribute declarations, etc.
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;
}
// 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];
|
| synchronized org.apache.xerces.parsers.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;
|
| public org.apache.xerces.xs.StringList | getDocumentLocations()[document location]
return new StringListImpl(fLocations);
|
| public org.apache.xerces.xs.XSElementDeclaration | getElementDeclaration(java.lang.String name)Convenience method. Returns a top-level element declaration.
return getGlobalElementDecl(name);
|
| public final XSAttributeDecl | getGlobalAttributeDecl(java.lang.String declName)get one global attribute
return(XSAttributeDecl)fGlobalAttrDecls.get(declName);
|
| public final XSAttributeGroupDecl | getGlobalAttributeGroupDecl(java.lang.String declName)get one global attribute group
return(XSAttributeGroupDecl)fGlobalAttrGrpDecls.get(declName);
|
| public final XSElementDecl | getGlobalElementDecl(java.lang.String declName)get one global element
return(XSElementDecl)fGlobalElemDecls.get(declName);
|
| public final XSGroupDecl | getGlobalGroupDecl(java.lang.String declName)get one global group
return(XSGroupDecl)fGlobalGroupDecls.get(declName);
|
| public final XSNotationDecl | getGlobalNotationDecl(java.lang.String declName)get one global notation
return(XSNotationDecl)fGlobalNotationDecls.get(declName);
|
| public final org.apache.xerces.xs.XSTypeDefinition | getGlobalTypeDecl(java.lang.String declName)get one global type
return(XSTypeDefinition)fGlobalTypeDecls.get(declName);
|
| public org.apache.xerces.xni.grammars.XMLGrammarDescription | getGrammarDescription()
return fGrammarDescription;
|
| public final org.apache.xerces.impl.xs.identity.IdentityConstraint | getIDConstraintDecl(java.lang.String declName)get one identity constraint
return(IdentityConstraint)fGlobalIDConstraintDecls.get(declName);
|
| public java.util.Vector | getImportedGrammars()
return fImported;
|
| public org.apache.xerces.xs.XSModelGroupDefinition | getModelGroupDefinition(java.lang.String name)Convenience method. Returns a top-level model group definition.
return getGlobalGroupDecl(name);
|
| public org.apache.xerces.xs.XSNotationDeclaration | getNotationDeclaration(java.lang.String name)Convenience method. Returns a top-level notation declaration.
return getGlobalNotationDecl(name);
|
| final org.apache.xerces.impl.xs.util.SimpleLocator[] | getRGLocators()get the error locator of all redefined groups
if (fRGCount < fRedefinedGroupDecls.length) {
fRedefinedGroupDecls = resize(fRedefinedGroupDecls, fRGCount);
fRGLocators = resize(fRGLocators, fRGCount/2);
}
return fRGLocators;
|
| final XSGroupDecl[] | getRedefinedGroupDecls()get all redefined groups: for later constraint checking
if (fRGCount < fRedefinedGroupDecls.length) {
fRedefinedGroupDecls = resize(fRedefinedGroupDecls, fRGCount);
fRGLocators = resize(fRGLocators, fRGCount/2);
}
return fRedefinedGroupDecls;
|
| synchronized org.apache.xerces.parsers.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;
|
| public java.lang.String | getSchemaNamespace()[schema namespace]
return fTargetNamespace;
|
| final XSElementDecl[] | getSubstitutionGroups()get all substitution group information: for the 3 constraint checking
if (fSubGroupCount < fSubGroups.length)
fSubGroups = resize(fSubGroups, fSubGroupCount);
return fSubGroups;
|
| public final java.lang.String | getTargetNamespace()Returns this grammar's target namespace.
return fTargetNamespace;
|
| public org.apache.xerces.xs.XSTypeDefinition | getTypeDefinition(java.lang.String name)Convenience method. Returns a top-level simple or complex type
definition.
return getGlobalTypeDecl(name);
|
| final org.apache.xerces.impl.xs.util.SimpleLocator[] | getUncheckedCTLocators()get the error locator of all complex type decls
if (fCTCount < fCTLocators.length) {
fComplexTypeDecls = resize(fComplexTypeDecls, fCTCount);
fCTLocators = resize(fCTLocators, fCTCount);
}
return fCTLocators;
|
| final XSComplexTypeDecl[] | getUncheckedComplexTypeDecls()get all complex type decls: for later constraint checking
if (fCTCount < fComplexTypeDecls.length) {
fComplexTypeDecls = resize(fComplexTypeDecls, fCTCount);
fCTLocators = resize(fCTLocators, fCTCount);
}
return fComplexTypeDecls;
|
| public final boolean | hasIDConstraints()get one identity constraint
return fGlobalIDConstraintDecls.getLength() > 0;
|
| public boolean | isNamespaceAware()
return true;
|
| 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 org.apache.xerces.impl.xs.util.SimpleLocator[] | resize(org.apache.xerces.impl.xs.util.SimpleLocator[] oldArray, int newSize)
SimpleLocator[] newArray = new SimpleLocator[newSize];
System.arraycopy(oldArray, 0, newArray, 0, Math.min(oldArray.length, newSize));
return newArray;
|
| public void | setImportedGrammars(java.util.Vector importedGrammars)
fImported = importedGrammars;
|
| final void | setUncheckedTypeNum(int newSize)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.
fCTCount = newSize;
fComplexTypeDecls = resize(fComplexTypeDecls, fCTCount);
fCTLocators = resize(fCTLocators, fCTCount);
|
| public org.apache.xerces.xs.XSModel | toXSModel()Return an XSModel that represents components in this schema
grammar.
return new XSModelImpl(new SchemaGrammar[]{this});
|
| public org.apache.xerces.xs.XSModel | toXSModel(org.apache.xerces.xni.grammars.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);
|
