com.saxonica.schema

## Class PreparedSchema

- java.lang.Object
- - com.saxonica.schema.SchemaStructure
  - - com.saxonica.schema.PreparedSchema

- All Implemented Interfaces:
    Serializable, SourceLocator, NotationSet
  Direct Known Subclasses:
    EnterpriseConfiguration.SurrogateSchema, SingleNamespaceSchema

      public class PreparedSchema
      extends SchemaStructure
      implements 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.
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `NAMESPACE_KNOWN`
    `static int` | `NAMESPACE_SEALED`
    `static int` | `NAMESPACE_UNDER_CONSTRUCTION`
    `static int` | `NAMESPACE_UNKNOWN`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `PreparedSchema()` Create a dummy schema definition.
    `` | `PreparedSchema(EnterpriseConfiguration config)` Create a new Schema definition

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addAnonymousType(SchemaType type)` Register an anonymous type defined in this schema
    `void` | `addAttributeDecl(AttributeDecl attribute)` Adds the given global attribute declaration to this Schema.
    `void` | `addAttributeGroup(AttributeGroupDecl attributeGroup)` Adds the given attribute group declaration to this Schema.
    `void` | `addComponent(UserSchemaComponent obj)` Add an object that might contain a forwards reference to be fixed up later
    `void` | `addElementDecl(ElementDecl elementDecl)` Adds the given global element declaration to this Schema definition
    `void` | `addGlobalParam(GlobalParam param)` Declare a global parameter for XPath expressions in this schema document (Saxon extension)
    `void` | `addGroup(ModelGroupDefinition group)` Adds the given group (xs:group) to this Schema.
    `void` | `addIdentityConstraint(IdentityConstraint constraint)` Add an identity constraint
    `void` | `addNotation(Notation notation)` Adds the given Notation declaration to this Schema defintion
    `void` | `addType(SchemaType type)` Adds the given type definition to this Schema.
    `void` | `copyTo(PreparedSchema destination, SchemaCompiler compiler)` Copy the components of this schema to another schema
    `AttributeDecl` | `getAttributeDecl(int fingerprint)` Get the attribute declaration with a given name if there is one.
    `AttributeGroupDecl` | `getAttributeGroup(int fingerprint)` Get the attribute declaration with a given name if there is one.
    `EnterpriseConfiguration` | `getConfiguration()` Get the configuration
    `ElementDecl` | `getElementDecl(int fingerprint)` Get the global element declaration with a given name
    `Set<UserComplexType>` | `getExtensionsOfBuiltInType(int fp)` Get the set of user-defined complex types that extend a given built-in type
    `GlobalParam` | `getGlobalParam(StructuredQName name)` Get the GlobalParam object representing a named parameter (Saxon extension)
    `Collection<GlobalParam>` | `getGlobalParams()` Return the set of global parameters defined in this schema document
    `ModelGroupDefinition` | `getGroup(int fingerprint)` Get the model group with a given name if there is one.
    `IdentityConstraint` | `getIdentityConstraint(int fingerprint)` Get the identity constraint whose name has a given fingerprint
    `NamePool` | `getNamePool()` Get the NamePool used by this schema
    `Notation` | `getNotation(int fingerprint)` Get the notation with a given name
    `SchemaType` | `getSchemaType(int fingerprint)` Get the type with a given name if there is one.
    `SimpleType` | `getSimpleType(int fingerprint)` Get the simple type with a given name if there is one.
    `Set<String>` | `getTargetNamespaces()` Get the set of all target namespaces of components present in this schema
    `SchemaType` | `getType(int fingerprint)` Get type defined in this schema, searching both named and anonymous types
    `boolean` | `isDeclaredNotation(String uri, String local)` Ask whether a given notation name is present in this set of notations
    `Iterator<AttributeDecl>` | `iterateAttributeDeclarations()` Get an iterator over all the global attribute declarations defined in this schema
    `Iterator<AttributeGroupDecl>` | `iterateAttributeGroups()` Get an iterator over all the named attribute groups defined in this schema
    `Iterator<ElementDecl>` | `iterateElementDeclarations()` Get an iterator over all the global element declarations defined in this schema.
    `Iterator<IdentityConstraint>` | `iterateIdentityConstraints()` Get an iterator over all the identity constraints defined in this schema (that is, unique, key, and keyref components).
    `Iterator<ModelGroupDefinition>` | `iterateModelGroups()` Get an iterator over all the named model groups defined in this schema
    `Iterator<Notation>` | `iterateNotations()` Get an iterator over all the notations defined in this schema.
    `Iterator<SchemaType>` | `iterateTypes()` Get an iterator over all the named simple and complex types defined in this schema.
    `static PreparedSchema` | `merge(PreparedSchema ps1, PreparedSchema ps2)` Merge two PreparedSchemas into one, rejecting any components that are defined in both.
    `void` | `registerExtensionOfBuiltInType(int fp, UserComplexType extension)` Register a complex type that extends a built-in simple type
    `void` | `setConfiguration(EnterpriseConfiguration config)` Set the configuration
    `boolean` | `validate(SchemaCompiler compiler)` Checks the validity of this Schema definition, and if valid, adds the schema to the cache held by the EnterpriseConfiguration
    `static SchemaComponent` | `validateReference(ComponentReference ref, SchemaCompiler compiler)` Helper method to validate that a reference to a schema component can be resolved

    - ### Methods inherited from class com.saxonica.schema.SchemaStructure

      `elaborate, fixup, getColumnNumber, getFixupStatus, getLineNumber, getPublicId, getRedefinitionLevel, getSchemaDocumentURI, getSystemId, getValidationStatus, lookForCycles, makeXPathExpressionPropertyRecord, setFixupStatus, setLineNumber, setLocator, setRedefinitionLevel, setSchemaDocumentURI, setSystemId, setValidationStatus`

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

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

- - ### Field Detail

    - #### NAMESPACE_UNKNOWN

          public static final int NAMESPACE_UNKNOWN

      See Also:
        Constant Field Values

    - #### NAMESPACE_UNDER_CONSTRUCTION

          public static final int NAMESPACE_UNDER_CONSTRUCTION

      See Also:
        Constant Field Values

    - #### NAMESPACE_KNOWN

          public static final int NAMESPACE_KNOWN

      See Also:
        Constant Field Values

    - #### NAMESPACE_SEALED

          public static final int NAMESPACE_SEALED

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### PreparedSchema

          protected PreparedSchema()

      Create a dummy schema definition. This constructor is defined only for use by subclasses

    - #### PreparedSchema

          public PreparedSchema(EnterpriseConfiguration config)

      Create a new Schema definition
      Parameters:
        `config` - The configuration object holding system configuration information

  - ### Method Detail

    - #### setConfiguration

          public void setConfiguration(EnterpriseConfiguration config)

      Set the configuration
      Overrides:
        `setConfiguration` in class `SchemaStructure`
      Parameters:
        `config` - the Saxon configuration

    - #### getConfiguration

          public EnterpriseConfiguration getConfiguration()

      Get the configuration
      Overrides:
        `getConfiguration` in class `SchemaStructure`
      Returns:
        the Saxon configuration

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

    - #### getAttributeDecl

          public AttributeDecl getAttributeDecl(int fingerprint)

      Get the attribute declaration with a given name if there is one.
      Parameters:
        `fingerprint` - the fingerprint representing the name of the required attribute declaration
      Returns:
        the attribute declaration if found, or null otherwise

    - #### iterateAttributeDeclarations

          public Iterator<AttributeDecl> iterateAttributeDeclarations()

      Get an iterator over all the global attribute declarations defined in this schema
      Returns:
        an iterator over the 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(int fingerprint)

      Get the attribute declaration with a given name if there is one.
      Parameters:
        `fingerprint` - the fingerprint representing the name of the required attribute group
      Returns:
        the attribute declaration if found, or null otherwise

    - #### iterateAttributeGroups

          public Iterator<AttributeGroupDecl> iterateAttributeGroups()

      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(int fingerprint)

      Get the model group with a given name if there is one.
      Parameters:
        `fingerprint` - the fingerprint representing the name of the required named model group
      Returns:
        the group if found, or null otherwise

    - #### iterateModelGroups

          public Iterator<ModelGroupDefinition> iterateModelGroups()

      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(int fingerprint)

      Get the type with a given name if there is one. This method will also find built-in types.
      Parameters:
        `fingerprint` - the fingerprint representing the name of the required schema type
      Returns:
        the named simple or complex type if found, or null otherwise

    - #### getSimpleType

          public SimpleType getSimpleType(int fingerprint)

      Get the simple type with a given name if there is one. This method will also find built-in types.
      Parameters:
        `fingerprint` - the fingerprint representing the name of the required simple type
      Returns:
        the simple type if found, or null otherwise

    - #### iterateTypes

          public Iterator<SchemaType> iterateTypes()

      Get an iterator over all the named simple and complex types defined in this schema. This iterator will not include built-in types or anonymous types.
      Returns:
        an iterator over the types. Each item returned by the iterator will be an instance of `SchemaType`

    - #### 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(int fingerprint)

      Get type defined in this schema, searching both named and anonymous types
      Parameters:
        `fingerprint` - the fingerprint representing the name of the required schema type
      Returns:
        the schema type if found, else null

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

    - #### 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(int fingerprint)

      Get the global element declaration with a given name
      Parameters:
        `fingerprint` - identifies the name of the element
      Returns:
        the element declaration, or null if not found.

    - #### iterateElementDeclarations

          public Iterator<ElementDecl> iterateElementDeclarations()

      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(int fingerprint)

      Get the notation with a given name
      Parameters:
        `fingerprint` - identifies the name of the notation
      Returns:
        the element notation, or null if not found.

    - #### iterateNotations

          public Iterator<Notation> iterateNotations()

      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(int fingerprint)

      Get the identity constraint whose name has a given fingerprint
      Parameters:
        `fingerprint` - the fingerprint representing the name of the required constraint
      Returns:
        the identity constraint, or null if there is none with that name

    - #### iterateIdentityConstraints

          public Iterator<IdentityConstraint> iterateIdentityConstraints()

      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 Set<String> getTargetNamespaces()

      Get the set of all target namespaces of components present in this schema
      Returns:
        the set of all target namespaces for these components

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

    - #### validate

          public boolean validate(SchemaCompiler compiler)
                           throws SchemaException

      Checks the validity of this Schema definition, and if valid, adds the schema to the cache held by the EnterpriseConfiguration
      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)
                                                   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
      Returns:
        the target of the reference
      Throws:
        `SchemaException` - if the reference cannot be resolved

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

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