com.saxonica.ee.pattern.preconditions

Class RealPreconditions

java.lang.Object

com.saxonica.ee.pattern.preconditions.RealPreconditions

All Implemented Interfaces:

PreconditionSet

public class RealPreconditions
extends Object
implements PreconditionSet

A collection of precondition expressions that can be used to increase efficiency of rule matching for long rule chains.

The preconditions are a set of expressions whose boolean evaluation on a context item are stored for subsequent retrieval in a lazy fashion within a Matcher object.

The method makeRuleSearchState(SimpleMode) is used to generate a stateful matcher for the preconditions. The rest of this class should be thread-safe.

Field Summary

Fields

Modifier and Type	Field and Description
static long	diagTime

Constructor Summary

Constructors

Constructor and Description
RealPreconditions(PatternOptimizationEE patternOptimization)

Method Summary

Methods

Modifier and Type	Method and Description
void	addAll(Collection<Expression> expressions) Add a collection of expressions to this set of preconditions, removing duplicates and counting the number of occurrences
static Expression	applyAxis(byte axis, Expression e)
static Set<Expression>	applyAxis(byte axis, Set<Expression> exps)
int	count(Expression e)
static Set<Expression>	difference(Set<Expression> eList1, Set<Expression> eList2) Strictly all elements in the union that are not in the intersection
static Expression	evaluatedFunction(Expression e, Expression isTrue, PatternOptimizationEE patternOptimization)
static Set<Expression>	except(Set<Expression> eList1, Set<Expression> eList2) Except between sets - Elist1 less any items that appear in Elist2
void	export(ExpressionPresenter out)
Map<Expression,Integer>	getIndexes()
int	getRawConditionSize()
List<Expression>	getSortedConditions()
static Set<Expression>	intersect(Set<Expression> eList1, Collection<Expression> eList2)
static boolean	isContainsLiteral(Expression e) Ask whether an expression has the form contains(x, L) where L is a string literal
static boolean	isTrue(Expression e) Ask whether a given expression is the literal boolean value "true()"
Matcher	makeRuleSearchState(SimpleMode mode) Generate a stateful Matcher for use against this set of preconditions.
static Expression	makeTokenizingComparison(FunctionCall f)
void	process() Carry out 'global' processing on this precondition set.
void	setPatternOptimization(PatternOptimizationEE p)
static Set<Expression>	union(Set<Expression> eList1, Set<Expression> eList2)

Methods inherited from class java.lang.Object

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

Field Detail

diagTime

public static long diagTime

Constructor Detail

RealPreconditions

public RealPreconditions(PatternOptimizationEE patternOptimization)

Method Detail

setPatternOptimization

public void setPatternOptimization(PatternOptimizationEE p)

getRawConditionSize

public int getRawConditionSize()

addAll

public void addAll(Collection<Expression> expressions)

Add a collection of expressions to this set of preconditions, removing duplicates and counting the number of occurrences

Specified by:

addAll in interface PreconditionSet

Parameters:

expressions - The expressions to be added

makeRuleSearchState

public Matcher makeRuleSearchState(SimpleMode mode)

Generate a stateful Matcher for use against this set of preconditions.

Specified by:

makeRuleSearchState in interface PreconditionSet

Parameters:

mode - the mode this precondition set is being used in

Returns:

process

public void process()

Description copied from interface: PreconditionSet

Carry out 'global' processing on this precondition set.

Specified by:

process in interface PreconditionSet

count

public int count(Expression e)

getSortedConditions

public List<Expression> getSortedConditions()

Specified by:

getSortedConditions in interface PreconditionSet

getIndexes

public Map<Expression,Integer> getIndexes()

Specified by:

getIndexes in interface PreconditionSet

export

public void export(ExpressionPresenter out)

Specified by:

export in interface PreconditionSet

intersect

public static Set<Expression> intersect(Set<Expression> eList1,
                        Collection<Expression> eList2)

union

public static Set<Expression> union(Set<Expression> eList1,
                    Set<Expression> eList2)

except

public static Set<Expression> except(Set<Expression> eList1,
                     Set<Expression> eList2)

Except between sets - Elist1 less any items that appear in Elist2

Parameters:

eList1 -

eList2 -

Returns:

difference

public static Set<Expression> difference(Set<Expression> eList1,
                         Set<Expression> eList2)

Strictly all elements in the union that are not in the intersection

Parameters:

eList1 -

eList2 -

Returns:

applyAxis

public static Set<Expression> applyAxis(byte axis,
                        Set<Expression> exps)

applyAxis

public static Expression applyAxis(byte axis,
                   Expression e)

isContainsLiteral

public static boolean isContainsLiteral(Expression e)

Ask whether an expression has the form contains(x, L) where L is a string literal

Parameters:

e - the expression to be tested

Returns:

true if the expression has this form

makeTokenizingComparison

public static Expression makeTokenizingComparison(FunctionCall f)

evaluatedFunction

public static Expression evaluatedFunction(Expression e,
                           Expression isTrue,
                           PatternOptimizationEE patternOptimization)

isTrue

public static boolean isTrue(Expression e)

Ask whether a given expression is the literal boolean value "true()"

Parameters:

e - the expression in question

Returns:

true if the expression is the literal boolean value "true()"