com.saxonica.config

## Class EnterpriseConfiguration

- java.lang.Object
- - net.sf.saxon.Configuration
  - - com.saxonica.config.ProfessionalConfiguration
    - - com.saxonica.config.EnterpriseConfiguration

- All Implemented Interfaces:
    Serializable, SourceResolver, NotationSet

      public final class EnterpriseConfiguration
      extends ProfessionalConfiguration

  A subclass of Configuration that defines a schema-aware processor. This contains helper methods invoked both at compile time and at run-time to perform operations that are allowed only in a schema-aware processor; the superclass Configuration contains the dummy versions of these methods used in a non-schema-aware processor. The interface is designed so that the calling classes contain no references to classes that are available only in the schema-aware product.

  Applications should avoid using this class directly, and should instead access all the necessary functionality through its superclass, `Configuration`.
  See Also:
    Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `EnterpriseConfiguration.SurrogateSchema` A SurrogateSchema is a dummy schema object that is stored in the schema cache while the schema for a given namespace is being processed.

    - ### Nested classes/interfaces inherited from class net.sf.saxon.Configuration

      `Configuration.LicenseFeature`

  - ### Field Summary

    - ### Fields inherited from class net.sf.saxon.Configuration

      `collectionResolver, configurationClass, DO_NOT_RECOVER, JAVA_APPLICATION, optimizationLevel, optimizer, RECOVER_SILENTLY, RECOVER_WITH_WARNINGS, softwareEdition, typeHierarchy, vendorFunctionLibrary, XML_SCHEMA, XML10, XML11, XPATH, XQUERY, XSD10, XSD11, xsdVersion, XSLT`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `EnterpriseConfiguration()` Create an EnterpriseConfiguration

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addSchema(PreparedSchema pschema)` Add a schema (a collection of schema components) to the cache
    `void` | `addSchemaForBuiltInNamespace(String namespace)` Add a built-in schema for a given namespace.
    `void` | `addSchemaSource(Source schemaSource, ErrorListener errorListener)` Load a schema, which will be available for use by all subsequent operations using this EnterpriseConfiguration.
    `void` | `addSurrogateSchema(String namespace)` Put a temporary schema marker in the cache, to indicate that a schema for a given namespace is being processed.
    `void` | `checkLicensedFeature(int feature, String name)` Check whether a particular feature is licensed, with a fatal error if it is not
    `void` | `checkTypeDerivationIsOK(SchemaType derived, SchemaType base, int block)` Check that a type is validly derived from another type, following the rules for the Schema Component Constraint "Is Type Derivation OK (Simple)" (3.14.6) or "Is Type Derivation OK (Complex)" (3.4.6) as appropriate.
    `void` | `clearSchemaCache()` Remove all schema components that have been loaded into this Configuration.
    `void` | `declareBuiltInExtensionElementNamespaces()` Declare the built-in XSLT extension element namespaces
    `void` | `exportComponents(Receiver out)` Export a precompiled Schema Component Model containing all the components (except built-in components) that have been loaded into this Processor.
    `Receiver` | `getAnnotationStripper(Receiver destination)` Add to a pipeline a receiver that strips all type annotations.
    `SchemaDeclaration` | `getAttributeDeclaration(int fingerprint)` Get a global attribute declaration
    `Object` | `getConfigurationProperty(String name)` Get a property of the configuration
    `Collection<GlobalParam>` | `getDeclaredSchemaParameters()` Get the set of saxon:param schema parameters declared in the schema held by this Configuration.
    `Receiver` | `getDocumentValidator(Receiver receiver, String systemId, ParseOptions validationOptions)` Get a document-level validator to add to a Receiver pipeline
    `String` | `getEditionCode()` Get the edition code identifying this configuration: "HE", "PE" or "EE"
    `SchemaDeclaration` | `getElementDeclaration(int fingerprint)` Get a global element declaration
    `SchemaDeclaration` | `getElementDeclaration(StructuredQName qName)` Get a global element declaration.
    `SequenceReceiver` | `getElementValidator(SequenceReceiver receiver, ParseOptions options, int locationId)` Get a Receiver that can be used to validate an element, and that passes the validated element on to a target receiver.
    `Iterator<? extends SchemaType>` | `getExtensionsOfType(SchemaType type)` Get the set of complex types that have been defined as extensions of a given type.
    `Set` | `getImportedNamespaces()` Get the set of namespaces of imported schemas
    `int` | `getNamespaceStatus(String namespace)` Get the status of a particular schema namespace.
    `int[]` | `getOccurrenceLimits()` Get the occurrence limits previously set using setOccurrenceLimits (or the default)
    `FunctionItem` | `getSchemaAsFunctionItem()` Get information about the schema in the form of a function item.
    `FunctionItem` | `getSchemaComponentAsFunctionItem(String kind, QNameValue name)` Get information about the schema in the form of a function item.
    `SchemaType` | `getSchemaType(int fingerprint)` Get the top-level schema type with a given fingerprint.
    `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.
    `int` | `getSiblingPosition(NodeInfo node, NodeTest nodeTest, int max)` Get the sibling position of a node: specifically, count how many preceding siblings of a node satisfy the nodetest.
    `PreparedSchema` | `getSuperSchema()` Get the SuperSchema, containing references to all names defined in all known schemas
    `TypeHierarchy` | `getTypeHierarchy()` Get the TypeHierarchy: a cache holding type information
    `void` | `importComponents(Source source)` Import a precompiled Schema Component Model from a given Source.
    `boolean` | `isDeclaredNotation(String uri, String local)` Ask whether a given notation has been declared in the schema
    `boolean` | `isSchemaAvailable(String targetNamespace)` Determine whether the Configuration contains a cached schema for a given target namespace
    `boolean` | `isSealedNamespace(String namespace)` Test whether a schema namespace is sealed.
    `Sequence` | `makeClosure(Expression expression, int ref, XPathContext context)` Make a Closure, given the expected reference count
    `FilterFactory` | `makeDocumentProjector(PathMap.PathMapRoot map)` Create a document projector for a given path map.
    `Sequence` | `makeSequenceExtent(Expression expression, int ref, XPathContext context)` Make a SequenceExtent, given the expected reference count
    `Receiver` | `makeStreamingTransformer(XPathContext context, Mode mode)` Create a streaming transformer
    `StyleNodeFactory` | `makeStyleNodeFactory()` Factory method to make a StyleNodeFactory, used for constructing elements in a stylesheet document
    `protected void` | `needEnterpriseEdition()` Throw an error indicating that a request cannot be satisfied because it requires the enterprise edition of Saxon.
    `ExpressionParser` | `newExpressionParser(String language, boolean updating, DecimalValue languageVersion)` Make an expression Parser for a specified version of XPath or XQuery
    `PendingUpdateList` | `newPendingUpdateList()` Get a new Pending Update List
    `SchemaCompiler` | `newSchemaCompiler()` Make a SchemaCompiler which can be used to compile schema documents.
    `StaticQueryContext` | `newStaticQueryContext()` Get a new StaticQueryContext (which is also the factory class for creating a query parser)
    `Optimizer` | `obtainOptimizer()` Factory method to get an Optimizer
    `void` | `processResultDocument(ResultDocument instruction, Expression content, XPathContext context)` Process an xsl:result-document instruction.
    `String` | `readInlineSchema(NodeInfo root, String expected, ErrorListener errorListener)` Read an inline schema from a stylesheet
    `void` | `readMultipleSchemas(PipelineConfiguration pipe, String baseURI, Collection<String> schemaLocations, String expected)` Read schema documents from a list of schema locations
    `String` | `readSchema(PipelineConfiguration pipe, String baseURI, String schemaLocation, String expected)` Read a schema from a given schema location
    `void` | `removeSchema(String namespace)` Remove the schema for a given namespace.
    `void` | `sealNamespace(String namespace)` Mark a schema namespace as being sealed.
    `void` | `setConfigurationProperty(String name, Object value)` Set a property of the configuration.
    `protected void` | `setLicensedFeatures()`
    `void` | `setNamespaceStatus(String namespace, int status)` Set the status of a particular schema namespace.
    `void` | `setOccurrenceLimits(int minimum, int maximum)` Set the occurrence limits to be used when compiling a finite state automaton.
    `void` | `setParameterizedURIResolver()` Set the URIResolver to a URI resolver that allows query parameters after the URI, and in the case of Saxon-EE, that inteprets the file extension .ptree
    `void` | `setSchemaURIResolver(SchemaURIResolver resolver)` Set a user-defined SchemaURIResolver for resolving URIs used in "import schema" declarations.
    `protected boolean` | `testFeature(int feature)` Determine if a particular feature is licensed.
    `SimpleType` | `validateAttribute(int nameCode, CharSequence value, int validation)` Validate an attribute value (XSLT only)

    - ### Methods inherited from class com.saxonica.config.ProfessionalConfiguration

      `addExtensionBinders, declareBuiltInExtensionFunctions, displayLicenseMessage, getExtensionBinder, getExtensionElementFactory, getFeature, getVendorFunctionLibrary, importLicenseDetails, isLicensedFeature, isLicenseFound, isLicenseNotFound, isSchemaAware, loadLicense, makeOuterForExpression, makeProfessionalConfiguration, makeUnconstructedDocument, makeUnconstructedElement, newUserFunction, readConfigurationFile, resolveSource, setExtensionBinder, setExtensionElementNamespace, supplyLicenseKey`

    - ### Methods inherited from class net.sf.saxon.Configuration

      `addSchemaSource, buildDocument, buildDocument, finalize, getBooleanProperty, getCharacterSetFactory, getClass, getCollationMap, getCollationURIResolver, getCollectionURIResolver, getConfiguration, getConversionContext, getConversionRules, getDebugger, getDefaultCollection, getDefaultCountry, getDefaultLanguage, getDefaultSerializationProperties, getDefaultStaticQueryContext, getDefaultXsltCompilerInfo, getDocumentNumberAllocator, getDOMLevel, getDynamicLoader, getErrorListener, getExternalObjectModel, getExternalObjectModel, getExternalObjectModels, getExternalObjectType, getGlobalDocumentPool, getHostLanguage, getInstance, getIntegratedFunctionLibrary, getLocale, getLocalizerFactory, getMessageEmitterClass, getModuleURIResolver, getNameChecker, getNamePool, getOutputURIResolver, getParseOptions, getPlatform, getProcessor, getProductTitle, getRecoveryPolicy, getSchemaValidationMode, getSerializerFactory, getSourceParser, getSourceParserClass, getSourceResolver, getStandardErrorOutput, getStandardModuleURIResolver, getStripsWhiteSpace, getStyleParser, getStyleParserClass, getSystemURIResolver, getTraceListener, getTraceListenerClass, getTreeModel, getURIResolver, getXMLVersion, getXsdVersion, init, instantiateClassName, internalSetBooleanProperty, isAllowStreamabilityExtensions, isCompatible, isCompileWithTracing, isExpandAttributeDefaults, isGenerateByteCode, isLineNumbering, isStripsAllWhiteSpace, isTiming, isValidation, isValidationWarnings, isVersionWarning, isXIncludeAware, loadSchema, locateResource, makeConfigurationClass, makeEmitter, makeLicensedConfiguration, makeNumberer, makeParser, makePipelineConfiguration, makePlatform, makeSchemaAwareConfiguration, makeSlotManager, makeTraceListener, makeTraceListener, makeURIResolver, newConfiguration, readConfiguration, registerExtensionFunction, registerExternalObjectModel, reportFatalError, requireBoolean, requireString, reuseSourceParser, reuseStyleParser, setBooleanProperty, setCollationURIResolver, setCollectionURIResolver, setCompileWithTracing, setConversionRules, setDebugger, setDefaultCollection, setDefaultCountry, setDefaultLanguage, setDefaultSerializationProperties, setDocumentNumberAllocator, setDOMLevel, setDynamicLoader, setErrorListener, setExpandAttributeDefaults, setHostLanguage, setLineNumbering, setLocalizerFactory, setMessageEmitterClass, setModuleURIResolver, setModuleURIResolver, setNamePool, setOutputURIResolver, setProcessor, setRecoveryPolicy, setSchemaValidationMode, setSerializerFactory, setSoftwareEdition, setSourceParserClass, setSourceResolver, setStandardErrorOutput, setStripsAllWhiteSpace, setStripsWhiteSpace, setStyleParserClass, setTiming, setTraceListener, setTraceListenerClass, setTreeModel, setURIResolver, setValidation, setValidationWarnings, setVersionWarning, setXIncludeAware, setXMLVersion, unravel`

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### EnterpriseConfiguration

          public EnterpriseConfiguration()

      Create an EnterpriseConfiguration

  - ### Method Detail

    - #### getEditionCode

          public String getEditionCode()

      Get the edition code identifying this configuration: "HE", "PE" or "EE"
      Overrides:
        `getEditionCode` in class `ProfessionalConfiguration`
      Returns:
        the code identifying the Saxon edition associated with this configuration

    - #### getSiblingPosition

          public int getSiblingPosition(NodeInfo node,
                               NodeTest nodeTest,
                               int max)
                                 throws XPathException

      Get the sibling position of a node: specifically, count how many preceding siblings of a node satisfy the nodetest. This method is included here so it can be subclassed to handle streamed nodes.
      Overrides:
        `getSiblingPosition` in class `Configuration`
      Parameters:
        `node` - the starting node, which is assumed to satisfy the node test
        `nodeTest` - the node test
      Returns:
        the number of preceding siblings that satisfy the node test, plus one, unless the number exceeds max, in which case return some number greater than or equal to max.
      Throws:
        `XPathException`

    - #### setConfigurationProperty

          public void setConfigurationProperty(String name,
                                      Object value)

      Set a property of the configuration. This method underpins the setAttribute() method of the TransformerFactory implementation, and is provided to enable setting of Configuration properties using URIs without instantiating a TransformerFactory: specifically, this may be useful when running XQuery, and it is also used by the Validator API
      Overrides:
        `setConfigurationProperty` in class `ProfessionalConfiguration`
      Parameters:
        `name` - the URI identifying the property to be set. See the class `FeatureKeys` for constants representing the property names that can be set.
        `value` - the value of the property
      Throws:
        `IllegalArgumentException` - if the property name is not recognized or if the value is not a valid value for the named property

    - #### getConfigurationProperty

          public Object getConfigurationProperty(String name)

      Get a property of the configuration
      Overrides:
        `getConfigurationProperty` in class `ProfessionalConfiguration`
      Parameters:
        `name` - the name of the required property. See the class `FeatureKeys` for constants representing the property names that can be requested.
      Returns:
        the value of the property
      Throws:
        `IllegalArgumentException` - thrown if the property is not one that Saxon recognizes.

    - #### checkLicensedFeature

          public void checkLicensedFeature(int feature,
                                  String name)
                                    throws LicenseException

      Check whether a particular feature is licensed, with a fatal error if it is not
      Overrides:
        `checkLicensedFeature` in class `ProfessionalConfiguration`
      Parameters:
        `feature` - the feature in question, identified by a constant in class `Configuration.LicenseFeature`
        `name` - the name of the required feature, for use in diagnostics
      Throws:
        `LicenseException` - if the feature is not licensed

    - #### setLicensedFeatures

          protected void setLicensedFeatures()

      Overrides:
        `setLicensedFeatures` in class `ProfessionalConfiguration`

    - #### testFeature

          protected boolean testFeature(int feature)

      Determine if a particular feature is licensed. Note, this method should only be called if it is known that the license file has been loaded. If it is not known whether the license file has been loaded, use the method `Configuration.isLicensedFeature(int)` which will load the license when necessary.
      Overrides:
        `testFeature` in class `ProfessionalConfiguration`
      Parameters:
        `feature` - the feature in question, identified by a constant in class {#LicenseFeature}
      Returns:
        true if the feature is available, otherwise false

    - #### needEnterpriseEdition

          protected void needEnterpriseEdition()

      Throw an error indicating that a request cannot be satisfied because it requires the enterprise edition of Saxon. If we get this far, we've got Saxon-EE loaded, and an EnterpriseConfiguration; the problem must therefore be with the license file.
      Overrides:
        `needEnterpriseEdition` in class `Configuration`

    - #### makeStyleNodeFactory

          public StyleNodeFactory makeStyleNodeFactory()

      Factory method to make a StyleNodeFactory, used for constructing elements in a stylesheet document
      Overrides:
        `makeStyleNodeFactory` in class `ProfessionalConfiguration`
      Returns:
        the StyleNodeFactory used in this Configuration

    - #### getTypeHierarchy

          public TypeHierarchy getTypeHierarchy()

      Get the TypeHierarchy: a cache holding type information
      Overrides:
        `getTypeHierarchy` in class `ProfessionalConfiguration`
      Returns:
        the type hierarchy cache

    - #### setParameterizedURIResolver

          public void setParameterizedURIResolver()

      Set the URIResolver to a URI resolver that allows query parameters after the URI, and in the case of Saxon-EE, that inteprets the file extension .ptree
      Overrides:
        `setParameterizedURIResolver` in class `Configuration`

    - #### setSchemaURIResolver

          public void setSchemaURIResolver(SchemaURIResolver resolver)

      Set a user-defined SchemaURIResolver for resolving URIs used in "import schema" declarations.
      Overrides:
        `setSchemaURIResolver` in class `Configuration`
      Parameters:
        `resolver` - the URI resolver used for import schema declarations

    - #### newSchemaCompiler

          public SchemaCompiler newSchemaCompiler()

      Make a SchemaCompiler which can be used to compile schema documents. The initial settings of the SchemaCompiler are a snapshot of the settings in the EnterpriseConfiguration. Other methods in EnterpriseConfiguration provided for the purpose of compiling schemas are retained for compatibility reasons.
      Returns:
        a new SchemaCompiler object
      Since:
        8.9

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

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

    - #### 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.
      Overrides:
        `getSchemaURIResolver` in class `Configuration`
      Returns:
        the user-defined SchemaURIResolver for resolving URIs

    - #### readSchema

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

      Read a schema from a given schema location
      Overrides:
        `readSchema` in class `Configuration`
      Parameters:
        `pipe` - the PipelineConfiguration
        `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` - if the schema cannot be read

    - #### readMultipleSchemas

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

      Read schema documents from a list of schema locations
      Overrides:
        `readMultipleSchemas` in class `Configuration`
      Parameters:
        `pipe` - the pipeline configuration
        `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 an error occurs

    - #### readInlineSchema

          public String readInlineSchema(NodeInfo root,
                                String expected,
                                ErrorListener errorListener)
                                  throws SchemaException

      Read an inline schema from a stylesheet
      Overrides:
        `readInlineSchema` in class `Configuration`
      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 schema cannot be processed

    - #### addSchemaSource

          public void addSchemaSource(Source schemaSource,
                             ErrorListener errorListener)
                               throws SchemaException

      Load a schema, which will be available for use by all subsequent operations using this EnterpriseConfiguration.
      Overrides:
        `addSchemaSource` in class `Configuration`
      Parameters:
        `schemaSource` - the JAXP Source object identifying the schema document to be loaded
        `errorListener` - the ErrorListener to be notified of any errors in the schema. If null, the configuration's errorListener is used
      Throws:
        `SchemaException` - if the schema cannot be read or parsed or if it is invalid

    - #### addSchema

          public void addSchema(PreparedSchema pschema)
                         throws SchemaException

      Add a schema (a collection of schema components) to the cache
      Parameters:
        `pschema` - The schema to be added
      Throws:
        `SchemaException` - if the schema cannot be added because components in the schema are incompatible with components already in the cache

    - #### addSurrogateSchema

          public void addSurrogateSchema(String namespace)

      Put a temporary schema marker in the cache, to indicate that a schema for a given namespace is being processed. Used to detect circularities.

      This method is intended for internal use

      Parameters:
        `namespace` - the target namespace of the schema

    - #### addSchemaForBuiltInNamespace

          public void addSchemaForBuiltInNamespace(String namespace)

      Add a built-in schema for a given namespace. This is a no-op if the configuration is not schema-aware
      Overrides:
        `addSchemaForBuiltInNamespace` in class `Configuration`
      Parameters:
        `namespace` - the namespace. Currently built-in schemas are available for the XML and FN namespaces

    - #### getNamespaceStatus

          public int getNamespaceStatus(String namespace)

      Get the status of a particular schema namespace.
      Parameters:
        `namespace` - the Namespace URI whose status is required (supply "" for the non-namespace)
      Returns:
        one of `PreparedSchema.NAMESPACE_KNOWN`, `PreparedSchema.NAMESPACE_UNKNOWN`, `PreparedSchema.NAMESPACE_UNDER_CONSTRUCTION`, `PreparedSchema.NAMESPACE_SEALED`

    - #### setNamespaceStatus

          public void setNamespaceStatus(String namespace,
                                int status)

      Set the status of a particular schema namespace.
      Parameters:
        `namespace` - the Namespace URI whose status is required (supply "" for the non-namespace)
        `status` - one of `PreparedSchema.NAMESPACE_KNOWN`, `PreparedSchema.NAMESPACE_UNKNOWN`, `PreparedSchema.NAMESPACE_UNDER_CONSTRUCTION`, `PreparedSchema.NAMESPACE_SEALED`

    - #### isSchemaAvailable

          public boolean isSchemaAvailable(String targetNamespace)

      Determine whether the Configuration contains a cached schema for a given target namespace
      Overrides:
        `isSchemaAvailable` in class `Configuration`
      Parameters:
        `targetNamespace` - the target namespace of the schema being sought (supply "" for the unnamed namespace)
      Returns:
        true if the schema for this namespace is available, false if not.

    - #### removeSchema

          public void removeSchema(String namespace)

      Remove the schema for a given namespace. This is done if it is found to be invalid. Note that this does not actually remove the schema components in this namespace; all it does is to mark the namespace as removed, which means that a new attempt to load a schema for this namespace is able to succeed.
      Parameters:
        `namespace` - the namespace of the schema to be removed

    - #### getImportedNamespaces

          public Set getImportedNamespaces()

      Get the set of namespaces of imported schemas
      Overrides:
        `getImportedNamespaces` in class `Configuration`
      Returns:
        a Set whose members are the namespaces of all schemas in the schema cache, as String objects

    - #### getSuperSchema

          public PreparedSchema getSuperSchema()

      Get the SuperSchema, containing references to all names defined in all known schemas
      Returns:
        the PreparedSchema containing the schema components for all loaded target namespaces

    - #### sealNamespace

          public void sealNamespace(String namespace)

      Mark a schema namespace as being sealed. This is done when components from this namespace are first used for validating a source document or compiling a source document or query. Once a namespace has been sealed, it is not permitted to change the schema components in that namespace by redefining them, deriving new types by extension, or adding to their substitution groups.
      Overrides:
        `sealNamespace` in class `Configuration`
      Parameters:
        `namespace` - the namespace URI of the components to be sealed

    - #### isSealedNamespace

          public boolean isSealedNamespace(String namespace)

      Test whether a schema namespace is sealed. Once a namespace has been sealed, it is not permitted to change the schema components in that namespace by redefining them, deriving new types by extension, or adding to their substitution groups.
      Parameters:
        `namespace` - the namespace URI of the components to be tested. Supply "" for the no-namespace.
      Returns:
        true if this namespace has been sealed, otherwise false

    - #### getDeclaredSchemaParameters

          public Collection<GlobalParam> getDeclaredSchemaParameters()

      Get the set of saxon:param schema parameters declared in the schema held by this Configuration.
      Overrides:
        `getDeclaredSchemaParameters` in class `Configuration`
      Returns:
        the set of parameters. May return null if none have been declared.

    - #### getExtensionsOfType

          public Iterator<? extends SchemaType> getExtensionsOfType(SchemaType type)

      Get the set of complex types that have been defined as extensions of a given type. Note that we do not seal the schema namespace, so this list is not necessarily final; we must assume that new extensions of built-in simple types can be added at any time
      Overrides:
        `getExtensionsOfType` in class `Configuration`
      Parameters:
        `type` - the type whose extensions are required
      Returns:
        an iterator over the types that are derived from the given type by extension

    - #### importComponents

          public void importComponents(Source source)
                                throws XPathException

      Import a precompiled Schema Component Model from a given Source. The schema components derived from this schema document are added to the cache of schema components maintained by this SchemaManager
      Overrides:
        `importComponents` in class `Configuration`
      Parameters:
        `source` - the XML file containing the schema component model, as generated by a previous call on `exportComponents(net.sf.saxon.event.Receiver)`
      Throws:
        `XPathException` - if an error occurs

    - #### exportComponents

          public void exportComponents(Receiver out)
                                throws XPathException

      Export a precompiled Schema Component Model containing all the components (except built-in components) that have been loaded into this Processor.
      Overrides:
        `exportComponents` in class `Configuration`
      Parameters:
        `out` - the destination to recieve the precompiled Schema Component Model in the form of an XML document
      Throws:
        `XPathException` - if a failure occurs

    - #### clearSchemaCache

          public void clearSchemaCache()

      Remove all schema components that have been loaded into this Configuration. This method must not be used if any processes (such as stylesheet or query compilations or executions) are currently active. In a multi-threaded environment, it is the user's responsibility to ensure that this method is not called unless it is safe to do so.
      Overrides:
        `clearSchemaCache` in class `Configuration`

    - #### getSchemaAsFunctionItem

          public FunctionItem getSchemaAsFunctionItem()

      Get information about the schema in the form of a function item. Supports the extension function saxon:schema
      Overrides:
        `getSchemaAsFunctionItem` in class `Configuration`
      Returns:
        a function item corresponding to the Schema (whole-schema) component

    - #### getSchemaComponentAsFunctionItem

          public FunctionItem getSchemaComponentAsFunctionItem(String kind,
                                                      QNameValue name)
                                                        throws XPathException

      Get information about the schema in the form of a function item. Supports the extension function saxon:schema
      Overrides:
        `getSchemaComponentAsFunctionItem` in class `Configuration`
      Parameters:
        `kind` - the component kind, e.g. "element declaration"
        `name` - the component name
      Returns:
        a function item corresponding to the selected component, or null if it does not exist.
      Throws:
        `XPathException` - if the first argument does not identify a valid kind of component

    - #### getElementDeclaration

          public SchemaDeclaration getElementDeclaration(int fingerprint)

      Get a global element declaration
      Overrides:
        `getElementDeclaration` in class `Configuration`
      Parameters:
        `fingerprint` - the NamePool fingerprint of the name of the required element declaration
      Returns:
        the element declaration whose name matches the given fingerprint, or null if no element declaration with this name has been registered.

    - #### getElementDeclaration

          public SchemaDeclaration getElementDeclaration(StructuredQName qName)

      Get a global element declaration.
      Overrides:
        `getElementDeclaration` in class `Configuration`
      Parameters:
        `qName` - the name of the required element declaration
      Returns:
        the element declaration whose name matches the given fingerprint, or null if no element declaration with this name has been registered.

    - #### getAttributeDeclaration

          public SchemaDeclaration getAttributeDeclaration(int fingerprint)

      Get a global attribute declaration
      Overrides:
        `getAttributeDeclaration` in class `Configuration`
      Parameters:
        `fingerprint` - the namepool fingerprint of the required attribute declaration
      Returns:
        the attribute declaration whose name matches the given fingerprint, or null if no element declaration with this name has been registered.

    - #### getSchemaType

          public SchemaType getSchemaType(int fingerprint)

      Get the top-level schema type with a given fingerprint.
      Overrides:
        `getSchemaType` in class `Configuration`
      Parameters:
        `fingerprint` - the fingerprint of the schema type
      Returns:
        the schema type , or null if there is none with this name.

    - #### isDeclaredNotation

          public boolean isDeclaredNotation(String uri,
                                   String local)

      Ask whether a given notation has been declared in the schema
      Specified by:
        `isDeclaredNotation` in interface `NotationSet`
      Overrides:
        `isDeclaredNotation` in class `Configuration`
      Parameters:
        `uri` - the targetNamespace of the notation
        `local` - the local part of the notation name
      Returns:
        true if the notation has been declared, false if not
      Since:
        9.3

    - #### checkTypeDerivationIsOK

          public void checkTypeDerivationIsOK(SchemaType derived,
                                     SchemaType base,
                                     int block)
                                       throws SchemaException

      Check that a type is validly derived from another type, following the rules for the Schema Component Constraint "Is Type Derivation OK (Simple)" (3.14.6) or "Is Type Derivation OK (Complex)" (3.4.6) as appropriate.
      Overrides:
        `checkTypeDerivationIsOK` in class `Configuration`
      Parameters:
        `derived` - the derived type
        `base` - the base type; the algorithm tests whether derivation from this type is permitted
        `block` - the derivations that are blocked by the relevant element declaration
      Throws:
        `SchemaException` - if the derivation is not allowed

    - #### getDocumentValidator

          public Receiver getDocumentValidator(Receiver receiver,
                                      String systemId,
                                      ParseOptions validationOptions)

      Get a document-level validator to add to a Receiver pipeline
      Overrides:
        `getDocumentValidator` in class `Configuration`
      Parameters:
        `receiver` - The receiver to which events should be sent after validation
        `systemId` - the base URI of the document being validated
        `validationOptions` - Supplies options relevant to XSD validation
      Returns:
        A Receiver to which events can be sent for validation

    - #### getElementValidator

          public SequenceReceiver getElementValidator(SequenceReceiver receiver,
                                             ParseOptions options,
                                             int locationId)
                                               throws XPathException

      Get a Receiver that can be used to validate an element, and that passes the validated element on to a target receiver. If validation is not supported, the returned receiver will be the target receiver.
      Overrides:
        `getElementValidator` in class `Configuration`
      Parameters:
        `receiver` - the target receiver to receive the validated element; its pipelineConfiguration must be initialized.
        `options` - options affecting the way schema validation is done
        `locationId` - identifies the location of the element within its source document (or, if preferred, the location of the instruction requesting validation), relative to the LocationProvider in the PipelineConfiguration of the receiver
      Returns:
        The newly created receiver, which performs the validation and passes the validated elements on to the target receiver.
      Throws:
        `XPathException` - if a validator for the element cannot be created

    - #### validateAttribute

          public SimpleType validateAttribute(int nameCode,
                                     CharSequence value,
                                     int validation)
                                       throws ValidationException

      Validate an attribute value (XSLT only)
      Overrides:
        `validateAttribute` in class `Configuration`
      Parameters:
        `nameCode` - the name of the attribute
        `value` - the value of the attribute as a string
        `validation` - STRICT or LAX
      Returns:
        an int, containing the type annotation to apply to the attribute node
      Throws:
        `ValidationException` - if the value is invalid

    - #### getAnnotationStripper

          public Receiver getAnnotationStripper(Receiver destination)

      Add to a pipeline a receiver that strips all type annotations. This has a null implementation in the Saxon-B product, because type annotations can never arise.
      Overrides:
        `getAnnotationStripper` in class `Configuration`
      Parameters:
        `destination` - the Receiver that events will be written to after whitespace stripping
      Returns:
        the Receiver to which events should be sent for stripping

    - #### newStaticQueryContext

          public StaticQueryContext newStaticQueryContext()

      Get a new StaticQueryContext (which is also the factory class for creating a query parser)
      Overrides:
        `newStaticQueryContext` in class `ProfessionalConfiguration`
      Returns:
        a new StaticQueryContext

    - #### newExpressionParser

          public ExpressionParser newExpressionParser(String language,
                                             boolean updating,
                                             DecimalValue languageVersion)

      Make an expression Parser for a specified version of XPath or XQuery
      Overrides:
        `newExpressionParser` in class `ProfessionalConfiguration`
      Parameters:
        `language` - set to "XP" (XPath) or "XQ" (XQuery)
        `updating` - indicates whether or not XQuery update syntax may be used. Note that XQuery Update is supported only in Saxon-EE
        `languageVersion` - the required version (e.g "1.0", "1.1"). The old version numbers for XPath 2.1 and XQuery 1.1 are recognized for the time being.
      Returns:
        the QueryParser
      Throws:
        `UnsupportedOperationException` - if a parser that supports update syntax is requested on Saxon-B

    - #### newPendingUpdateList

          public PendingUpdateList newPendingUpdateList()

      Get a new Pending Update List
      Overrides:
        `newPendingUpdateList` in class `Configuration`
      Returns:
        the new Pending Update List

    - #### makeDocumentProjector

          public FilterFactory makeDocumentProjector(PathMap.PathMapRoot map)

      Create a document projector for a given path map.
      Overrides:
        `makeDocumentProjector` in class `Configuration`
      Parameters:
        `map` - the path map used to control document projection
      Returns:
        a factory for a push filter that implements document projection

    - #### makeStreamingTransformer

          public Receiver makeStreamingTransformer(XPathContext context,
                                          Mode mode)
                                            throws XPathException

      Create a streaming transformer
      Overrides:
        `makeStreamingTransformer` in class `Configuration`
      Parameters:
        `context` - the initial XPath context
        `mode` - the initial mode, which must be a streaming mode
      Returns:
        a Receiver to which the streamed input document will be pushed
      Throws:
        `XPathException` - if a streaming transformer cannot be created (which is always the case in Saxon-HE and Saxon-PE)

    - #### obtainOptimizer

          public Optimizer obtainOptimizer()

      Factory method to get an Optimizer
      Overrides:
        `obtainOptimizer` in class `Configuration`
      Returns:
        the optimizer used in this configuration, which is created if necessary

    - #### processResultDocument

          public void processResultDocument(ResultDocument instruction,
                                   Expression content,
                                   XPathContext context)
                                     throws XPathException

      Process an xsl:result-document instruction. The Saxon-HE version of this method simply executes the instruction. The Saxon-EE version starts a new thread, and executes the instruction in that thread.
      Overrides:
        `processResultDocument` in class `Configuration`
      Parameters:
        `instruction` - the instruction to be executed
        `content` - the expression that defines the content of the new result document
        `context` - the evaluation context
      Throws:
        `XPathException` - if any dynamic error occurs

    - #### makeClosure

          public Sequence makeClosure(Expression expression,
                             int ref,
                             XPathContext context)
                               throws XPathException

      Make a Closure, given the expected reference count
      Overrides:
        `makeClosure` in class `Configuration`
      Parameters:
        `expression` - the expression to be evaluated
        `ref` - the (nominal) number of times the value of the expression is required
        `context` - the XPath dynamic evaluation context
      Returns:
        the constructed Closure
      Throws:
        `XPathException` - if a failure occurs constructing the Closure

    - #### makeSequenceExtent

          public Sequence makeSequenceExtent(Expression expression,
                                    int ref,
                                    XPathContext context)
                                      throws XPathException

      Make a SequenceExtent, given the expected reference count
      Overrides:
        `makeSequenceExtent` in class `Configuration`
      Parameters:
        `expression` - the expression to be evaluated
        `ref` - the (nominal) number of times the value of the expression is required
        `context` - the XPath dynamic evaluation context
      Returns:
        the constructed Closure
      Throws:
        `XPathException` - if evaluation of the expression fails

    - #### declareBuiltInExtensionElementNamespaces

          public void declareBuiltInExtensionElementNamespaces()

      Declare the built-in XSLT extension element namespaces
      Overrides:
        `declareBuiltInExtensionElementNamespaces` in class `ProfessionalConfiguration`

Copyright (c) 2004-2013 Saxonica Limited. All rights reserved.