Package com.saxonica.ee.stream.watch

## Class ApplyTemplatesAction

- java.lang.Object
- - net.sf.saxon.event.Outputter
  - - net.sf.saxon.event.ProxyOutputter
    - - com.saxonica.ee.stream.feed.ItemFeed
      - - com.saxonica.ee.stream.watch.ApplyTemplatesAction

- All Implemented Interfaces:
    `javax.xml.transform.Result`, `Receiver`
  Direct Known Subclasses:
    `ApplyImportsAction`, `NextMatchAction`

      public class ApplyTemplatesAction
      extends ItemFeed

  This watch implements xsl:apply-templates in streaming mode. It watches for the nodes selected by the xsl:apply-templates instruction; when such a node is encountered, it locates the relevant (inverted) template, and activates it.

- - ### Field Summary

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

      `pipelineConfiguration, systemId`

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

      `PI_DISABLE_OUTPUT_ESCAPING, PI_ENABLE_OUTPUT_ESCAPING`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `ApplyTemplatesAction​(Expression expression, ItemFeed result, XPathContext context)` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `append​(Item item)` | Signal that a item (other than a streamed element) that matches the selection has been found.
    `void` | `close()` | Finish evaluating the expression.
    `void` | `computeActualParams​(WithParam[] params)` |
    `void` | `computeTunnelParams​(WithParam[] params)` |
    `void` | `endSelectedParentNode​(Location locationId)` | Signal that the endElement event has occurred for the element whose startElement event caused the Watch to be activated.
    `protected XPathContext` | `getLocalContext()` |
    `Component` | `getMode()` |
    `protected Rule` | `getRule​(FleetingNode node)` | Get the template rule matching a specific node
    `void` | `open​(Terminator terminator)` | Start evaluating the expression.
    `void` | `setActualParams​(ParameterSet params)` |
    `void` | `setMode​(Component.M mode)` |
    `void` | `setTunnelParams​(ParameterSet params)` |
    `void` | `setWatchManager​(WatchManager watchManager)` |
    `Receiver` | `startSelectedParentNode​(FleetingParentNode node, Location locationId)` | Signal that an element or document node has been found that matches the selection that this Watch is looking for.

    - ### Methods inherited from class com.saxonica.ee.stream.feed.ItemFeed

      `append, dynamicError, getContext, getExpression, getResult, getTerminator, hasFailed, processItems, setExpression, setHasFailed, setTerminator`

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

      `attribute, characters, comment, endDocument, endElement, getNextOutputter, namespace, open, processingInstruction, setLocation, setUnparsedEntity, startContent, startDocument, startElement, startElement, usesTypeAnnotations`

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

      `getConfiguration, getPipelineConfiguration, getStringReceiver, getSystemId, namespaces, setPipelineConfiguration, setSystemId`

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

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

    - ### Methods inherited from interface net.sf.saxon.event.Receiver

      `handlesAppend`

- - ### Constructor Detail

    - #### ApplyTemplatesAction

          public ApplyTemplatesAction​(Expression expression,
                                      ItemFeed result,
                                      XPathContext context)

  - ### Method Detail

    - #### open

          public void open​(Terminator terminator)
                    throws XPathException

      Description copied from class: `ItemFeed`
      Start evaluating the expression. The default implementation does nothing.
      Overrides:
        `open` in class `ItemFeed`
      Parameters:
        `terminator` - used to achieve early exit
      Throws:
        `XPathException` - if a dynamic error occurs

    - #### computeActualParams

          public void computeActualParams​(WithParam[] params)
                                   throws XPathException

      Throws:
        `XPathException`

    - #### computeTunnelParams

          public void computeTunnelParams​(WithParam[] params)
                                   throws XPathException

      Throws:
        `XPathException`

    - #### setActualParams

          public void setActualParams​(ParameterSet params)

    - #### setTunnelParams

          public void setTunnelParams​(ParameterSet params)

    - #### getLocalContext

          protected XPathContext getLocalContext()

    - #### setMode

          public void setMode​(Component.M mode)

    - #### getMode

          public Component getMode()

    - #### setWatchManager

          public void setWatchManager​(WatchManager watchManager)

    - #### startSelectedParentNode

          public Receiver startSelectedParentNode​(FleetingParentNode node,
                                                  Location locationId)
                                           throws XPathException

      Signal that an element or document node has been found that matches the selection that this Watch is looking for. This method is called by the WatchManager while processing the startElement or startDocument event that matches the selection.
      Overrides:
        `startSelectedParentNode` in class `ItemFeed`
      Parameters:
        `node` - the element or document node whose start event has been matched
        `locationId` - the location associated with the element or document node (may be the location of the instruction that created it)
      Returns:
        a Receiver to be notified of all events starting with the startElement/startDocument event for the matched element, and ending with the endElement event for that element; or null if this feature is not required.
      Throws:
        `XPathException` - May be raised if a dynamic error occurs

    - #### getRule

          protected Rule getRule​(FleetingNode node)
                          throws XPathException

      Get the template rule matching a specific node
      Parameters:
        `node` - the node (in a streamed input document) to be matched
      Returns:
        the best-fit template rule used to process this node
      Throws:
        `XPathException` - if a dynamic error occurs

    - #### append

          public void append​(Item item)
                      throws XPathException

      Signal that a item (other than a streamed element) that matches the selection has been found.
      Specified by:
        `append` in interface `Receiver`
      Specified by:
        `append` in class `ItemFeed`
      Parameters:
        `item` - the item that was matched.
      Throws:
        `XPathException` - if the operation fails

    - #### endSelectedParentNode

          public void endSelectedParentNode​(Location locationId)
                                     throws XPathException

      Signal that the endElement event has occurred for the element whose startElement event caused the Watch to be activated.
      Overrides:
        `endSelectedParentNode` in class `ItemFeed`
      Parameters:
        `locationId` - the location of the node in the source, or of the instruction that created it
      Throws:
        `ValidationException` - May be raised if the constraint implemented by this Watch is violated @param locationId the location of the node in the source, or of the instruction that created it
        `XPathException` - May be raised if a constraint implemented by this Watch is violated

    - #### close

          public void close()
                     throws XPathException

      Description copied from class: `ItemFeed`
      Finish evaluating the expression.
      Specified by:
        `close` in interface `Receiver`
      Overrides:
        `close` in class `ItemFeed`
      Throws:
        `XPathException` - if a dynamic error occurs