com.saxonica.ee.stream.feed

Interface Feed

All Known Implementing Classes:

AbsorptionFeed, ApplyImportsAction, ApplyTemplatesAction, ApplyTemplatesFeed, BooleanFnAdjunct.BooleanFnFeed, BufferingFeed, BufferingFilterExpressionFeed, CallableFeed, CardinalityCheckingFeed, ComplexNodeEventFeed, CopyOfFeed, DecomposingFeed, DocumentInstrAdjunct.DocumentInstrFeed, ElementCreatorFeed, EmptiableElementFeed, FilteringFeed, ForEachAction, ForEachGroupAction, ForExpressionAdjunct.ForExpressionFeed, GeneralComparisonFeed, GroupedItemStoppingFeed, ItemCheckingFeed, ItemFeed, ItemMappingFeed, IterateAction, LiteralAdjunct.LiteralItemFeed, MotionlessFeed, NextIterationFeed, NextMatchAction, NoOpenOrCloseFeed, ResultDocumentAdjunct.ResultDocumentFeed, ShallowCopyEventFeed, SimpleContentFeed, SimpleNodeConstructorFeed, SnapshotFeed, StringValueFeed, TryCatchAdjunct.TryCatchFeed, TypedValueFeed, WithParamFeed

public interface Feed

A Feed is a processing object that sits on a push pipeline to evaluate some expression. One operand of the expression is a streamed operand, and this operand delivers a sequence either of composed items, or of start/end element events (or a mixture of both). The calls to the Feed represent incremental events in the evaluation of the streamed operand. The Feed is responsible for processing this stream of events and generating a new stream of events representing the result of the expression, which are pushed to the next step in the pipeline in the same way.

A "composed feed" consists entirely of items, supplied using the processItem interface. A "decomposed feed" represents a tree using a sequence of startElement/endElement events. In general the code for a particular expression should be prepared to accept either. However, in many cases (especially expressions that atomize their operand), it is known that the input will always be composed, as a result of the action of an earlier step in the pipeline.

A Feed musy be serially reusable; that is, its state after exiting the close() method must be the same as the state before entering the open() method.

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.
void	endSelectedParentNode(int locationId) Signal that the endElement event has occurred for the element whose startElement event caused the Watch to be activated.
PipelineConfiguration	getPipelineConfiguration() Get the pipeline configuration
SequenceReceiver	getReceiver() Get a receiver to which start and end events for documents and elements can be written.
void	open(Terminator terminator) Open the feed.
void	processItem(Item item) Signal that a node (other than a document or element node) that matches the selection has been found, or that a grounded item is being passed to the next expression in the evaluation pipeline.
Receiver	startSelectedParentNode(FleetingParentNode node, int locationId) Signal that an element or document node has been found that .

Method Detail

getPipelineConfiguration

PipelineConfiguration getPipelineConfiguration()

Get the pipeline configuration

Returns:

the pipeline configuration

open

void open(Terminator terminator)
          throws XPathException

Open the feed. This is done at the point where evaluation of an expression begins.

Parameters:

terminator - provides a method for early termination of the streamed processing. The Feed should call the terminator.terminate() method, and close() the result, if it has computed its result and requires no more input. After a call on terminate(), the feed MAY be called to supply further input (which it should ignore), or it may never be called again. The Feed should leave its state clean to allow serial reuse, via another call on open().

Throws:

XPathException - May be raised if a dynamic error occurs

startSelectedParentNode

Receiver startSelectedParentNode(FleetingParentNode node,
                               int locationId)
                                 throws XPathException

Signal that an element or document node has been found that . This method is called by the WatchManager while processing the startElement or startDocument event that matches the selection.

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

endSelectedParentNode

void endSelectedParentNode(int locationId)
                           throws XPathException

Signal that the endElement event has occurred for the element whose startElement event caused the Watch to be activated.

Parameters:

locationId - the location of the element

Throws:

XPathException - May be raised if a constraint implemented by this Watch is violated

processItem

void processItem(Item item)
                 throws XPathException

Signal that a node (other than a document or element node) that matches the selection has been found, or that a grounded item is being passed to the next expression in the evaluation pipeline.

Parameters:

item - the node that was matched.

Throws:

XPathException - May be raised if a dynamic error occurs

close

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.

Throws:

XPathException - May be raised if a dynamic error occurs

getReceiver

SequenceReceiver getReceiver()

Get a receiver to which start and end events for documents and elements can be written. By default this will be the same as the receiver for the result feed, because very few XSLT constructs (specifically, variables and functions) allow the results of document and element constructors to be captured for further processing. A construct that does need to process these events will intercept them by providing its own receiver, typically a SequenceOutputter.

Returns:

the receiver