Package com.saxonica.ee.stream

Class Streamability

java.lang.Object

com.saxonica.ee.stream.Streamability

public class Streamability
extends java.lang.Object

Supporting class for assessing the streamability of expressions. Among other things, it contains an implementation of the General Streamability Rules.

Constructor Summary

Constructors

Constructor	Description
Streamability()

Method Summary

Modifier and Type	Method	Description
static Posture	combinedPosture(java.util.Set<Posture> postures)	Get the combined posture of a set of postures, as defined in the XSLT 3.0 specification
static Sweep	computeAccumulatorAfterSweep(SystemFunctionCall call, ContextItemStaticInfoEE contextInfo, java.util.List<java.lang.String> reasons)	Compute the sweep of a call to accumulator-after (which depends on what else is found in the same sequence constructor
static PostureAndSweep	generalStreamabilityRules(Expression target, java.lang.Iterable<Operand> operands, ContextItemStaticInfoEE contextInfo, java.util.List<java.lang.String> reasons)	Implement the general streamability rules; the rules used to determine the posture and sweep of any expression except when more specific rules are defined for that class of expression
static Operand	getConsumingOperand(Expression exp)	Get the consuming (or potentially consuming) operand of an expression, assuming there is exactly one
static Posture	getPosture(Expression exp)
static PostureAndSweep	getPostureAndSweepIfKnown(Expression exp)	Get the posture and sweep of the expression if these have already been computed
static PostureAndSweep	getStreamability(Expression exp, ContextItemStaticInfoEE contextInfo, java.util.List<java.lang.String> reasons)	Get the posture and sweep of this expression as defined in the W3C streamability specifications.
static Sweep	getSweep(Expression exp)
static boolean	isChildlessNodeKind(ItemType type)	Ask whether an ItemType only allows nodes that cannot have children
static boolean	isIncrementalPosture(Posture posture)	Test whether a supplied posture is either striding or crawling
static Expression	rewriteForExpressionAsMappingExpression(ForExpression forEx)
static Expression	rewriteQuantifiedExpressionAsFilterExpression(QuantifiedExpression quant)
static void	setPostureAndSweep(Expression exp, PostureAndSweep ps)
static Pattern	toStreamingPattern(Expression expr, Configuration config)	Convert an expression to a streaming pattern (a pattern used internally to match nodes during push processing of an event stream)
static Sweep	wider(Sweep a, Sweep b)	Return the wider of two sweeps.

Methods inherited from class java.lang.Object

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

Constructor Detail

Streamability

public Streamability()

Method Detail

getConsumingOperand

public static Operand getConsumingOperand(Expression exp)

Get the consuming (or potentially consuming) operand of an expression, assuming there is exactly one

Parameters:

exp - the expression

Returns:

if there are one or more consuming subexpressions, then the first of these; otherwise, null. Also returns null if the posture and sweep have not yet been assessed.

rewriteQuantifiedExpressionAsFilterExpression

public static Expression rewriteQuantifiedExpressionAsFilterExpression(QuantifiedExpression quant)
                                                                throws XPathException

Throws:

XPathException

rewriteForExpressionAsMappingExpression

public static Expression rewriteForExpressionAsMappingExpression(ForExpression forEx)

generalStreamabilityRules

public static PostureAndSweep generalStreamabilityRules(Expression target,
                                                        java.lang.Iterable<Operand> operands,
                                                        ContextItemStaticInfoEE contextInfo,
                                                        java.util.List<java.lang.String> reasons)

Implement the general streamability rules; the rules used to determine the posture and sweep of any expression except when more specific rules are defined for that class of expression

Parameters:

target - the expression whose streamability is being analyzed (used only for diagnostics)

operands - the operands of the expression being evaluated

contextInfo - information about the static context item type and posture

reasons - (optionally null) an array to which explanations of non-streamability should be appended

Returns:

the posture and sweep of the expression

isChildlessNodeKind

public static boolean isChildlessNodeKind(ItemType type)

Ask whether an ItemType only allows nodes that cannot have children

Parameters:

type - the item type

Returns:

true if the item type only allows nodes that cannot have children

toStreamingPattern

public static Pattern toStreamingPattern(Expression expr,
                                         Configuration config)

Convert an expression to a streaming pattern (a pattern used internally to match nodes during push processing of an event stream)

Parameters:

expr - the expression to be converted

config - the Saxon configuration

Returns:

the equivalent pattern if conversion succeeds; otherwise null

getStreamability

public static PostureAndSweep getStreamability(Expression exp,
                                               ContextItemStaticInfoEE contextInfo,
                                               java.util.List<java.lang.String> reasons)

Get the posture and sweep of this expression as defined in the W3C streamability specifications. This provides an assessment of stylesheet code against the W3C criteria for guaranteed streamability, and is implemented to allow these criteria to be tested. It is not the case that all expression that emerge as streamable from this analysis are currently capable of being streamed by Saxon

Parameters:

contextInfo - Information about the context item type and posture

reasons - the caller may supply a list, in which case the implementation may add to this list a message explaining why the construct is not streamable, suitable for inclusion in an

Returns:

the posture and sweep of the expression

getPosture

public static Posture getPosture(Expression exp)

getSweep

public static Sweep getSweep(Expression exp)

getPostureAndSweepIfKnown

public static PostureAndSweep getPostureAndSweepIfKnown(Expression exp)

Get the posture and sweep of the expression if these have already been computed

Returns:

the posture and sweep if known, or null if the streamability has not yet been assessed.

setPostureAndSweep

public static void setPostureAndSweep(Expression exp,
                                      PostureAndSweep ps)

computeAccumulatorAfterSweep

public static Sweep computeAccumulatorAfterSweep(SystemFunctionCall call,
                                                 ContextItemStaticInfoEE contextInfo,
                                                 java.util.List<java.lang.String> reasons)

Compute the sweep of a call to accumulator-after (which depends on what else is found in the same sequence constructor

Parameters:

call - the call on accumulator-after

Returns:

the computed sweep, which is consuming if all previous instructions are motionless, or motionless if a previous instruction is consuming.

wider

public static Sweep wider(Sweep a,
                          Sweep b)

Return the wider of two sweeps. The order of increasing width is MOTIONLESS, CONSUMING, FREE_RANGING.

Parameters:

a - the first sweep

b - the second sweep

Returns:

the wider of the two

isIncrementalPosture

public static boolean isIncrementalPosture(Posture posture)

Test whether a supplied posture is either striding or crawling

Parameters:

posture - the posture to be tested

Returns:

true if this posture is either striding or crawling

combinedPosture

public static Posture combinedPosture(java.util.Set<Posture> postures)

Get the combined posture of a set of postures, as defined in the XSLT 3.0 specification

Parameters:

postures - the set of postures

Returns:

the combined posture