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

    Constructors
    Constructor and Description
    `RuleManager()` create a RuleManager and initialise variables.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `computeRankings()` Allocate rankings to the rules within each mode.
    `void` | `explainTemplateRules(ExpressionPresenter presenter)` Explain (that is, output the expression tree) all template rules
    `Collection<Mode>` | `getAllNamedModes()` Get all registered modes
    `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

    - #### getAllNamedModes

          public Collection<Mode> getAllNamedModes()

      Get all registered modes
      Returns:
        a collection containing all registered modes excluding the unnamed mode

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

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