com.saxonica.ee.schema

Class SchemaCompiler

java.lang.Object

com.saxonica.ee.schema.SchemaCompiler

All Implemented Interfaces:

ISchemaCompiler

public class SchemaCompiler
extends java.lang.Object
implements ISchemaCompiler

A SchemaCompiler is capable of reading source schema documents and converting them into collections of schema components. The Compiler holds all the options relating to schema compilation, including maintaining information about the schema documents involved in a compilation.

A default SchemaCompiler is available as part of the EnterpriseConfiguration

Since:

8.9

Constructor Summary

Constructors

Constructor and Description
SchemaCompiler(EnterpriseConfiguration config) Create a SchemaCompiler

Method Summary

Modifier and Type	Method and Description
void	addPendingTypeCheck(IdentityConstraintReference constraint, SchemaType contextItemType) Register an identity constraint that needs to be type-checked
void	compile() y In deferred validation mode, validate and compile the accumulated schema components.
SchemaDocument	doChameleonTransformation(javax.xml.transform.Source input, SchemaElement referrer) Do the chameleon transformation on a source schema document
SchemaDocument	doOverrideTransformation(javax.xml.transform.Source input, SchemaElement referrer) Do the override transformation on a source schema document
void	error(java.lang.String message, Location locator) Report an error
EnterpriseConfiguration	getConfiguration() Get the configuration
int	getErrorCount() Test whether errors have been reported
javax.xml.transform.ErrorListener	getErrorListener() Get the ErrorListener used in this configuration.
XSDSchema	getExistingSchemaDocument(java.lang.String systemId, java.lang.String targetNamespace) Get the root element of the tree representing a schema document that has already been read
int	getLanguageVersion() Get the XSD langauge version allowed
NamePool	getNamePool() Get the NamePool
int[]	getOccurrenceLimits() Get the occurrence limits previously set using setOccurrenceLimits (or the default)
PipelineConfiguration	getPipelineConfiguration() Get the pipeline configuration
PreparedSchema	getPreparedSchema() Get the PreparedSchema.
SchemaURIResolver	getSchemaURIResolver() Get the user-defined SchemaURIResolver for resolving URIs used in "import schema" declarations; if none has been explicitly set, returns the standard schema URI resolver.
boolean	isBeingRead(java.lang.String systemId) Determine whether a particular URI is currently being read
boolean	isDeferredValidationMode() Ask if deferred validation mode is currently set
NamespaceResolver	makeNamespaceResolver(NodeInfo node) Make a namespace resolver for a particular element in the schema.
void	markAsRead(java.lang.String systemId, XSDSchema schema) Mark a document as having been read
java.lang.String	readInlineSchema(NodeInfo root, java.lang.String expected, javax.xml.transform.ErrorListener errorListener) Read an inline schema from a stylesheet
void	readMultipleSchemas(PipelineConfiguration pipe, java.lang.String baseURI, java.util.Collection<java.lang.String> schemaLocations, java.lang.String expected) Read schemas from a list of schema locations.
java.lang.String	readSchema(PipelineConfiguration pipe, java.lang.String baseURI, java.lang.String schemaLocation, java.lang.String expected) Read a schema document from a given schema location.
boolean	reportMissingComponent(java.lang.String componentType, StructuredQName componentName) Register that there is an unresolved component reference
void	setBeingRead(java.lang.String systemId) Mark a URI as currently being read
void	setDeferredValidationMode(boolean defer) Set deferred validation mode.
void	setErrorListener(javax.xml.transform.ErrorListener listener) Set the ErrorListener to be used in this compiler.
void	setLanguageVersion(int version) Set the XSD language version allowed.
void	setOccurrenceLimits(int minimum, int maximum) Set the occurrence limits to be used when compiling a finite state automaton.
void	setPipelineConfiguration(PipelineConfiguration pipelineConfiguration) Set the pipeline configuration
void	setPreparedSchema(PreparedSchema schema) Set the PreparedSchema.
void	typeCheckIdentityConstraints() Do all the pending type-checking
PreparedSchema	validate(SchemaDocument doc) Validate the schema represented by a schema document.
void	warning(java.lang.String message, Location locator) Report a warning

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SchemaCompiler

public SchemaCompiler(EnterpriseConfiguration config)

Create a SchemaCompiler

Parameters:

config - the Saxon Configuration

Method Detail

getConfiguration

public EnterpriseConfiguration getConfiguration()

Get the configuration

Returns:

the configuration (which is always schema-aware)

getNamePool

public NamePool getNamePool()

Get the NamePool

Returns:

the name pool

setLanguageVersion

public void setLanguageVersion(int version)

Set the XSD language version allowed.

Parameters:

version - the language version allowed. Default is Configuration.XSD10; to use facilities in XML Schema 1.1, the value must be set to Configuration.XSD11

getLanguageVersion

public int getLanguageVersion()

Get the XSD langauge version allowed

Returns:

the XSD language version. Default is Configuration.XSD10; to use facilities in XML Schema 1.1, the value must be set to Configuration.XSD11

setDeferredValidationMode

public void setDeferredValidationMode(boolean defer)

Set deferred validation mode. In this mode, schema documents loaded using the readSchema() interfaces are not fully compiled and validated until the compile() method is called.

Parameters:

defer - set to true to select deferred validation mode

isDeferredValidationMode

public boolean isDeferredValidationMode()

Ask if deferred validation mode is currently set

Returns:

true if deferred validation mode has been set

setPreparedSchema

public void setPreparedSchema(PreparedSchema schema)

Set the PreparedSchema. Used when validating a schema loaded using the SchemaModelLoader

Parameters:

schema - the schema that has been loaded

getPreparedSchema

public PreparedSchema getPreparedSchema()

Get the PreparedSchema. This is a callback available only during a schema validation episode

Returns:

the PreparedSchema containing all the schema components

getErrorListener

public javax.xml.transform.ErrorListener getErrorListener()

Get the ErrorListener used in this configuration. If no ErrorListener has been supplied explicitly, the default ErrorListener is used.

Returns:

the ErrorListener.

Since:

8.9

setErrorListener

public void setErrorListener(javax.xml.transform.ErrorListener listener)

Set the ErrorListener to be used in this compiler. The ErrorListener is informed of all errors detected during schema processing.

Parameters:

listener - the ErrorListener to be used

Since:

8.9

getErrorCount

public int getErrorCount()

Test whether errors have been reported

Returns:

the number of errors reported

setOccurrenceLimits

public void setOccurrenceLimits(int minimum,
                                int maximum)

Set the occurrence limits to be used when compiling a finite state automaton.

Parameters:

minimum - The highest value of minOccurs that will be strictly enforced. If the actual value of minOccurs in a schema is higher than this value, it will be treated as if this value had been specified. The default is 100.

maximum - The highest value of maxOccurs that will be strictly enforced. If the actual value of maxOccurs in a schema is higher than this value, it will be treated as if "unbounded" had been specified. The default is 250.

Since:

8.9

getOccurrenceLimits

public int[] getOccurrenceLimits()

Get the occurrence limits previously set using setOccurrenceLimits (or the default)

Returns:

an array of two integers, the minimum occurrence limit and the maximum occurrence limit

Since:

8.9

setBeingRead

public void setBeingRead(java.lang.String systemId)

Mark a URI as currently being read

Parameters:

systemId - the URI of the schema document being read

isBeingRead

public boolean isBeingRead(java.lang.String systemId)

Determine whether a particular URI is currently being read

Parameters:

systemId - the URI of the document in question

Returns:

true if the document is currently being read

markAsRead

public void markAsRead(java.lang.String systemId,
                       XSDSchema schema)

Mark a document as having been read

Parameters:

systemId - the URI of the schema document that has been read

schema - the root element of the schema document constructed from this URI

getExistingSchemaDocument

public XSDSchema getExistingSchemaDocument(java.lang.String systemId,
                                           java.lang.String targetNamespace)

Get the root element of the tree representing a schema document that has already been read

Parameters:

systemId - the URI of the required schema document

targetNamespace - the expected namespace. If the schema document was previously read but chameleoned into a different namespace, we read it again

Returns:

the root element of the tree representing this schema document

getPipelineConfiguration

public PipelineConfiguration getPipelineConfiguration()

Get the pipeline configuration

Returns:

the pipeline configuration

setPipelineConfiguration

public void setPipelineConfiguration(PipelineConfiguration pipelineConfiguration)

Set the pipeline configuration

Parameters:

pipelineConfiguration - the pipeline configuration

getSchemaURIResolver

public SchemaURIResolver getSchemaURIResolver()

Get the user-defined SchemaURIResolver for resolving URIs used in "import schema" declarations; if none has been explicitly set, returns the standard schema URI resolver.

Returns:

the SchemaURIResolver

readSchema

public java.lang.String readSchema(PipelineConfiguration pipe,
                                   java.lang.String baseURI,
                                   java.lang.String schemaLocation,
                                   java.lang.String expected)
                            throws SchemaException

Read a schema document from a given schema location. If deferredValidationMode is not set, the schema document will be fully validated and integrated with other schema documents previously loaded

Parameters:

pipe - the pipeline configuration

baseURI - the base URI for resolving relative URIs

schemaLocation - the location "hint" where to find the schema document. Must not be null.

expected - the target namespace expected; null if there is no expectation

Returns:

the actual target namespace of the schema

Throws:

SchemaException

readMultipleSchemas

public void readMultipleSchemas(PipelineConfiguration pipe,
                                java.lang.String baseURI,
                                java.util.Collection<java.lang.String> schemaLocations,
                                java.lang.String expected)
                         throws SchemaException

Read schemas from a list of schema locations. Note, these must contain source XSD documents (compiled SCM documents are not acceptable)

Parameters:

pipe - the PipelineConfiguration

baseURI - the base URI for resolving relative URIs

schemaLocations - the list of location "hints" where to find the schema document. Must not be null.

expected - the target namespace expected in each of the schema documents; null if there is no expected namespace

Throws:

SchemaException - if reading a schema document fails

readInlineSchema

public java.lang.String readInlineSchema(NodeInfo root,
                                         java.lang.String expected,
                                         javax.xml.transform.ErrorListener errorListener)
                                  throws SchemaException

Read an inline schema from a stylesheet

Parameters:

root - the xs:schema element in the stylesheet

expected - the target namespace expected; "" if there is no expectation

errorListener - The destination for error messages. May be null, in which case the errorListener registered with this Configuration is used.

Returns:

the actual target namespace of the schema

Throws:

SchemaException - if the inline schema is in error

compile

public void compile()
             throws SchemaException

y In deferred validation mode, validate and compile the accumulated schema components. If validation succeeds, the schema components will be added to the cache held by the Configuration.

Throws:

SchemaException - if any of the schema components is invalid, or if the collection of schema components as a whole is invalid, or if there are components present that conflict with components already present in the cache held by the Configuration.

validate

public PreparedSchema validate(SchemaDocument doc)
                        throws SchemaException

Validate the schema represented by a schema document. This method validates the schema components associated with this schema document: that is, the components defined in this document, together with any components referenced by these components if they have not already been validated.

Parameters:

doc - the schema document to be validated

Returns:

schema the schema, if it is valid

Throws:

SchemaException - if the schema is invalid

reportMissingComponent

public boolean reportMissingComponent(java.lang.String componentType,
                                      StructuredQName componentName)

Register that there is an unresolved component reference

Parameters:

componentType - the type of component, for example attributeGroup

componentName - the name of the component

Returns:

true if this is the first report that this component is missing

error

public void error(java.lang.String message,
                  Location locator)
           throws SchemaException

Report an error

Parameters:

message - the error message

locator - the location of the error

Throws:

SchemaException - if the supplied ErrorListener throws an exception

warning

public void warning(java.lang.String message,
                    Location locator)

Report a warning

Parameters:

message - the warning message

locator - the location of the error

addPendingTypeCheck

public void addPendingTypeCheck(IdentityConstraintReference constraint,
                                SchemaType contextItemType)

Register an identity constraint that needs to be type-checked

Parameters:

constraint - the constraint to be checked

contextItemType - the type of the context node for the XPath expression to be checked

typeCheckIdentityConstraints

public void typeCheckIdentityConstraints()
                                  throws SchemaException

Do all the pending type-checking

Throws:

SchemaException - if any of the checks fail

doChameleonTransformation

public SchemaDocument doChameleonTransformation(javax.xml.transform.Source input,
                                                SchemaElement referrer)
                                         throws SchemaException

Do the chameleon transformation on a source schema document

Parameters:

input - the included schema document to be transformeed

referrer - the xs:include element referencing this schema document

Returns:

the transformed schema document

Throws:

SchemaException - if the transformation fails

doOverrideTransformation

public SchemaDocument doOverrideTransformation(javax.xml.transform.Source input,
                                               SchemaElement referrer)
                                        throws SchemaException

Do the override transformation on a source schema document

Parameters:

input - the schema document being overridden

referrer - the xs:override element referencing this schema document

Returns:

the transformed schema document

Throws:

SchemaException - if the transformation fails

makeNamespaceResolver

public NamespaceResolver makeNamespaceResolver(NodeInfo node)

Make a namespace resolver for a particular element in the schema. Makes a copy, to avoid preventing the schema document tree being garbage-collected. Reuses the most recent one if the namespace context is the same, to reduce memory usage

Parameters:

node - the node in the schema document whose namespace context is required