SchemaTypeLoader
A finite set of XML Schema component definitions.
Every SchemaComponent
such as a
SchemaType
,
SchemaGlobalElement
,
SchemaGlobalAttribute
,
SchemaModelGroup
,
SchemaAttributeGroup
, or
SchemaIdentityConstraint
, is defined in exactly one
SchemaTypeSystem. (See
SchemaComponent.getTypeSystem()
.)
A single SchemaTypeSystem can include definitions
from any number of namespaces; one SchemaTypeSystem consists simply
of a set of component definitions that were compiled together.
Since every component is defined in a single SchemaTypeSystem, no
SchemaTypeSystem other than XmlBeans.getBuiltinTypeSystem()
includes any of the the built-in types. That means
you cannot ordinarily load instances using a single
SchemaTypeSystem by itself. Instead, you will want to combine a path of
SchemaTypeSystems together using
XmlBeans.typeLoaderUnion(SchemaTypeLoader[])
to form a SchemaTypeLoader that can be used for loading instances.
For example, the following code compiles the schema in myXSDFile
in the presence of only the minimal builtin type system.
The resulting SchemaTypeSystem sts
contains only the definitions
from myXSD file. In order to load and validate an instance within
the context of those types, we must next construct a
SchemaTypeLoader
stl
that contains both
the builtin type system and the types defined within the myXSD file.
SchemaTypeSystem sts = XmlBeans.compileXsd(new XmlObject[] { XmlObject.Factory.parse(myXSDFile) }, XmlBeans.getBuiltinTypeSystem(), null); SchemaTypeLoader stl = XmlBeans.typeLoaderUnion(new SchemaTypeLoader[] { sts, XmlBeans.getBuiltinTypeSystem() }); XmlObject mydoc = stl.parse(instanceFile, null, null); System.out.println("Document valid: " + mydoc.validate());
As you can see, for working with instances, you typically want to
work with a SchemaTypeLoader constructed from a path rather than
a solitary SchemaTypeSystem. See XmlBeans.loadXsd(XmlObject[])
for
a convenient alternative to
XmlBeans.compileXsd(XmlObject[], SchemaTypeLoader, XmlOptions)
.
A SchemaTypeSystem is useful when you need to enumerate the exact set of component definitions derived from a set of XSD files, for example, when you are analyzing the contents of the XSD files themselves. Here is how to use a SchemaTypeSystem to inspect a set of schema definitions:
XmlBeans.compileXsd(XmlObject[], SchemaTypeLoader, XmlOptions)
to compile any number
of schema files. If the schema files are valid, result will
be a SchemaTypeSystem that contains all the component definitions
from those files. It will contain no other component definitions.
SchemaComponent.getTypeSystem()
on
a precompiled schema component to discover the SchemaTypeSystem
within which that component was originally compiled.
SchemaTypeSystem.globalTypes()
for all the global type definitions.
SchemaTypeSystem.globalElements()
for all the global element definitions.
SchemaTypeSystem.globalAttributes()
for all the global attribute definitions.
SchemaTypeSystem.modelGroups()
for all the named model group definitions.
SchemaTypeSystem.attributeGroups()
for all the attribute group definitions.
SchemaTypeSystem.documentTypes()
returns all the document types.
SchemaTypeSystem.attributeTypes()
returns all the attribute types.
A document type is a type that contains a single global element; there is one document type for each global element definition in a SchemaTypeSystem. In an instance document, only the root XmlObject can have a document type as its type.
Similarly, an attribute type is a type that contains a single global attribute, and there is one attribute type for each global attribute definition in a SchemaTypeSystem. It is possible to have a root XmlObject representing a fragment whose type is an attribute type, but attribute types are present mainly for symmetry and to simplify code such as the type-tree-walking code below.
The global component methods above only provide a view of the top-level
components of a SchemaTypeSystem and do not include any nested
definitions. To view all the nested definitions, you will want to
traverse the entire tree of SchemaType
defintions within a
SchemaTypeSystem by examining the
SchemaType.getAnonymousTypes()
within each
SchemaType
recursively.
The following code is a standard treewalk that visits every
SchemaType
in the SchemaTypeSystem once, including nested
definitions.
List allSeenTypes = new ArrayList(); allSeenTypes.addAll(Arrays.asList(typeSystem.documentTypes())); allSeenTypes.addAll(Arrays.asList(typeSystem.attributeTypes())); allSeenTypes.addAll(Arrays.asList(typeSystem.globalTypes())); for (int i = 0; i < allSeenTypes.size(); i++) { SchemaType sType = (SchemaType)allSeenTypes.get(i); System.out.prinlnt("Visiting " + sType.toString()); allSeenTypes.addAll(Arrays.asList(sType.getAnonymousTypes())); }
Related Topics
SchemaType
SchemaTypeLoader
XmlBeans.compileXsd(XmlObject[], SchemaTypeLoader, XmlOptions)
XmlBeans.typeLoaderUnion(SchemaTypeLoader[])
XmlBeans.getBuiltinTypeSystem()
SchemaTypeLoader
Method Summary |
public |
|
public |
|
public |
|
public |
|
public |
|
public |
|
public |
|
public |
|
public |
|
public void |
|
public |
|
public void |
|
public |
|
Method Detail |
public SchemaAttributeGroup
[] attributeGroups()
Returns the attribute groups defined in this loader.
public SchemaType
[] attributeTypes()
Returns the attribute types defined in this loader.
public SchemaType
[] documentTypes()
Returns the document types defined in this loader.
public ClassLoader
getClassLoader()
Returns the classloader used by this loader for resolving types.
public String
getName()
Returns the name of this loader.
public SchemaGlobalAttribute
[] globalAttributes()
Returns the global attributes defined in this loader.
public SchemaGlobalElement
[] globalElements()
Returns the global elements defined in this loader.
public SchemaType
[] globalTypes()
Returns the global types defined in this loader.
public SchemaModelGroup
[] modelGroups()
Returns the model groups defined in this loader.
public void resolve()Initializes a type system (resolves all handles within the type system).
publicLocates a type, element, or attribute using the handle.SchemaComponent
resolveHandle(String
handle)
public void saveToDirectory(File
classDir)
Saves this type to a directory.
publicLocates a type, element, or attribute using the handle.SchemaType
typeForHandle(String
handle)