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