net.sf.saxon.s9api

## Class ItemTypeFactory

- java.lang.Object
- - net.sf.saxon.s9api.ItemTypeFactory

-     public class ItemTypeFactory
      extends Object

  This class is used for creating ItemType objects.

  The `ItemTypeFactory` class is thread-safe.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ItemTypeFactory(Processor processor)` Create an ItemTypeFactory

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `ItemType` | `getAtomicType(QName name)` Get an item type representing an atomic type.
    `ItemType` | `getAttributeTest(QName name, QName schemaType)` Get an ItemType that tests an element name and/or schema type.
    `ItemType` | `getDocumentTest(ItemType elementTest)` Make an ItemType representing a document-node() test with an embedded element test.
    `ItemType` | `getElementTest(QName name, QName schemaType, boolean nillable)` Make an ItemType that tests an element name and/or schema type.
    `XdmItem` | `getExternalObject(Object object)` Factory method to construct an "external object".
    `ItemType` | `getExternalObjectType(Class externalClass)` Get an ItemType representing the type of a Java object when used as an external object for use in conjunction with calls on extension/external functions.
    `ItemType` | `getItemType(XdmItem item)` Get an ItemType representing the type of a supplied XdmItem.
    `ItemType` | `getItemType(XdmNodeKind kind, QName name)` Get an item type that matches nodes of a specified kind with a specified name.
    `ItemType` | `getNodeKindTest(XdmNodeKind kind)` Get an item type that matches any node of a specified kind.
    `ItemType` | `getSchemaAttributeTest(QName name)` Get an ItemType representing an attribute declaration in the schema.
    `ItemType` | `getSchemaElementTest(QName name)` Make an ItemType representing an element declaration in the schema.

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

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

- - ### Constructor Detail

    - #### ItemTypeFactory

          public ItemTypeFactory(Processor processor)

      Create an ItemTypeFactory
      Parameters:
        `processor` - the processor used by this ItemTypeFactory. This must be supplied in the case of user-defined types or types that reference element or attribute names; for built-in types it can be omitted.

  - ### Method Detail

    - #### getAtomicType

          public ItemType getAtomicType(QName name)
                                 throws SaxonApiException

      Get an item type representing an atomic type. This may be a built-in type in the XML Schema namespace, or a user-defined atomic type. The resulting type will use the conversion rules configured for the supplied `Processor`.

      It is undefined whether two calls supplying the same QName will return the same ItemType object.

      Parameters:
        `name` - the name of the built-in or user-defined atomic type required
      Returns:
        an ItemType object representing this built-in or user-defined atomic type
      Throws:
        `SaxonApiException` - if the type name is not known, or if the type identified by the name is not an atomic type.

    - #### getNodeKindTest

          public ItemType getNodeKindTest(XdmNodeKind kind)

      Get an item type that matches any node of a specified kind.

      This corresponds to the XPath syntactic forms element(), attribute(), document-node(), text(), comment(), processing-instruction(). It also provides an option, not available in the XPath syntax, that matches namespace nodes.

      It is undefined whether two calls supplying the same argument value will return the same ItemType object.

      Parameters:
        `kind` - the kind of node for which a NodeTest is required
      Returns:
        an item type corresponding to the specified kind of node

    - #### getItemType

          public ItemType getItemType(XdmNodeKind kind,
                             QName name)

      Get an item type that matches nodes of a specified kind with a specified name.

      This corresponds to the XPath syntactic forms element(name), attribute(name), and processing-instruction(name). In the case of processing-instruction, the supplied QName must have no namespace.

      It is undefined whether two calls supplying the same argument values will return the same ItemType object.

      Parameters:
        `kind` - the kind of nodes that match
        `name` - the name of the nodes that match
      Returns:
        an ItemType that matches nodes of a given node kind with a given name
      Throws:
        `IllegalArgumentException` - if the node kind is other than element, attribute, or processing instruction, or if the node kind is processing instruction and the name is in a namespace.

    - #### getSchemaElementTest

          public ItemType getSchemaElementTest(QName name)
                                        throws SaxonApiException

      Make an ItemType representing an element declaration in the schema. This is the equivalent of the XPath syntax `schema-element(element-name)`

      It is undefined whether two calls supplying the same argument values will return the same ItemType object.

      Parameters:
        `name` - the element name
      Returns:
        the ItemType
      Throws:
        `SaxonApiException` - if the schema does not contain a global element declaration for the given name

    - #### getElementTest

          public ItemType getElementTest(QName name,
                                QName schemaType,
                                boolean nillable)
                                  throws SaxonApiException

      Make an ItemType that tests an element name and/or schema type. This is the equivalent of the XPath syntax `element(element-name, type)`

      It is undefined whether two calls supplying the same argument values will return the same ItemType object.

      Parameters:
        `name` - the element name, or null if there is no constraint on the name (equivalent to specifying `element(*, type)`)
        `schemaType` - the name of the required schema type, or null if there is no constraint on the type (equivalent to specifying `element(name)`)
        `nillable` - if a nilled element is allowed to match the type (equivalent to specifying "?" after the type name). The value is ignored if schemaType is null.
      Returns:
        the constructed ItemType
      Throws:
        `SaxonApiException` - if the schema does not contain a global element declaration for the given name

    - #### getSchemaAttributeTest

          public ItemType getSchemaAttributeTest(QName name)
                                          throws SaxonApiException

      Get an ItemType representing an attribute declaration in the schema. This is the equivalent of the XPath syntax `schema-attribute(attribute-name)`

      It is undefined whether two calls supplying the same argument values will return the same ItemType object.

      Parameters:
        `name` - the attribute name
      Returns:
        the ItemType
      Throws:
        `SaxonApiException` - if the schema does not contain a global attribute declaration for the given name

    - #### getAttributeTest

          public ItemType getAttributeTest(QName name,
                                  QName schemaType)
                                    throws SaxonApiException

      Get an ItemType that tests an element name and/or schema type. This is the equivalent of the XPath syntax `element(element-name, type)`

      It is undefined whether two calls supplying the same argument values will return the same ItemType object.

      Parameters:
        `name` - the element name, or null if there is no constraint on the name (equivalent to specifying `element(*, type)`)
        `schemaType` - the name of the required schema type, or null of there is no constraint on the type (equivalent to specifying `element(name)`)
      Returns:
        the constructed ItemType
      Throws:
        `SaxonApiException` - if the schema does not contain a global element declaration for the given name

    - #### getDocumentTest

          public ItemType getDocumentTest(ItemType elementTest)

      Make an ItemType representing a document-node() test with an embedded element test. This reflects the XPath syntax `document-node(element(N, T))` or `document-node(schema-element(N))`.

      It is undefined whether two calls supplying the same argument values will return the same ItemType object.

      Parameters:
        `elementTest` - the elementTest. An IllegalArgumentException is thrown if the supplied ItemTest is not an elementTest or schemaElementTest.
      Returns:
        a new ItemType representing the document test

    - #### getExternalObjectType

          public ItemType getExternalObjectType(Class externalClass)

      Get an ItemType representing the type of a Java object when used as an external object for use in conjunction with calls on extension/external functions.
      Parameters:
        `externalClass` - a Java class
      Returns:
        the ItemType representing the type of external objects of this class

    - #### getExternalObject

          public XdmItem getExternalObject(Object object)

      Factory method to construct an "external object". This is an XDM value that wraps a Java object. Such values can be passed as parameters to stylesheets or queries, for use in conjunction with external (extension) functions.

      Changed in Saxon 9.5 to return XdmItem rather than XdmAtomicValue, since wrapped external objects are now modelled as a separate type of item, rather than as an atomic value.

      Parameters:
        `object` - the value to be wrapped as an external object. Must not be null.
      Returns:
        the object, wrapped as an XdmAtomicValue

    - #### getItemType

          public ItemType getItemType(XdmItem item)

      Get an ItemType representing the type of a supplied XdmItem. If the supplied item is an atomic value, the returned ItemType will reflect the most specific atomic type of the item. If the supplied item is a node, the returned item type will reflect the node kind, and if the node has a name, then its name. It will not reflect the type annotation.
      Parameters:
        `item` - the supplied item whose type is required
      Returns:
        the type of the supplied item

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