Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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(NodeInfo 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(NodeInfo node, Mode mode, int min, int max, XPathContext c)` Get a template rule whose import precedence is in a particular range.
`Rule` | `getTemplateRule(NodeInfo node, Mode mode, XPathContext c)` Find the template rule registered for a particular node in a specific mode.
`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

### 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(NodeInfo node,
                                Mode mode,
                                XPathContext c)
                         throws XPathException

  Find the template rule registered for a particular node in a specific mode.

  Parameters:
    `node` - The NodeInfo for the relevant node
    `mode` - The processing mode
    `c` - The controller for this transformation
  Returns:
    The template rule that will process this node Returns null if there is no specific handler registered.
  Throws:
    `XPathException`

### getTemplateRule

    public Rule getTemplateRule(NodeInfo node,
                                Mode mode,
                                int min,
                                int max,
                                XPathContext c)
                         throws XPathException

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

  Parameters:
    `node` - The node 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`

### getNextMatchHandler

    public Rule getNextMatchHandler(NodeInfo 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`

### 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`

### invertStreamableTemplates

    public void invertStreamableTemplates(Optimizer opt)
                                   throws XPathException

  Invert streamable templates in all streamable modes

  Throws:
    `XPathException`

### explainTemplateRules

    public void explainTemplateRules(ExpressionPresenter presenter)

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

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (c) 2004-2010 Saxonica Limited. All rights reserved.