Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## net.sf.saxon.event
Class SequenceWriter

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

All Implemented Interfaces:
  Result, Receiver

Direct Known Subclasses:
  SequenceExchanger.SequencePusher, SequenceFilter, SequenceOutputter, SequenceTransmitter

    public abstract class SequenceWriter

extends SequenceReceiver

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

This class is not used to build temporary trees. For that, the ComplexContentOutputter is used.

Author:
  Michael H. Kay

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
`SequenceWriter(PipelineConfiguration pipe)`

Method Summary
`protected boolean` | `adviseReuse()` Decide whether reuse of the SequenceWriter is advisable
`void` | `append(Item item, int locationId, int copyNamespaces)` Append an item to the sequence, performing any necessary type-checking and conversion
`void` | `attribute(NodeName attName, SimpleType typeCode, CharSequence value, int locationId, int properties)` Output an attribute value.
`void` | `characters(CharSequence s, int locationId, int properties)` Produce text content output.
`void` | `close()` Close the output
`void` | `comment(CharSequence comment, int locationId, int properties)` Write a comment.
`void` | `endDocument()` Notify the end of a document node
`void` | `endElement()` Output an element end tag.
`void` | `namespace(NamespaceBinding namespaceBinding, int properties)` Output a namespace declaration.
`void` | `processingInstruction(String target, CharSequence data, int locationId, int properties)` Write a processing instruction No-op in this implementation
`void` | `startContent()` The startContent() event is notified after all namespaces and attributes of an element have been notified, and before any child nodes are notified.
`void` | `startDocument(int properties)` Start of a document node.
`void` | `startElement(NodeName elemName, SchemaType typeCode, int locationId, int properties)` Output an element start tag.
`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, getConfiguration, getNamePool, getPipelineConfiguration, getSystemId, open, setPipelineConfiguration, setSystemId, setUnparsedEntity`

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

  Start of a document node.

  Parameters:
    `properties` - bit-significant integer indicating properties of the document node. The definitions of the bits are in class `ReceiverOptions`
  Throws:
    `XPathException` - if an error occurs

### adviseReuse

    protected boolean adviseReuse()

  Decide whether reuse of the SequenceWriter is advisable

  Returns:
    true if reuse is considered advisable

### endDocument

    public void endDocument()
                     throws XPathException

  Notify the end of a document node

  Throws:
    `XPathException` - if an error occurs

### startElement

    public void startElement(NodeName elemName,
                             SchemaType typeCode,
                             int locationId,
                             int properties)
                      throws XPathException

  Output an element start tag.

  Parameters:
    `elemName` - The element name code - a code held in the Name Pool
    `typeCode` - Integer code identifying the type of this element. Zero identifies the default type, that is xs:anyType
    `properties` - bit-significant flags indicating any special information
    `locationId` - an integer which can be interpreted using a `LocationProvider` to return information such as line number and system ID. If no location information is available, the value zero is supplied.
  Throws:
    `XPathException` - if an error occurs

### endElement

    public void endElement()
                    throws XPathException

  Output an element end tag.

  Throws:
    `XPathException` - if an error occurs

### namespace

    public void namespace(NamespaceBinding namespaceBinding,
                          int properties)
                   throws XPathException

  Output a namespace declaration.
  This is added to a list of pending namespaces for the current start tag. If there is already another declaration of the same prefix, this one is ignored. Note that unlike SAX2 startPrefixMapping(), this call is made AFTER writing the start tag.

  Parameters:
    `namespaceBinding` - The namespace binding
    `properties` - Allows special properties to be passed if required
  Throws:
    `XPathException` - if there is no start tag to write to (created using writeStartTag), or if character content has been written since the start tag was written.

### attribute

    public void attribute(NodeName attName,
                          SimpleType typeCode,
                          CharSequence value,
                          int locationId,
                          int properties)
                   throws XPathException

  Output an attribute value.

  Parameters:
    `attName` - An integer code representing the name of the attribute, as held in the Name Pool
    `typeCode` - Integer code identifying the type annotation of the attribute; zero represents the default type (xs:untypedAtomic)
    `value` - The value of the attribute
    `properties` - Bit significant flags for passing extra information to the serializer, e.g. to disable escaping
    `locationId` - an integer which can be interpreted using a `LocationProvider` to return information such as line number and system ID. If no location information is available, the value zero is supplied.
  Throws:
    `XPathException` - if there is no start tag to write to (created using writeStartTag), or if character content has been written since the start tag was written.

### startContent

    public void startContent()
                      throws XPathException

  The startContent() event is notified after all namespaces and attributes of an element have been notified, and before any child nodes are notified.

  Throws:
    `XPathException` - for any failure

### characters

    public void characters(CharSequence s,
                           int locationId,
                           int properties)
                    throws XPathException

  Produce text content output.

  Parameters:
    `s` - The String to be output
    `properties` - bit-significant flags for extra information, e.g. disable-output-escaping
    `locationId` - an integer which can be interpreted using a `LocationProvider` to return information such as line number and system ID. If no location information is available, the value zero is supplied.
  Throws:
    `XPathException` - for any failure

### comment

    public void comment(CharSequence comment,
                        int locationId,
                        int properties)
                 throws XPathException

  Write a comment.

  Parameters:
    `comment` - The content of the comment
    `locationId` - an integer which can be interpreted using a `LocationProvider` to return information such as line number and system ID. If no location information is available, the value zero is supplied.
    `properties` - Additional information about the comment.
  Throws:
    `XPathException` - if an error occurs

### processingInstruction

    public void processingInstruction(String target,
                                      CharSequence data,
                                      int locationId,
                                      int properties)
                               throws XPathException

  Write a processing instruction No-op in this implementation

  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` - an integer which can be interpreted using a `LocationProvider` to return information such as line number and system ID. If no location information is available, the value zero is supplied.
    `properties` - Additional information about the PI.
  Throws:
    `XPathException` - if an error occurs

### close

    public void close()
               throws XPathException

  Close the output

  Throws:
    `XPathException` - if an error occurs

### append

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

  Append an item to the sequence, performing any necessary type-checking and conversion

  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 `NodeInfo.ALL_NAMESPACES`, `NodeInfo.LOCAL_NAMESPACES`, `NodeInfo.NO_NAMESPACES`
  Throws:
    `XPathException` - if the operation fails

### usesTypeAnnotations

    public boolean usesTypeAnnotations()

  Ask whether this Receiver (or the downstream pipeline) makes any use of the type annotations supplied on element and attribute events

  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

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

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