Package com.saxonica.ee.schema

## Class SchemaCompiler

- java.lang.Object
- - com.saxonica.ee.schema.SchemaCompiler

-     public class SchemaCompiler
      extends java.lang.Object

  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 | Description
    --- | ---
    `SchemaCompiler​(EnterpriseConfiguration config)` | Create a SchemaCompiler

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `addPendingTypeCheck​(IdentityConstraintReference constraint, SchemaType contextItemType)` | Register an identity constraint that needs to be type-checked
    `void` | `checkAllAutomata()` | Perform all subsumption checks that have been previously requested.
    `void` | `compile()` | In deferred validation mode, validate and compile the accumulated schema components.
    `SchemaDocument` | `doChameleonTransformation​(NodeInfo input, SchemaElement referrer)` | Do the chameleon transformation on a source schema document
    `SchemaDocument` | `doOverrideTransformation​(NodeInfo 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
    `ErrorReporter` | `getErrorReporter()` | Get the ErrorReporter 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` | `isAllowDanglingReferences()` | Ask whether dangling references are allowed.
    `boolean` | `isBeingRead​(java.lang.String systemId)` | Determine whether a particular URI is currently being read
    `void` | `makeAllAutomata()` | Create determinized finite state automata for all complex types for which this has been previously requested
    `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, ErrorReporter errorReporter)` | 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` | `scheduleAutomaton​(UserComplexType type)` | Schedule the task of creating a finite state automaton for a given complex type.
    `void` | `scheduleAutomatonCheck​(UserComplexType base, UserComplexType sub)` | Schedule a subsumption check: that is, checking that the finite state automaton for one complex type subsumes the FSA for another complex type
    `void` | `setBeingRead​(java.lang.String systemId)` | Mark a URI as currently being read
    `void` | `setErrorReporter​(ErrorReporter reporter)` | Set the ErrorReporter 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`

    - #### 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

    - #### getErrorReporter

          public ErrorReporter getErrorReporter()

      Get the ErrorReporter used in this configuration. If no ErrorReporter has been supplied explicitly, the default ErrorReporter is used.
      Returns:
        the ErrorReporter.
      Since:
        8.9. Changed in 10.0 to use ErrorReporter rather than ErrorListener

    - #### setErrorReporter

          public void setErrorReporter​(ErrorReporter reporter)

      Set the ErrorReporter to be used in this compiler. The ErrorReporter is informed of all errors detected during schema processing.
      Parameters:
        `reporter` - the ErrorReporter to be used
      Since:
        8.9. Changed in 10.0 to use ErrorReporter rather than ErrorListener

    - #### 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

    - #### isAllowDanglingReferences

          public boolean isAllowDanglingReferences()

      Ask whether dangling references are allowed. Returns false by default; returns true if the configuration property `Feature.ALLOW_UNRESOLVED_SCHEMA_COMPONENTS` is set.
      Returns:
        true if the presence of unresolved schema components should not cause the schema to be treated as invalid. Instead, the schema is "repaired" such that it can be used for validation, provided that the absent schema components are not actually required for a particular validation episode.

    - #### 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,
                                                   ErrorReporter errorReporter)
                                            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
        `errorReporter` - 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

      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)

      Report an error
      Parameters:
        `message` - the error message
        `locator` - the location of the error

    - #### 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​(NodeInfo 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​(NodeInfo 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

    - #### scheduleAutomaton

          public void scheduleAutomaton​(UserComplexType type)

      Schedule the task of creating a finite state automaton for a given complex type. This is done at the end, because there may be multiple requests for the same complex type, and doing it once saves effort
      Parameters:
        `type` - the complex type for which an FSA is needed

    - #### scheduleAutomatonCheck

          public void scheduleAutomatonCheck​(UserComplexType base,
                                             UserComplexType sub)

      Schedule a subsumption check: that is, checking that the finite state automaton for one complex type subsumes the FSA for another complex type
      Parameters:
        `base` - the base (super-) complex type
        `sub` - the derived complex type

    - #### makeAllAutomata

          public void makeAllAutomata()
                               throws SchemaException

      Create determinized finite state automata for all complex types for which this has been previously requested
      Throws:
        `SchemaException` - if creation of any FSA fails

    - #### checkAllAutomata

          public void checkAllAutomata()
                                throws SchemaException

      Perform all subsumption checks that have been previously requested. This can only be done after the determinized FSA's have been constructed.
      Throws:
        `SchemaException` - if any restricted type is not validly derived from its base type