com.saxonica.validate

## Class AbstractWatch

- java.lang.Object
- - com.saxonica.validate.AbstractWatch

- All Implemented Interfaces:
    Watch
  Direct Known Subclasses:
    AccumulatorWatch, ComposingWatch, EventPushingWatch, FieldWatch, ForkingWatch, SelectorWatch

      public abstract class AbstractWatch
      extends Object
      implements Watch

  A Watch represents a class that is interested in looking at nodes for the purpose of evaluating uniqueness and key constraints, or for XSLT streaming.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractWatch()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `close()` The close() method is called immediately before the Watch is destroyed, that is, when the element whose declaration scopes the constraint implemented by this Watch goes out of scope.
    `FleetingNode` | `getAnchorNode()` Get the anchor node for the watch.
    `NamespaceResolver` | `getNamespaceResolver()` Get the namespace resolver in use by the Watch
    `PipelineConfiguration` | `getPipelineConfiguration()` Get the pipeline configuration in use
    `Pattern` | `getSelection()` Get the selection (that is, the restricted XPath expression) that defines the nodes that this Watch is looking for
    `void` | `notifySelectedLeafNode(FleetingNode node, int locationId)` Signal that a node (other than an element) that matches the selection has been found.
    `void` | `open()` Open the watch.
    `void` | `setAnchorNode(FleetingNode anchor)` Set the anchor node for the watch.
    `void` | `setNamespaceResolver(NamespaceResolver resolver)` Set a NamespaceResolver for use by the Watch
    `void` | `setPipelineConfiguration(PipelineConfiguration pipe)` Set the PipelineConfiguration in use
    `void` | `setSelection(Pattern selection)` Set the selection (that is, the streamable XPath expression) that defines the nodes that this Watch is looking for

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

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

    - ### Methods inherited from interface com.saxonica.stream.watch.Watch

      `endSelectedParentNode, startSelectedParentNode`

- - ### Constructor Detail

    - #### AbstractWatch

          public AbstractWatch()

  - ### Method Detail

    - #### setSelection

          public final void setSelection(Pattern selection)

      Set the selection (that is, the streamable XPath expression) that defines the nodes that this Watch is looking for
      Specified by:
        `setSelection` in interface `Watch`
      Parameters:
        `selection` - the streamable XPath expression

    - #### getSelection

          public final Pattern getSelection()

      Get the selection (that is, the restricted XPath expression) that defines the nodes that this Watch is looking for
      Specified by:
        `getSelection` in interface `Watch`
      Returns:
        the selection

    - #### setPipelineConfiguration

          public final void setPipelineConfiguration(PipelineConfiguration pipe)

      Set the PipelineConfiguration in use
      Specified by:
        `setPipelineConfiguration` in interface `Watch`
      Parameters:
        `pipe` - the PipelineConfiguration in use

    - #### getPipelineConfiguration

          public PipelineConfiguration getPipelineConfiguration()

      Get the pipeline configuration in use
      Specified by:
        `getPipelineConfiguration` in interface `Watch`
      Returns:
        the pipeline configuration

    - #### setNamespaceResolver

          public final void setNamespaceResolver(NamespaceResolver resolver)

      Set a NamespaceResolver for use by the Watch
      Specified by:
        `setNamespaceResolver` in interface `Watch`
      Parameters:
        `resolver` - the namespace resolver to be used

    - #### getNamespaceResolver

          public NamespaceResolver getNamespaceResolver()

      Get the namespace resolver in use by the Watch
      Specified by:
        `getNamespaceResolver` in interface `Watch`
      Returns:
        the namespace resolver

    - #### setAnchorNode

          public void setAnchorNode(FleetingNode anchor)

      Set the anchor node for the watch. This is the node to which the watch is scoped, typically the context node for the streamable path expression that defines the root of the subtree within which nodes are being sought.
      Specified by:
        `setAnchorNode` in interface `Watch`
      Parameters:
        `anchor` - The anchor node within which the watch is scoped

    - #### getAnchorNode

          public FleetingNode getAnchorNode()

      Get the anchor node for the watch. This is the node to which the watch is scoped, typically the context node for the streamable path expression that defines the root of the subtree within which nodes are being sought.
      Specified by:
        `getAnchorNode` in interface `Watch`
      Returns:
        The anchor node within which the watch is scoped

    - #### open

          public void open()
                    throws XPathException

      Open the watch. This is done at the point where it first starts watching for nodes that match the selection.
      Specified by:
        `open` in interface `Watch`
      Throws:
        `XPathException`

    - #### notifySelectedLeafNode

          public void notifySelectedLeafNode(FleetingNode node,
                                    int locationId)
                                      throws XPathException

      Signal that a node (other than an element) that matches the selection has been found.
      Specified by:
        `notifySelectedLeafNode` in interface `Watch`
      Parameters:
        `node` - the node that was matched.
        `locationId` - the location for use in error messages
      Throws:
        `XPathException`

    - #### close

          public void close()
                     throws XPathException

      The close() method is called immediately before the Watch is destroyed, that is, when the element whose declaration scopes the constraint implemented by this Watch goes out of scope. The default implementation does nothing.
      Specified by:
        `close` in interface `Watch`
      Throws:
        `XPathException`

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