net.sf.saxon.trans
Class RuleManager

java.lang.Object
  net.sf.saxon.trans.RuleManager

All Implemented Interfaces:

Serializable

public final class RuleManager
extends Object
implements Serializable

RuleManager maintains a set of template rules, one set for each mode

Version:

10 December 1999: carved out of the old Controller class

Author:

Michael H. Kay

See Also:

Serialized Form

Constructor Summary

RuleManager()
create a RuleManager and initialise variables.

Method Summary

void	computeRankings() Allocate rankings to the rules within each mode.
void	explainTemplateRules(ExpressionPresenter presenter) Explain (that is, output the expression tree) all template rules
Mode	getMode(StructuredQName modeName, boolean createIfAbsent) Get the Mode object for a named mode.
Rule	getNextMatchHandler(Item node, Mode mode, Rule currentRule, XPathContext c) Get the next-match handler after the current one
int	getRecoveryPolicy() Get the policy for handling recoverable errors.
Rule	getTemplateRule(Item item, Mode mode, int min, int max, XPathContext c) Get the template rule matching a given item whose import precedence is in a particular range.
Mode	getUnnamedMode() Get the mode object for the unnamed mode
void	invertStreamableTemplates(Optimizer opt) Invert streamable templates in all streamable modes
void	resetHandlers() Set up a new table of handlers.
void	setRecoveryPolicy(int policy) Set the policy for handling recoverable errrors.
void	setTemplateRule(Pattern pattern, Template eh, Mode mode, StylesheetModule module, double priority) Register a template for a particular pattern.

Methods inherited from class java.lang.Object

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

Constructor Detail

RuleManager

public RuleManager()

create a RuleManager and initialise variables.

Method Detail

setRecoveryPolicy

public void setRecoveryPolicy(int policy)

Set the policy for handling recoverable errrors. Note that for some errors the decision can be made at run-time, but for the "ambiguous template match" error, the decision is (since 9.2) fixed at compile time.

Parameters:

policy - the recovery policy to be used. The options are Configuration.RECOVER_SILENTLY, Configuration.RECOVER_WITH_WARNINGS, or Configuration.DO_NOT_RECOVER.

Since:

9.2

getRecoveryPolicy

public int getRecoveryPolicy()

Get the policy for handling recoverable errors. Note that for some errors the decision can be made at run-time, but for the "ambiguous template match" error, the decision is (since 9.2) fixed at compile time.

Returns:

the current policy.

Since:

9.2

resetHandlers

public void resetHandlers()

Set up a new table of handlers.

getUnnamedMode

public Mode getUnnamedMode()

Get the mode object for the unnamed mode

Returns:

the unnamed mode

getMode

public Mode getMode(StructuredQName modeName,
                    boolean createIfAbsent)

Get the Mode object for a named mode. If there is not one already registered. a new Mode is created.

Parameters:

modeName - The name of the mode. Supply null to get the default mode or Mode.ALL_MODES to get the Mode object containing "mode=all" rules

createIfAbsent - if true, then if the mode does not already exist it will be created. If false, then if the mode does not already exist the method returns null.

Returns:

the Mode with this name

setTemplateRule

public void setTemplateRule(Pattern pattern,
                            Template eh,
                            Mode mode,
                            StylesheetModule module,
                            double priority)

Register a template for a particular pattern.

Parameters:

pattern - Must be a valid Pattern.

eh - The Template to be used

mode - The processing mode to which this template applies

module - The stylesheet module containing the template rule

priority - The priority of the rule: if an element matches several patterns, the one with highest priority is used

See Also:

Pattern

getTemplateRule

public Rule getTemplateRule(Item item,
                            Mode mode,
                            int min,
                            int max,
                            XPathContext c)
                     throws XPathException

Get the template rule matching a given item whose import precedence is in a particular range. This is used to support the xsl:apply-imports function

Parameters:

item - The item to be matched

mode - The mode for which a rule is required

min - The minimum import precedence that the rule must have

max - The maximum import precedence that the rule must have

c - The Controller for the transformation

Returns:

The template rule to be invoked

Throws:

XPathException - if an error occurs matching a pattern

getNextMatchHandler

public Rule getNextMatchHandler(Item node,
                                Mode mode,
                                Rule currentRule,
                                XPathContext c)
                         throws XPathException

Get the next-match handler after the current one

Parameters:

node - The node to be matched

mode - The processing mode

currentRule - The current template rule

c - The dynamic context for the transformation

Returns:

The template rule to be executed

Throws:

XPathException - if an error occurs while matching a pattern

computeRankings

public void computeRankings()
                     throws XPathException

Allocate rankings to the rules within each mode. This method must be called when all the rules in each mode are known

Throws:

XPathException - if an error occurs

invertStreamableTemplates

public void invertStreamableTemplates(Optimizer opt)
                               throws XPathException

Invert streamable templates in all streamable modes

Parameters:

opt - the optimizer (Always a Saxon-EE optimizer)

Throws:

XPathException - if the templates are not streamable

explainTemplateRules

public void explainTemplateRules(ExpressionPresenter presenter)

Explain (that is, output the expression tree) all template rules

Parameters:

presenter - the object used to present the output