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

      • 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