com.saxonica.stream.watch

## Class WatchManager

- java.lang.Object
- - net.sf.saxon.event.SequenceReceiver
  - - net.sf.saxon.event.ProxyReceiver
    - - com.saxonica.stream.watch.WatchManager

- All Implemented Interfaces:
    Result, Receiver, NamespaceResolver
  Direct Known Subclasses:
    ConstraintChecker

      public class WatchManager
      extends ProxyReceiver
      implements NamespaceResolver

  This class sits on a push pipeline and evaluates the passing element and attribute nodes. One or more Watch objects can be registered with the pipeline at any time; element and attribute events are notified to the active Watch objects. A watch that is added immediately after a startElement call is automatically dropped at the corresponding endElement call. If a Watch matches a startElement call, then it becomes an active Watch; it is automatically deactivated (but not dropped) at the corresponding endElement call.

  A Watch is not itself a receiver, but it can nominate a Receiver to receive all events while it is active. It will stop receiving events when it is deactivated.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Stack<List<com.saxonica.stream.watch.WatchManager.ClosedownAction>>` | `activeWatchStack`
    `protected int` | `elementStackTop`
    `protected List<Watch>` | `watchList`

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

      `nextReceiver`

    - ### 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 and Description
    `WatchManager(Receiver next)` Create a WatchManager

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `addPrearrangedWatches()`
    `void` | `addWatch(Watch watch)` Add a new Watch.
    `void` | `attribute(NodeName nameCode, SimpleType typeCode, CharSequence value, int locationId, int properties)` Notify an attribute
    `void` | `characters(CharSequence chars, int locationId, int properties)` Text node
    `void` | `comment(CharSequence chars, int locationId, int properties)` Output a comment
    `void` | `endDocument()` Notify the end of a document node
    `void` | `endElement()` Notify end of element
    `Map<Accumulator,AccumulatorWatch>` | `getAccumulatorWatchMap()`
    `FleetingDocumentNode` | `getDocumentNode()`
    `String` | `getURIForPrefix(String prefix, boolean useDefault)` Get the namespace URI corresponding to a given prefix.
    `XPathContext` | `getXPathContext()`
    `Iterator<String>` | `iteratePrefixes()` Get an iterator over all the prefixes declared in this namespace context.
    `void` | `namespace(NamespaceBinding namespaceBinding, int properties)` Notify a namespace
    `void` | `processingInstruction(String target, CharSequence data, int locationId, int properties)` Processing Instruction
    `void` | `setAccumulatorWatchMap(Map<Accumulator,AccumulatorWatch> accumulatorWatchMap)`
    `void` | `setStartTagBuffer(StartTagBuffer stb)`
    `void` | `setXPathContext(XPathContext context)`
    `void` | `startContent()` Start element content (called after all the attributes and namespaces have been processed)
    `void` | `startDocument(int properties)` Start of a document node.
    `void` | `startElement(NodeName elementName, SchemaType typeCode, int locationId, int properties)` Output 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

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

      `append, close, getNamePool, getUnderlyingReceiver, open, setPipelineConfiguration, setSystemId, setUnderlyingReceiver, setUnparsedEntity`

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

      `append, getConfiguration, getPipelineConfiguration, getSystemId`

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

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

- - ### Field Detail

    - #### elementStackTop

          protected int elementStackTop

    - #### watchList

          protected List<Watch> watchList

    - #### activeWatchStack

          protected Stack<List<com.saxonica.stream.watch.WatchManager.ClosedownAction>> activeWatchStack

  - ### Constructor Detail

    - #### WatchManager

          public WatchManager(Receiver next)

      Create a WatchManager
      Parameters:
        `next` - the receiver that is next in the pipeline for receiving events

  - ### Method Detail

    - #### setStartTagBuffer

          public void setStartTagBuffer(StartTagBuffer stb)

    - #### setXPathContext

          public void setXPathContext(XPathContext context)

    - #### getXPathContext

          public XPathContext getXPathContext()

    - #### startDocument

          public void startDocument(int properties)
                             throws XPathException

      Start of a document node.
      Specified by:
        `startDocument` in interface `Receiver`
      Overrides:
        `startDocument` in class `ProxyReceiver`
      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

    - #### startElement

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

      Output element start tag
      Specified by:
        `startElement` in interface `Receiver`
      Overrides:
        `startElement` in class `ProxyReceiver`
      Parameters:
        `elementName` - integer code identifying the name of the element within the name pool.
        `typeCode` - integer code identifying the element's type within the name pool.
        `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` - properties of the element node
      Throws:
        `XPathException` - if an error occurs

    - #### addPrearrangedWatches

          protected void addPrearrangedWatches()
                                        throws XPathException

      Throws:
        `XPathException`

    - #### attribute

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

      Notify an attribute
      Specified by:
        `attribute` in interface `Receiver`
      Overrides:
        `attribute` in class `ProxyReceiver`
      Parameters:
        `nameCode` - integer identifying the name of the attribute
        `typeCode` - integer identifying the type annotation (ignored)
        `value` - the value of the attribute
        `properties` - additional properties of the attribute
        `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` - On any failure to write the attribute

    - #### namespace

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

      Notify a namespace
      Specified by:
        `namespace` in interface `Receiver`
      Overrides:
        `namespace` in class `ProxyReceiver`
      Parameters:
        `namespaceBinding` - the prefix/uri pair being notified
        `properties` - properties of this event
      Throws:
        `XPathException` - if any error occurs

    - #### characters

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

      Text node
      Specified by:
        `characters` in interface `Receiver`
      Overrides:
        `characters` in class `ProxyReceiver`
      Parameters:
        `chars` - The characters
        `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` - 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

    - #### endElement

          public void endElement()
                          throws XPathException

      Notify end of element
      Specified by:
        `endElement` in interface `Receiver`
      Overrides:
        `endElement` in class `ProxyReceiver`
      Throws:
        `XPathException` - if an error occurs

    - #### endDocument

          public void endDocument()
                           throws XPathException

      Notify the end of a document node
      Specified by:
        `endDocument` in interface `Receiver`
      Overrides:
        `endDocument` in class `ProxyReceiver`
      Throws:
        `XPathException` - if an error occurs

    - #### comment

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

      Output a comment
      Specified by:
        `comment` in interface `Receiver`
      Overrides:
        `comment` in class `ProxyReceiver`
      Parameters:
        `chars` - 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

      Processing Instruction
      Specified by:
        `processingInstruction` in interface `Receiver`
      Overrides:
        `processingInstruction` in class `ProxyReceiver`
      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

    - #### startContent

          public void startContent()
                            throws XPathException

      Start element content (called after all the attributes and namespaces have been processed)
      Specified by:
        `startContent` in interface `Receiver`
      Overrides:
        `startContent` in class `ProxyReceiver`
      Throws:
        `XPathException`

    - #### addWatch

          public void addWatch(Watch watch)
                        throws XPathException

      Add a new Watch. This is associated with the current level in the element stack, and is automatically closed and dropped when the current element goes out of scope.
      Parameters:
        `watch` - the watch to be added
      Throws:
        `XPathException` - if any error occurs

    - #### getURIForPrefix

          public String getURIForPrefix(String prefix,
                               boolean useDefault)

      Get the namespace URI corresponding to a given prefix. Return null if the prefix is not in scope.
      Specified by:
        `getURIForPrefix` in interface `NamespaceResolver`
      Parameters:
        `prefix` - the namespace prefix. May be the zero-length string, indicating that there is no prefix. This indicates either the default namespace or the null namespace, depending on the value of useDefault.
        `useDefault` - true if the default namespace is to be used when the prefix is "". If false, the method returns "" when the prefix is "".
      Returns:
        the uri for the namespace, or null if the prefix is not in scope. The "null namespace" is represented by the pseudo-URI "".

    - #### iteratePrefixes

          public Iterator<String> iteratePrefixes()

      Description copied from interface: `NamespaceResolver`
      Get an iterator over all the prefixes declared in this namespace context. This will include the default namespace (prefix="") and the XML namespace where appropriate
      Specified by:
        `iteratePrefixes` in interface `NamespaceResolver`
      Returns:
        an iterator over all the prefixes for which a namespace binding exists, including the zero-length string to represent the null/absent prefix if it is bound

    - #### 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
      Specified by:
        `usesTypeAnnotations` in interface `Receiver`
      Overrides:
        `usesTypeAnnotations` in class `ProxyReceiver`
      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

    - #### getDocumentNode

          public FleetingDocumentNode getDocumentNode()

    - #### getAccumulatorWatchMap

          public Map<Accumulator,AccumulatorWatch> getAccumulatorWatchMap()

    - #### setAccumulatorWatchMap

          public void setAccumulatorWatchMap(Map<Accumulator,AccumulatorWatch> accumulatorWatchMap)

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