Package net.sf.saxon.event

## Class SequenceWriter

- java.lang.Object
- - net.sf.saxon.event.SequenceReceiver
  - - net.sf.saxon.event.SequenceWriter

- All Implemented Interfaces:
    `javax.xml.transform.Result`, `Receiver`
  Direct Known Subclasses:
    `AdaptiveEmitter`, `JSONSerializer`, `SequenceCollector`, `StreamingSequenceWriter`

      public abstract class SequenceWriter
      extends SequenceReceiver

  The `SequenceWriter` is used when writing a sequence of items, for example, when `xsl:variable` is used with content and an "as" attribute. The `SequenceWriter` builds the sequence; the concrete subclass is responsible for deciding what to do with the resulting items.

  Items may be supplied in either "composed" form (by calling the `SequenceReceiver.append(Item)` method, or in "decomposed" form (by a sequence of calls representing XML push events: `Outputter.startDocument(int)`, `Outputter.startElement(NodeName, SchemaType, Location, int)`, and so on. When items are supplied in decomposed form, a tree will be built, and the resulting document or element node is then written to the sequence in the same way as if it were supplied directly as a `NodeInfo` item.

- - ### Field Summary

    - ### Fields inherited from class net.sf.saxon.event.SequenceReceiver

      `pipelineConfiguration, previousAtomic, systemId`

    - ### Fields inherited from interface javax.xml.transform.Result

      `PI_DISABLE_OUTPUT_ESCAPING, PI_ENABLE_OUTPUT_ESCAPING`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `SequenceWriter​(PipelineConfiguration pipe)` |

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `append​(Item item, Location locationId, int copyNamespaces)` | Append an arbitrary item (node, atomic value, or function) to the output
    `void` | `characters​(java.lang.CharSequence s, Location locationId, int properties)` | Notify character data.
    `void` | `close()` | Notify the end of the event stream
    `void` | `comment​(java.lang.CharSequence comment, Location locationId, int properties)` | Notify a comment.
    `void` | `endDocument()` | Notify the end of a document node
    `void` | `endElement()` | Notify the end of an element.
    `TreeModel` | `getTreeModel()` | Get the tree model that will be used for creating trees when events are written to the sequence
    `void` | `processingInstruction​(java.lang.String target, java.lang.CharSequence data, Location locationId, int properties)` | Output a processing instruction
    `void` | `setTreeModel​(TreeModel treeModel)` | Set the tree model that will be used for creating trees when events are written to the sequence
    `void` | `setUnparsedEntity​(java.lang.String name, java.lang.String systemID, java.lang.String publicID)` | Notify an unparsed entity URI.
    `void` | `startDocument​(int properties)` | Notify the start of a document node
    `void` | `startElement​(NodeName elemName, SchemaType type, AttributeMap attributes, NamespaceMap namespaces, Location location, int properties)` | Notify the start of an element
    `boolean` | `usesTypeAnnotations()` | Ask whether this Receiver (or the downstream pipeline) makes any use of the type annotations supplied on element and attribute events.
    `abstract void` | `write​(Item item)` | Abstract method to be supplied by subclasses: output one item in the sequence.

    - ### Methods inherited from class net.sf.saxon.event.SequenceReceiver

      `append, decompose, flatten, getConfiguration, getErrorCodeForDecomposingFunctionItems, getNamePool, getPipelineConfiguration, getSystemId, handlesAppend, open, setPipelineConfiguration, setSystemId`

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

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

- - ### Constructor Detail

    - #### SequenceWriter

          public SequenceWriter​(PipelineConfiguration pipe)

  - ### Method Detail

    - #### write

          public abstract void write​(Item item)
                              throws XPathException

      Abstract method to be supplied by subclasses: output one item in the sequence.
      Parameters:
        `item` - the item to be written to the sequence
      Throws:
        `XPathException` - if any failure occurs while writing the item

    - #### startDocument

          public void startDocument​(int properties)
                             throws XPathException

      Description copied from interface: `Receiver`
      Notify the start of a document node
      Parameters:
        `properties` - bit-significant integer indicating properties of the document node. The definitions of the bits are in class `ReceiverOption`
      Throws:
        `XPathException` - if an error occurs

    - #### setUnparsedEntity

          public void setUnparsedEntity​(java.lang.String name,
                                        java.lang.String systemID,
                                        java.lang.String publicID)
                                 throws XPathException

      Description copied from class: `SequenceReceiver`
      Notify an unparsed entity URI.
      Specified by:
        `setUnparsedEntity` in interface `Receiver`
      Overrides:
        `setUnparsedEntity` in class `SequenceReceiver`
      Parameters:
        `name` - The name of the unparsed entity
        `systemID` - The system identifier of the unparsed entity
        `publicID` - The public identifier of the unparsed entity
      Throws:
        `XPathException` - if an error occurs

    - #### getTreeModel

          public TreeModel getTreeModel()

      Get the tree model that will be used for creating trees when events are written to the sequence
      Returns:
        the tree model, if one has been set using setTreeModel(); otherwise null

    - #### setTreeModel

          public void setTreeModel​(TreeModel treeModel)

      Set the tree model that will be used for creating trees when events are written to the sequence
      Parameters:
        `treeModel` - the tree model to be used. If none has been set, the default tree model for the configuration is used, unless a mutable tree is required and the default tree model is not mutable, in which case a linked tree is used.

    - #### endDocument

          public void endDocument()
                           throws XPathException

      Description copied from interface: `Receiver`
      Notify the end of a document node
      Throws:
        `XPathException` - if an error occurs

    - #### startElement

          public void startElement​(NodeName elemName,
                                   SchemaType type,
                                   AttributeMap attributes,
                                   NamespaceMap namespaces,
                                   Location location,
                                   int properties)
                            throws XPathException

      Description copied from interface: `Receiver`
      Notify the start of an element
      Parameters:
        `elemName` - the name of the element.
        `type` - the type annotation of the element.
        `attributes` - the attributes of this element
        `namespaces` - the in-scope namespaces of this element: generally this is all the in-scope namespaces, without relying on inheriting namespaces from parent elements
        `location` - an object providing information about the module, line, and column where the node originated
        `properties` - bit-significant properties of the element node. If there are no relevant properties, zero is supplied. The definitions of the bits are in class `ReceiverOption`
      Throws:
        `XPathException` - if an error occurs

    - #### endElement

          public void endElement()
                          throws XPathException

      Description copied from interface: `Receiver`
      Notify the end of an element. The receiver must maintain a stack if it needs to know which element is ending.
      Throws:
        `XPathException` - if an error occurs

    - #### characters

          public void characters​(java.lang.CharSequence s,
                                 Location locationId,
                                 int properties)
                          throws XPathException

      Description copied from interface: `Receiver`
      Notify character data. Note that some receivers may require the character data to be sent in a single event, but in general this is not a requirement.
      Parameters:
        `s` - The characters
        `locationId` - provides information such as line number and system ID.
        `properties` - Bit significant value. The following bits are defined:
        DISABLE_ESCAPING
          Disable escaping for this text node
        USE_CDATA
          Output as a CDATA section
      Throws:
        `XPathException` - if an error occurs

    - #### comment

          public void comment​(java.lang.CharSequence comment,
                              Location locationId,
                              int properties)
                       throws XPathException

      Description copied from interface: `Receiver`
      Notify a comment. Comments are only notified if they are outside the DTD.
      Parameters:
        `comment` - The content of the comment
        `locationId` - provides information such as line number and system ID.
        `properties` - Additional information about the comment.
      Throws:
        `XPathException` - if an error occurs

    - #### processingInstruction

          public void processingInstruction​(java.lang.String target,
                                            java.lang.CharSequence data,
                                            Location locationId,
                                            int properties)
                                     throws XPathException

      Description copied from interface: `Receiver`
      Output a processing instruction
      Parameters:
        `target` - The PI name. This must be a legal name (it will not be checked).
        `data` - The data portion of the processing instruction
        `locationId` - provides information such as line number and system ID.
        `properties` - Additional information about the PI.
      Throws:
        `XPathException` - if an error occurs

    - #### close

          public void close()
                     throws XPathException

      Description copied from interface: `Receiver`
      Notify the end of the event stream
      Throws:
        `XPathException` - if an error occurs

    - #### append

          public void append​(Item item,
                             Location locationId,
                             int copyNamespaces)
                      throws XPathException

      Description copied from class: `SequenceReceiver`
      Append an arbitrary item (node, atomic value, or function) to the output
      Specified by:
        `append` in interface `Receiver`
      Specified by:
        `append` in class `SequenceReceiver`
      Parameters:
        `item` - the item to be appended
        `locationId` - the location of the calling instruction, for diagnostics
        `copyNamespaces` - if the item is an element node, this indicates whether its namespaces need to be copied. Values are `ReceiverOption.ALL_NAMESPACES`; the default (0) means
      Throws:
        `XPathException` - if an error occurs

    - #### usesTypeAnnotations

          public boolean usesTypeAnnotations()

      Description copied from interface: `Receiver`
      Ask whether this Receiver (or the downstream pipeline) makes any use of the type annotations supplied on element and attribute events. The default implementation of this method returns false.
      Returns:
        true if the Receiver makes any use of this information. If false, the caller may supply untyped nodes instead of supplying the type annotation (or conversely, it may avoid stripping unwanted type annotations)