|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object net.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 ProfessionalConfiguration
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
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 ProfessionalConfiguration
name
- 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 ProfessionalConfiguration
feature
- the feature in question, identified by a constant in class Configuration.LicenseFeature
name
- the name of the required feature, for use in diagnostics
LicenseException
- if the feature is not licensedprotected void setLicensedFeatures()
setLicensedFeatures
in class ProfessionalConfiguration
protected boolean testFeature(int feature)
Configuration.isLicensedFeature(int)
which will load the license when necessary.
testFeature
in class ProfessionalConfiguration
feature
- the feature in question, identified by a constant in class {#LicenseFeature}
protected void needEnterpriseEdition()
needEnterpriseEdition
in class Configuration
public void setParameterizedURIResolver()
setParameterizedURIResolver
in class Configuration
public void setSchemaURIResolver(SchemaURIResolver resolver)
setSchemaURIResolver
in class Configuration
resolver
- 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 Configuration
pipe
- 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 readpublic void readMultipleSchemas(PipelineConfiguration pipe, String baseURI, Collection schemaLocations, String expected) throws SchemaException
readMultipleSchemas
in class Configuration
pipe
- 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 occurspublic String readInlineSchema(NodeInfo root, String expected, ErrorListener errorListener) throws SchemaException
readInlineSchema
in class Configuration
root
- 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 processedpublic void addSchemaSource(Source schemaSource, ErrorListener errorListener) throws SchemaException
addSchemaSource
in class Configuration
schemaSource
- 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 invalidpublic 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 Configuration
namespace
- 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_SEALED
public boolean isSchemaAvailable(String targetNamespace)
isSchemaAvailable
in class Configuration
targetNamespace
- 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 Configuration
public PreparedSchema getSuperSchema()
public void sealNamespace(String namespace)
sealNamespace
in class Configuration
namespace
- 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 Configuration
type
- the type whose extensions are required
public void importComponents(Source source) throws XPathException
importComponents
in class Configuration
source
- 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 occurspublic void exportComponents(Receiver out) throws XPathException
exportComponents
in class Configuration
out
- 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 Configuration
public SchemaDeclaration getElementDeclaration(int fingerprint)
getElementDeclaration
in class Configuration
fingerprint
- the NamePool fingerprint of the name of the required
element declaration
public SchemaDeclaration getElementDeclaration(StructuredQName qName)
getElementDeclaration
in class Configuration
qName
- the name of the required
element declaration
public SchemaDeclaration getAttributeDeclaration(int fingerprint)
getAttributeDeclaration
in class Configuration
fingerprint
- the namepool fingerprint of the required attribute
declaration
public SchemaType getSchemaType(int fingerprint)
getSchemaType
in class Configuration
fingerprint
- the fingerprint of the schema type
public boolean isDeclaredNotation(String uri, String local)
isDeclaredNotation
in interface NotationSet
isDeclaredNotation
in class Configuration
uri
- 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 Configuration
derived
- 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 allowedpublic Receiver getDocumentValidator(Receiver receiver, String systemId, int validationMode, int stripSpace, SchemaType schemaType, int topLevelElementName)
getDocumentValidator
in class Configuration
receiver
- 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 Configuration
receiver
- 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 createdpublic SimpleType validateAttribute(int nameCode, CharSequence value, int validation) throws ValidationException
validateAttribute
in class Configuration
nameCode
- 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 Configuration
destination
- 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 ProfessionalConfiguration
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-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 Configuration
public FilterFactory makeDocumentProjector(PathMap.PathMapRoot map)
makeDocumentProjector
in class Configuration
map
- the path map used to control document projection
public Receiver makeStreamingTransformer(XPathContext context, Mode mode) throws XPathException
makeStreamingTransformer
in class Configuration
context
- 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 Configuration
expression
- 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 Closurepublic ValueRepresentation makeSequenceExtent(Expression expression, int ref, XPathContext context) throws XPathException
makeSequenceExtent
in class Configuration
expression
- 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 |