Package com.saxonica.ee.schema

Class PreparedSchema

java.lang.Object
com.saxonica.ee.schema.PreparedSchema
All Implemented Interfaces:
NotationSet, Schema
Direct Known Subclasses:
SingleNamespaceSchema
public class PreparedSchema extends Object implements Schema, NotationSet
A schema is a collection of schema components. It may be derived from a single schema document (an xs:schema element), in which case it contains those components defined in that schema document, the components defined in the included documents (expanded transitively), and the components defined in imported schema documents (not expanded transitively). Alternatively, it may be a collection of schema components derived from multiple independent schema documents.

All components in the schema are indexed by name. In addition, elements, attributes, and types are indexed by their integer NamePool fingerprint.

Construction of the PreparedSchema is not thread-safe; all creation of new components must happen in a single thread.

  • Field Details

  • Constructor Details

    • PreparedSchema

      public PreparedSchema(EnterpriseConfiguration config)
      Create a new Schema definition
      Parameters:
      config - The configuration object holding system configuration information

  • Method Details

    • getConfiguration

      public EnterpriseConfiguration getConfiguration()
      Get the configuration
      Specified by:
      getConfiguration in interface Schema

    • setXsdVersion

      public void setXsdVersion(int version)
      Set the version of XSD used to create this schema
      Parameters:
      version - Configuration.XSD10 or Configuration.XSD11

    • getXsdVersion

      public int getXsdVersion()
      Get the version of XSD used to create this schema
      Returns:
      Configuration.XSD10 or Configuration.XSD11

    • setLocalLicenseId

      public void setLocalLicenseId(int id)
      Set the local license id, identifying any local license in the case where this package was loaded from a compiled package that contained its own embedded license
      Parameters:
      id - identifier used to distinguish this local license

    • getLocalLicenseId

      public int getLocalLicenseId()
      Get the local license id, identifying any local license in the case where this package was loaded from a compiled package that contained its own embedded license
      Returns:
      integer identifying the local license, or -1 if there is none

    • setUuid

      public void setUuid(String uuid)
      Set a UUID on this schema
      Parameters:
      uuid - the UUID to be used

    • getUuid

      public String getUuid()
      Get the UUID of this schema
      Returns:
      the UUID of the schema; null if none has been allocated

    • addComponent

      public void addComponent(UserSchemaComponent obj)
      Add an object that might contain a forwards reference to be fixed up later
      Parameters:
      obj - the component to be added. The caller should ensure that the same component is not added twice.

    • makeSchemaElementTest

      public GNodeType makeSchemaElementTest(int fp) throws SchemaException
      Make a schema-element node test for a given element name
      Specified by:
      makeSchemaElementTest in interface Schema
      Parameters:
      fp - the integer fingerprint of the element name
      Returns:
      a node test corresponding to the XPath item type syntax schema-element(E)
      Throws:
      SchemaException - if there is no element declaration with this name in the schema

    • makeSchemaAttributeTest

      public GNodeType makeSchemaAttributeTest(int fp) throws SchemaException
      Make a schema-attribute node test for a given attribute name
      Specified by:
      makeSchemaAttributeTest in interface Schema
      Parameters:
      fp - the integer fingerprint of the attribute name
      Returns:
      a node test corresponding to the XPath item type syntax schema-attribute(E)
      Throws:
      SchemaException - if there is no attribute declaration with this name in the schema

    • getAttributeDecl

      public AttributeDecl getAttributeDecl(StructuredQName name)
      Get the attribute declaration with a given name if there is one.
      Specified by:
      getAttributeDecl in interface Schema
      Parameters:
      name - the name of the required attribute declaration
      Returns:
      the attribute declaration if found, or null otherwise

    • getAttributeDecl

      public AttributeDecl getAttributeDecl(int fingerprint)
      Get the attribute declaration with a given name if there is one.
      Specified by:
      getAttributeDecl in interface Schema
      Parameters:
      fingerprint - the NamePool fingerprint of the name of the required attribute declaration
      Returns:
      the attribute declaration if found, or null otherwise

    • getAttributeDeclarations

      public Iterable<AttributeDecl> getAttributeDeclarations()
      Get all the global attribute declarations defined in this schema
      Returns:
      an iterable collection of attribute declarations. Each item returned by the iterator will be an instance of AttributeDecl

    • addAttributeDecl

      public void addAttributeDecl(AttributeDecl attribute)
      Adds the given global attribute declaration to this Schema. It will overwrite any existing attribute declaration with the same name.
      Parameters:
      attribute - the AttributeDecl to add

    • getAttributeGroup

      public AttributeGroupDecl getAttributeGroup(StructuredQName name)
      Get the attribute declaration with a given name if there is one.
      Parameters:
      name - the name of the required attribute group
      Returns:
      the attribute declaration if found, or null otherwise

    • getAllAttributeGroups

      public Iterable<AttributeGroupDecl> getAllAttributeGroups()
      Get an iterator over all the named attribute groups defined in this schema
      Returns:
      an iterator over the attribute groups. Each item returned by the iterator will be an instance of AttributeGroupDecl

    • addAttributeGroup

      public void addAttributeGroup(AttributeGroupDecl attributeGroup)
      Adds the given attribute group declaration to this Schema. It will overwrite any existing attribute group declaration with the same name, unless the existing attribute has a higher redefinition level.
      Parameters:
      attributeGroup - the AttributeDecl to add

    • getGroup

      public ModelGroupDefinition getGroup(StructuredQName name)
      Get the model group with a given name if there is one.
      Parameters:
      name - the name of the required named model group
      Returns:
      the group if found, or null otherwise

    • getAllModelGroups

      public Iterable<ModelGroupDefinition> getAllModelGroups()
      Get an iterator over all the named model groups defined in this schema
      Returns:
      an iterator over the model groups. Each item returned by the iterator will be an instance of ModelGroupDefinition

    • addGroup

      public void addGroup(ModelGroupDefinition group)
      Adds the given group (xs:group) to this Schema. It will overwrite any existing group with the same name.
      Parameters:
      group - the group to add

    • getSchemaType

      public SchemaType getSchemaType(StructuredQName name)
      Get the type with a given name if there is one. This method will also find built-in types.
      Specified by:
      getSchemaType in interface Schema
      Parameters:
      name - the name of the required schema type
      Returns:
      the named simple or complex type if found, or null otherwise

    • getSimpleType

      public SimpleType getSimpleType(StructuredQName name)
      Get the simple type with a given name if there is one. This method will also find built-in types.
      Parameters:
      name - the name of the required simple type
      Returns:
      the simple type if found, or null otherwise

    • getCompiledComplexType

      public CompiledComplexType getCompiledComplexType(UserComplexType type)

    • getCompiledComplexTypes

      public Iterable<CompiledComplexType> getCompiledComplexTypes()

    • getAllNamedTypes

      public Iterable<SchemaType> getAllNamedTypes()
      Get all the named simple and complex types defined in this schema. This iterable will not include built-in types or anonymous types.
      Returns:
      an iterable of the types.

    • getAllAnonymousTypes

      public Iterable<SchemaType> getAllAnonymousTypes()
      Get all the anonymous simple and complex types defined in this schema.
      Returns:
      an iterable of the types.

    • addType

      public void addType(SchemaType type)
      Adds the given type definition to this Schema. If another type with this name already exists, it is overwritten, unless it has a higher redefinition level
      Parameters:
      type - the type to add to this Schema

    • addAnonymousType

      public void addAnonymousType(SchemaType type)
      Register an anonymous type defined in this schema
      Parameters:
      type - the anonymous type to be added

    • getType

      public SchemaType getType(StructuredQName name)
      Get type defined in this schema, searching both named and anonymous types
      Parameters:
      name - the name of the required schema type
      Returns:
      the schema type if found, else null

    • getExtensionsOfType

      public Set<UserComplexType> 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
      Parameters:
      type - the type whose extensions are required

    • registerExtensionOfBuiltInType

      public void registerExtensionOfBuiltInType(int fp, UserComplexType extension)
      Register a complex type that extends a built-in simple type
      Parameters:
      fp - the fingerprint of the built-in type
      extension - the complex type that extends the built-in (directly or indirectly)

    • registerExtensionOfUserDefinedType

      public void registerExtensionOfUserDefinedType(UserDefinedType baseType, UserComplexType extension)
      Register a complex type that extends a user-defined type
      Parameters:
      baseType - the user-defined type that is extended
      extension - the complex type that extends the base type

    • getExtensionsOfBuiltInType

      public Set<UserComplexType> getExtensionsOfBuiltInType(int fp)
      Get the set of user-defined complex types that extend a given built-in type
      Parameters:
      fp - the fingerprint of the built-in type
      Returns:
      the set of user-defined complex types that have been registered as extensions of this built-in type

    • addElementDecl

      public void addElementDecl(ElementDecl elementDecl)
      Adds the given global element declaration to this Schema definition
      Parameters:
      elementDecl - the ElementDecl to add to this Schema

    • getElementDecl

      public ElementDecl getElementDecl(StructuredQName name)
      Get the global element declaration with a given name
      Specified by:
      getElementDecl in interface Schema
      Parameters:
      name - the name of the element
      Returns:
      the element declaration, or null if not found.

    • getElementDecl

      public ElementDecl getElementDecl(int fingerprint)
      Get the global element declaration with a given fingerprint
      Specified by:
      getElementDecl in interface Schema
      Parameters:
      fingerprint - the NamePool fingerprint of the name of the element
      Returns:
      the element declaration, or null if not found.

    • getSubstitutionGroupMembers

      public Set<ElementDecl> getSubstitutionGroupMembers(ElementDecl owner)
      Get the members of the substitution group of an element
      Parameters:
      owner - the element declaration owning the substitution group
      Returns:
      the set of element declarations in this schema that are members of the substitution group. Note that an element declaration may appear in multiple schemas and have different substitution group membership in each one.

    • addSubstitutionGroupMember

      public void addSubstitutionGroupMember(ElementDecl owner, ElementDecl member)

    • setSubstitutionGroupMembers

      public void setSubstitutionGroupMembers(ElementDecl owner, Set<ElementDecl> members)

    • getElementDeclarations

      public Iterable<ElementDecl> getElementDeclarations()
      Get an iterator over all the global element declarations defined in this schema.
      Returns:
      an iterator over the global element declarations. Each item returned by the iterator will be an instance of ElementDecl

    • addNotation

      public void addNotation(Notation notation)
      Adds the given Notation declaration to this Schema defintion
      Parameters:
      notation - the Notation to add to this Schema

    • getNotation

      public Notation getNotation(StructuredQName notationName)
      Get the notation with a given name
      Parameters:
      notationName - identifies the name of the notation
      Returns:
      the element notation, or null if not found.

    • getAllNotations

      public Iterable<Notation> getAllNotations()
      Get an iterator over all the notations defined in this schema.
      Returns:
      an iterator over the notations. Each item returned by the iterator will be an instance of Notation

    • addIdentityConstraint

      public void addIdentityConstraint(IdentityConstraint constraint)
      Add an identity constraint
      Parameters:
      constraint - the identity constraint to be added

    • getIdentityConstraint

      public IdentityConstraint getIdentityConstraint(StructuredQName name)
      Get the identity constraint whose name has a given fingerprint
      Parameters:
      name - the name of the required constraint
      Returns:
      the identity constraint, or null if there is none with that name

    • getIdentityConstraints

      public Iterable<IdentityConstraint> getIdentityConstraints()
      Get an iterator over all the identity constraints defined in this schema (that is, unique, key, and keyref components).
      Returns:
      an iterator over the identity constraints. Each item returned by the iterator will be an instance of IdentityConstraint

    • getTargetNamespaces

      public Iterable<NamespaceUri> getTargetNamespaces()
      Get the set of all target namespaces of components present in this schema
      Returns:
      the set of all target namespaces for these components

    • includesTargetNamespace

      public boolean includesTargetNamespace(NamespaceUri target)
      Specified by:
      includesTargetNamespace in interface Schema

    • getTargetNamespaceMap

      public Map<NamespaceUri,List<String>> getTargetNamespaceMap()

    • addSchemaDocument

      public void addSchemaDocument(NamespaceUri targetNamespace, String location)

    • addSchemaDocument

      public void addSchemaDocument(String location)

    • includesSchemaLocation

      public boolean includesSchemaLocation(String location)

    • getNamePool

      public NamePool getNamePool()
      Get the NamePool used by this schema
      Returns:
      the namepool

    • addGlobalParam

      public void addGlobalParam(GlobalParam param) throws SchemaException
      Declare a global parameter for XPath expressions in this schema document (Saxon extension)
      Parameters:
      param - the details of the parameter
      Throws:
      SchemaException

    • getGlobalParam

      public GlobalParam getGlobalParam(StructuredQName name)
      Get the GlobalParam object representing a named parameter (Saxon extension)
      Parameters:
      name - the parameter name
      Returns:
      the GlobalParam object if a parameter with this name exists, else null

    • getGlobalParams

      public Collection<GlobalParam> getGlobalParams()
      Return the set of global parameters defined in this schema document
      Returns:
      the set of global parameters

    • copyTo

      public void copyTo(PreparedSchema destination, SchemaCompiler compiler) throws SchemaException
      Copy the components of this schema to another schema
      Parameters:
      destination - the destination of the copy. The destination schema is modified; this schema is unchanged.
      compiler - used for error reporting
      Throws:
      SchemaException - if there are name clashes between this schema and the destination schema (that is, the same name used to refer to different components. Components are compared by checking their name and origin, where the origin is the SystemId and line number of the schema document from which they were initially derived)

    • addBuiltInNamespace

      public void addBuiltInNamespace(NamespaceUri namespace)

    • validate

      public boolean validate(SchemaCompiler compiler) throws SchemaException
      Checks the validity of this Schema definition
      Parameters:
      compiler - a SchemaCompiler to which all errors should be reported
      Returns:
      true if validation succeeds, false if it fails
      Throws:
      SchemaException - if the SchemaCompiler decides that an error is fatal

    • validateReference

      public static SchemaComponent validateReference(ComponentReference ref, SchemaCompiler compiler, boolean fatal) throws SchemaException
      Helper method to validate that a reference to a schema component can be resolved
      Parameters:
      ref - The Component reference that needs to be resolved
      compiler - used for error reporting
      fatal - True if failure to resolve the reference is an error rather than a warning
      Returns:
      the target of the reference
      Throws:
      SchemaException - if the reference cannot be resolved

    • compareWith

      public boolean compareWith(PreparedSchema other) throws SchemaException
      Determine whether this schema is equivalent to another schema, compatible with another schema, or incompatible.
      Parameters:
      other - the other schema
      Returns:
      true if the two schemas are identical, false if they are different but compatible
      Throws:
      SchemaException - if the two schemas are incompatible: specifically, if there is a name that is present in both schemas but refers to different components.

    • merge

      public static PreparedSchema merge(PreparedSchema ps1, PreparedSchema ps2) throws SchemaException
      Merge two PreparedSchemas into one, rejecting any components that are defined in both.
      Parameters:
      ps1 - the first PreparedSchema
      ps2 - the second PreparedSchema
      Returns:
      the merged PreparedSchema
      Throws:
      SchemaException - if there are inconsistencies between the two schemas, for example different components with the same name

    • isDeclaredNotation

      public boolean isDeclaredNotation(NamespaceUri uri, String local)
      Description copied from interface: NotationSet
      Ask whether a given notation name is present in this set of notations
      Specified by:
      isDeclaredNotation in interface NotationSet
      Parameters:
      uri - the URI part of the notation name
      local - the local part of the notation name
      Returns:
      true if the notation name is present

    • addSchemaSource

      public void addSchemaSource(Source schemaSource, ErrorReporter errorReporter, SchemaCompiler compiler) throws SchemaException
      Load a schema, which will be available for use by all subsequent operations using this EnterpriseConfiguration.
      Parameters:
      schemaSource - the JAXP Source object identifying the schema document to be loaded. This may be either a source schema document in XSD format, or a compiled schema in Saxon's SCM format
      errorReporter - the ErrorListener to be notified of any errors in the schema. If null, the configuration's errorListener is used
      compiler - the schema compiler to be used. This allows a cache of schema documents (retained by the schema compiler) to be reused when compiling multiple schema documents. See bug #4982.
      Throws:
      SchemaException - if the schema cannot be read or parsed or if it is invalid

    • exportComponents

      public void exportComponents(Receiver out) throws XPathException
      Throws:
      XPathException

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

    • importComponentsFrom

      public static PreparedSchema importComponentsFrom(Source source, Configuration config) throws XPathException
      Throws:
      XPathException

    • 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

    • getNamespaceStatus

      public int getNamespaceStatus(NamespaceUri 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 NAMESPACE_KNOWN, NAMESPACE_UNKNOWN, NAMESPACE_UNDER_CONSTRUCTION}

    • setNamespaceStatus

      public void setNamespaceStatus(NamespaceUri 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 NAMESPACE_KNOWN, NAMESPACE_UNKNOWN, NAMESPACE_UNDER_CONSTRUCTION}

    • getDocumentValidator

      public Receiver getDocumentValidator(Receiver receiver, String systemId, ParseOptions validationOptions, Location initiatingLocation)
      Get a document-level validator to add to a Receiver pipeline
      Specified by:
      getDocumentValidator in interface Schema
      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
      initiatingLocation - (optional) Location in query or stylesheet of instruction that requested validation
      Returns:
      A Receiver to which events can be sent for validation

    • getElementValidator

      public Receiver getElementValidator(Receiver receiver, ParseOptions options, Location location) 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.
      Specified by:
      getElementValidator in interface Schema
      Parameters:
      receiver - the target receiver to receive the validated element; its pipelineConfiguration must be initialized.
      options - options affecting the way schema validation is done
      location - 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(StructuredQName nodeName, UnicodeString value, int validation) throws ValidationException, MissingComponentException
      Validate an attribute value (XSLT only)
      Specified by:
      validateAttribute in interface Schema
      Parameters:
      nodeName - 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
      MissingComponentException

    • compileComplexType

      public CompiledComplexType compileComplexType(SchemaCompiler compiler, UserComplexType type) throws SchemaException
      Throws:
      SchemaException

    • rebuildComplexType

      public CompiledComplexType rebuildComplexType(UserComplexType type, FiniteStateMachine fsm) throws SchemaException
      Throws:
      SchemaException

    • apparentlyEqual

      public static boolean apparentlyEqual(SchemaType t1, SchemaType t2)