com.saxonica.config

Class EnterpriseConfiguration

java.lang.Object

net.sf.saxon.Configuration

com.saxonica.config.ProfessionalConfiguration

com.saxonica.config.EnterpriseConfiguration

All Implemented Interfaces:

SourceResolver, NotationSet

public final class EnterpriseConfiguration
extends ProfessionalConfiguration

A subclass of Configuration that defines a processor with Saxon-EE capabilities. 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.

Nested Class Summary

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

Configuration.LicenseFeature

Field Summary

Fields inherited from class net.sf.saxon.Configuration

collectionResolver, configurationClass, defaultStaticQueryContext, 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<String>	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.
int	getStreamability() Get the streamability rules to be applied.
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
VendorFunctionLibrary	getVendorFunctionLibrary() Get the FunctionLibrary used to bind calls on Saxon-defined extension functions
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 root.
FilterFactory	makeDocumentProjector(XQueryExpression exp) Create a document projector for the document supplied as the initial context item in a query.
PipelineConfiguration	makePipelineConfiguration() Make a PipelineConfiguration from the properties of this Configuration
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
XQueryExpression	makeXQueryExpression(Expression exp, QueryModule mainModule, boolean streaming) Factory method to make an XQueryExpression
protected void	needEnterpriseEdition() Throw an error indicating that a request cannot be satisfied because it requires the enterprise edition of Saxon.
XPathParser	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.
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.
void	setStreamability(int streamability) Set the streamability rules to be applied.
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, getGlobalLocationMap, importLicenseDetails, isLicensedFeature, isLicenseFound, isLicenseNotFound, loadLicense, makeProfessionalConfiguration, makeUnconstructedDocument, makeUnconstructedElement, newUserFunction, readConfigurationFile, reportIfMissingLicenseFeature, resolveSource, rewriteCopyOnEmpty, setExtensionBinder, setExtensionElementNamespace, supplyLicenseKey

Methods inherited from class net.sf.saxon.Configuration

addSchemaSource, buildDocument, buildDocument, finalize, getBooleanProperty, getCharacterSetFactory, getClass, getCollation, getCollation, getCollation, getCollationURIResolver, getCollectionURIResolver, getConfiguration, getConversionContext, getConversionRules, getDebugger, getDefaultCollationName, getDefaultCollection, getDefaultCountry, getDefaultLanguage, getDefaultSerializationProperties, getDefaultStaticQueryContext, getDefaultXsltCompilerInfo, getDocumentNumberAllocator, getDynamicLoader, getErrorListener, getExternalObjectModel, getExternalObjectModel, getExternalObjectModels, getGlobalDocumentPool, getInstance, getIntegratedFunctionLibrary, getLocalizerFactory, getLogger, getMessageEmitterClass, getModuleURIResolver, getNamePool, getOutputURIResolver, getParseOptions, getPlatform, getProcessor, getProductTitle, getRecoveryPolicy, getSchemaValidationMode, getSerializerFactory, getSoftwareEdition, getSourceParser, getSourceParserClass, getSourceResolver, getStandardErrorOutput, getStandardModuleURIResolver, getStripsWhiteSpace, getStyleParser, getStyleParserClass, getSystemURIResolver, getTraceListener, getTraceListenerClass, getTreeModel, getURIResolver, getValidCharacterChecker, getXMLVersion, getXsdVersion, init, instantiateClassName, internalSetBooleanProperty, isCompatible, isCompileWithTracing, isExpandAttributeDefaults, isGenerateByteCode, isLineNumbering, isStripsAllWhiteSpace, isTiming, isValidation, isValidationWarnings, isVersionWarning, isXIncludeAware, loadSchema, locateResource, makeConfigurationClass, makeEmitter, makeLicensedConfiguration, makeNumberer, makeParser, makePlatform, makeSlotManager, makeTraceListener, makeTraceListener, makeURIResolver, newConfiguration, newStaticQueryContext, readConfiguration, registerCollation, registerExtensionFunction, registerExternalObjectModel, reportFatalError, requireBoolean, requireString, reuseSourceParser, reuseStyleParser, setBooleanProperty, setCollationURIResolver, setCollectionURIResolver, setCompileWithTracing, setConversionRules, setDebugger, setDefaultCollection, setDefaultCountry, setDefaultLanguage, setDefaultSerializationProperties, setDocumentNumberAllocator, setDynamicLoader, setErrorListener, setExpandAttributeDefaults, setLineNumbering, setLocalizerFactory, setLogger, setMessageEmitterClass, setModuleURIResolver, setModuleURIResolver, setNamePool, setOutputURIResolver, setProcessor, setRecoveryPolicy, setSchemaValidationMode, setSerializerFactory, setSourceParserClass, setSourceResolver, setStandardErrorOutput, setStaticQueryContextFactory, 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

max - the maximum number of nodes to be counted

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 - if a dynamic error occurs

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

getVendorFunctionLibrary

public VendorFunctionLibrary getVendorFunctionLibrary()

Get the FunctionLibrary used to bind calls on Saxon-defined extension functions

Overrides:

getVendorFunctionLibrary in class ProfessionalConfiguration

Returns:

the FunctionLibrary used for extension functions in the Saxon library.

getTypeHierarchy

public TypeHierarchy getTypeHierarchy()

Get the TypeHierarchy: a cache holding type information

Overrides:

getTypeHierarchy in class Configuration

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.

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.

Returns:

the user-defined SchemaURIResolver if there is one; otherwise the standard schema URI resolver.

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

newExpressionParser

public XPathParser 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

makePipelineConfiguration

public PipelineConfiguration makePipelineConfiguration()

Make a PipelineConfiguration from the properties of this Configuration

Overrides:

makePipelineConfiguration in class Configuration

Returns:

a new PipelineConfiguration

Since:

8.4

makeDocumentProjector

public FilterFactory makeDocumentProjector(PathMap.PathMapRoot map)

Create a document projector for a given path map root. Document projection is available only in Saxon-EE, so the Saxon-HE version of this method throws an exception

Overrides:

makeDocumentProjector in class Configuration

Parameters:

map - a path map root in a path map. This might represent the call to the initial context item for a query, or it might represent a call on the doc() function. The path map contains information about the paths that the query uses within this document.

Returns:

a push filter that implements document projection

Throws:

UnsupportedOperationException - if this is not a schema-aware configuration, or if no Saxon-EE license is available

makeDocumentProjector

public FilterFactory makeDocumentProjector(XQueryExpression exp)

Create a document projector for the document supplied as the initial context item in a query. Document projection is available only in Saxon-EE, so the Saxon-HE version of this method throws an exception

Overrides:

makeDocumentProjector in class Configuration

Parameters:

exp - an XQuery expression. The document projector that is returned will be for the document supplied as the context item to this query.

Returns:

a push filter that implements document projection

Throws:

UnsupportedOperationException - if this is not a schema-aware configuration, or if no Saxon-EE license is available

setStreamability

public void setStreamability(int streamability)

Set the streamability rules to be applied.

Parameters:

streamability - the streamability rules. With a plain Saxon-HE Configuration, any value other than 0 causes an IllegalArgumentException

Since:

9.6

getStreamability

public int getStreamability()

Get the streamability rules to be applied.

Overrides:

getStreamability in class Configuration

Returns:

Streamability.OFF, Streamability.STANDARD, or Streamability.EXTENDED

Since:

9.6

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

makeXQueryExpression

public XQueryExpression makeXQueryExpression(Expression exp,
                                    QueryModule mainModule,
                                    boolean streaming)
                                      throws XPathException

Factory method to make an XQueryExpression

Overrides:

makeXQueryExpression in class Configuration

Parameters:

exp - the expression forming the body of the query

mainModule - the query module containing the expression

streaming - true if streamed execution is requested

Returns:

the XQueryExpression

Throws:

XPathException - if an error occurs

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