|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
java.lang.Objectnet.sf.saxon.Configuration
com.saxonica.config.ProfessionalConfiguration
com.saxonica.config.EnterpriseConfiguration
public final class EnterpriseConfiguration
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.
| Nested Class Summary | |
|---|---|
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 |
|---|
configurationClass, DO_NOT_RECOVER, JAVA_APPLICATION, optimizationLevel, optimizer, RECOVER_SILENTLY, RECOVER_WITH_WARNINGS, softwareEdition, vendorFunctionLibrary, XML_SCHEMA, XML10, XML11, XPATH, XQUERY, XSD10, XSD11, xsdVersion, XSLT |
| Constructor Summary | |
|---|---|
EnterpriseConfiguration()
Create an EnterpriseConfiguration |
|
| Method Summary | |
|---|---|
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 |
Receiver |
getDocumentValidator(Receiver receiver,
String systemId,
int validationMode,
int stripSpace,
SchemaType schemaType,
int topLevelElementName)
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,
NodeName elemName,
int locationId,
SchemaType schemaType,
int validation)
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) |
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. |
PreparedSchema |
getSuperSchema()
Get the SuperSchema, containing references to all names defined in all known schemas |
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. |
Value |
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. |
ValueRepresentation |
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 |
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 |
String |
readInlineSchema(NodeInfo root,
String expected,
ErrorListener errorListener)
Read an inline schema from a stylesheet |
void |
readMultipleSchemas(PipelineConfiguration pipe,
String baseURI,
Collection 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 java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public EnterpriseConfiguration()
| Method Detail |
|---|
public String getEditionCode()
getEditionCode in class ProfessionalConfiguration
public void setConfigurationProperty(String name,
Object value)
setConfigurationProperty in class ProfessionalConfigurationname - 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
IllegalArgumentException - if the property name is not recognized or if the value is not
a valid value for the named propertypublic Object getConfigurationProperty(String name)
getConfigurationProperty in class ProfessionalConfigurationname - the name of the required property. See the class FeatureKeys for
constants representing the property names that can be requested.
IllegalArgumentException - thrown if the property is not one that Saxon recognizes.
public void checkLicensedFeature(int feature,
String name)
throws LicenseException
checkLicensedFeature in class ProfessionalConfigurationfeature - the feature in question, identified by a constant in class Configuration.LicenseFeaturename - the name of the required feature, for use in diagnostics
LicenseException - if the feature is not licensedprotected void setLicensedFeatures()
setLicensedFeatures in class ProfessionalConfigurationprotected boolean testFeature(int feature)
Configuration.isLicensedFeature(int) which will load the license when necessary.
testFeature in class ProfessionalConfigurationfeature - the feature in question, identified by a constant in class {#LicenseFeature}
protected void needEnterpriseEdition()
needEnterpriseEdition in class Configurationpublic void setParameterizedURIResolver()
setParameterizedURIResolver in class Configurationpublic void setSchemaURIResolver(SchemaURIResolver resolver)
setSchemaURIResolver in class Configurationresolver - the URI resolver used for import schema declarationspublic SchemaCompiler newSchemaCompiler()
public void setOccurrenceLimits(int minimum,
int maximum)
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.public int[] getOccurrenceLimits()
public SchemaURIResolver getSchemaURIResolver()
getSchemaURIResolver in class Configuration
public String readSchema(PipelineConfiguration pipe,
String baseURI,
String schemaLocation,
String expected)
throws SchemaException
readSchema in class Configurationpipe - the PipelineConfigurationbaseURI - the base URI for resolving relative URIsschemaLocation - the location "hint" where to find the schema document. Must not be null.expected - the target namespace expected; null if there is no
expectation
SchemaException - if the schema cannot be read
public void readMultipleSchemas(PipelineConfiguration pipe,
String baseURI,
Collection schemaLocations,
String expected)
throws SchemaException
readMultipleSchemas in class Configurationpipe - the pipeline configurationbaseURI - the base URI for resolving relative URIsschemaLocations - 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
SchemaException - if an error occurs
public String readInlineSchema(NodeInfo root,
String expected,
ErrorListener errorListener)
throws SchemaException
readInlineSchema in class Configurationroot - the xs:schema element in the stylesheetexpected - the target namespace expected; "" if there is no
expectationerrorListener - The destination for error messages. May be null, in which case
the errorListener registered with this Configuration is used.
SchemaException - if the schema cannot be processed
public void addSchemaSource(Source schemaSource,
ErrorListener errorListener)
throws SchemaException
addSchemaSource in class ConfigurationschemaSource - the JAXP Source object identifying the schema document to be loadederrorListener - the ErrorListener to be notified of any errors in the schema. If null,
the configuration's errorListener is used
SchemaException - if the schema cannot be read or parsed or if it is invalid
public void addSchema(PreparedSchema pschema)
throws SchemaException
pschema - The schema to be added
SchemaException - if the schema cannot be added because components in the schema
are incompatible with components already in the cachepublic void addSurrogateSchema(String namespace)
This method is intended for internal use
namespace - the target namespace of the schemapublic void addSchemaForBuiltInNamespace(String namespace)
addSchemaForBuiltInNamespace in class Configurationnamespace - the namespace. Currently built-in schemas are available for the XML and FN namespacespublic int getNamespaceStatus(String namespace)
namespace - the Namespace URI whose status is required (supply "" for the non-namespace)
PreparedSchema.NAMESPACE_KNOWN, PreparedSchema.NAMESPACE_UNKNOWN,
PreparedSchema.NAMESPACE_UNDER_CONSTRUCTION, PreparedSchema.NAMESPACE_SEALED
public void setNamespaceStatus(String namespace,
int status)
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_SEALEDpublic boolean isSchemaAvailable(String targetNamespace)
isSchemaAvailable in class ConfigurationtargetNamespace - the target namespace of the schema being sought (supply "" for the
unnamed namespace)
public void removeSchema(String namespace)
namespace - the namespace of the schema to be removedpublic Set getImportedNamespaces()
getImportedNamespaces in class Configurationpublic PreparedSchema getSuperSchema()
public void sealNamespace(String namespace)
sealNamespace in class Configurationnamespace - the namespace URI of the components to be sealedpublic boolean isSealedNamespace(String namespace)
namespace - the namespace URI of the components to be tested. Supply "" for the no-namespace.
public Iterator<? extends SchemaType> getExtensionsOfType(SchemaType type)
getExtensionsOfType in class Configurationtype - the type whose extensions are required
public void importComponents(Source source)
throws XPathException
importComponents in class Configurationsource - the XML file containing the schema component model, as generated by a previous call on
exportComponents(net.sf.saxon.event.Receiver)
XPathException - if an error occurs
public void exportComponents(Receiver out)
throws XPathException
exportComponents in class Configurationout - the destination to recieve the precompiled Schema Component Model in the form of an
XML document
XPathException - if a failure occurspublic void clearSchemaCache()
clearSchemaCache in class Configurationpublic SchemaDeclaration getElementDeclaration(int fingerprint)
getElementDeclaration in class Configurationfingerprint - the NamePool fingerprint of the name of the required
element declaration
public SchemaDeclaration getElementDeclaration(StructuredQName qName)
getElementDeclaration in class ConfigurationqName - the name of the required
element declaration
public SchemaDeclaration getAttributeDeclaration(int fingerprint)
getAttributeDeclaration in class Configurationfingerprint - the namepool fingerprint of the required attribute
declaration
public SchemaType getSchemaType(int fingerprint)
getSchemaType in class Configurationfingerprint - the fingerprint of the schema type
public boolean isDeclaredNotation(String uri,
String local)
isDeclaredNotation in interface NotationSetisDeclaredNotation in class Configurationuri - the targetNamespace of the notationlocal - the local part of the notation name
public void checkTypeDerivationIsOK(SchemaType derived,
SchemaType base,
int block)
throws SchemaException
checkTypeDerivationIsOK in class Configurationderived - the derived typebase - the base type; the algorithm tests whether derivation from this type is permittedblock - the derivations that are blocked by the relevant element declaration
SchemaException - if the derivation is not allowed
public Receiver getDocumentValidator(Receiver receiver,
String systemId,
int validationMode,
int stripSpace,
SchemaType schemaType,
int topLevelElementName)
getDocumentValidator in class Configurationreceiver - The receiver to which events should be sent after validationsystemId - the base URI of the document being validatedvalidationMode - for example Validation.STRICT or Validation.STRIP. The integer may
also have the bit Validation.VALIDATE_OUTPUT set, indicating that the stream being validated
is to be treated as a final output stream (which means multiple errors can be reported)stripSpace - if set to Whitespace.IGNORABLE, causes whitespace in element-only
content to be stripped after validation. Default is taken from the Configuration settings.schemaType - The type against which the outermost element of the document must be validated
(null if there is no constraint)topLevelElementName - the fingerprint of the required name for the top-level element
being validated. Supply -1 to indicate that there is no specific requirement
public SequenceReceiver getElementValidator(SequenceReceiver receiver,
NodeName elemName,
int locationId,
SchemaType schemaType,
int validation)
throws XPathException
getElementValidator in class Configurationreceiver - the target receiver to receive the validated element; its pipelineConfiguration
must be initialized.elemName - the nameCode of the element to be validated. This should be set to -1 if
validation against a specific type is required (in which case schemaType must not be null).
Otherwise, the namecode must correspond to the name of an element declaration in a loaded schemalocationId - 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 receiverschemaType - the schema type (typically a complex type) against which the element is to
be validated. Supply null if there are no constraints, that is, if validation is to start from
the element declaration.validation - The validation mode, for example Validation.STRICT or Validation.LAX
XPathException - if a validator for the element cannot be created
public SimpleType validateAttribute(int nameCode,
CharSequence value,
int validation)
throws ValidationException
validateAttribute in class ConfigurationnameCode - the name of the attributevalue - the value of the attribute as a stringvalidation - STRICT or LAX
ValidationException - if the value is invalidpublic Receiver getAnnotationStripper(Receiver destination)
getAnnotationStripper in class Configurationdestination - the Receiver that events will be written to after whitespace stripping
public StaticQueryContext newStaticQueryContext()
newStaticQueryContext in class ProfessionalConfiguration
public ExpressionParser newExpressionParser(String language,
boolean updating,
DecimalValue languageVersion)
newExpressionParser in class ProfessionalConfigurationlanguage - 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-EElanguageVersion - 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.
UnsupportedOperationException - if a parser that supports update syntax is requested on Saxon-Bpublic PendingUpdateList newPendingUpdateList()
newPendingUpdateList in class Configurationpublic FilterFactory makeDocumentProjector(PathMap.PathMapRoot map)
makeDocumentProjector in class Configurationmap - the path map used to control document projection
public Receiver makeStreamingTransformer(XPathContext context,
Mode mode)
throws XPathException
makeStreamingTransformer in class Configurationcontext - the initial XPath contextmode - the initial mode, which must be a streaming mode
XPathException - if a streaming transformer cannot be created (which
is always the case in Saxon-HE and Saxon-PE)public Optimizer obtainOptimizer()
obtainOptimizer in class Configuration
public Value makeClosure(Expression expression,
int ref,
XPathContext context)
throws XPathException
makeClosure in class Configurationexpression - the expression to be evaluatedref - the (nominal) number of times the value of the expression is requiredcontext - the XPath dynamic evaluation context
XPathException - if a failure occurs constructing the Closure
public ValueRepresentation makeSequenceExtent(Expression expression,
int ref,
XPathContext context)
throws XPathException
makeSequenceExtent in class Configurationexpression - the expression to be evaluatedref - the (nominal) number of times the value of the expression is requiredcontext - the XPath dynamic evaluation context
XPathException - if evaluation of the expression failspublic void declareBuiltInExtensionElementNamespaces()
declareBuiltInExtensionElementNamespaces in class ProfessionalConfiguration
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||