## net.sf.saxon.trans
Class RuleManager

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

All Implemented Interfaces:
  java.io.Serializable

    public final class RuleManager

extends java.lang.Object
implements java.io.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` `explainTemplateRules(ExpressionPresenter presenter)` Explain (that is, output the expression tree) all template rules
`Mode` `getDefaultMode()` Get the mode object for the default (unnamed) mode
`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
`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.
`void` `resetHandlers()` Set up a new table of handlers.
`void` `setHandler(Pattern pattern, Template eh, Mode mode, int precedence)` Register a handler for a particular pattern.
`void` `setHandler(Pattern pattern, Template eh, Mode mode, int precedence, 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

### resetHandlers

    public void resetHandlers()

  Set up a new table of handlers.

### getDefaultMode

    public Mode getDefaultMode()

  Get the mode object for the default (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

### setHandler

    public void setHandler(Pattern pattern,
                           Template eh,
                           Mode mode,
                           int precedence)

  Register a handler for a particular pattern. The priority of the rule is the default priority for the pattern, which depends on the syntax of the pattern suppllied.

  Parameters:
    `pattern` - A match pattern
    `eh` - The ElementHandler to be used
    `mode` - The processing mode
    `precedence` - The import precedence (use 0 by default)

### setHandler

    public void setHandler(Pattern pattern,
                           Template eh,
                           Mode mode,
                           int precedence,
                           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
    `precedence` - The import precedence of this 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`

### explainTemplateRules

    public void explainTemplateRules(ExpressionPresenter presenter)

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

Copyright (c) Saxonica Limited. All rights reserved.