Class Executable

  • All Implemented Interfaces:
    java.io.Serializable

    public class Executable
    extends java.lang.Object
    implements java.io.Serializable
    A compiled stylesheet or a query in executable form. Note that the original stylesheet tree is not retained.
    See Also:
    Serialized Form
    • Constructor Detail

      • Executable

        public Executable​(Configuration config)
        Create a new Executable (a collection of stylesheet modules and/or query modules)
        Parameters:
        config - the Saxon Configuration
    • Method Detail

      • setConfiguration

        public void setConfiguration​(Configuration config)
        Set the configuration
        Parameters:
        config - the Configuration
      • getConfiguration

        public Configuration getConfiguration()
        Get the configuration
        Returns:
        the Configuration
      • setHostLanguage

        public void setHostLanguage​(int language)
        Set the host language
        Parameters:
        language - the host language, as a constant such as Configuration.XSLT or Configuration.XQUERY
      • setRuleManager

        public void setRuleManager​(RuleManager rm)
        Set the RuleManager that handles template rules
        Parameters:
        rm - the RuleManager containing details of all the template rules
      • getRuleManager

        public RuleManager getRuleManager()
        Get the RuleManager which handles template rules
        Returns:
        the RuleManager registered with setRuleManager
      • getNamedTemplate

        public Template getNamedTemplate​(StructuredQName qName)
        Get the named template with a given name.
        Parameters:
        qName - The template name
        Returns:
        The template (of highest import precedence) with this name if there is one; null if none is found.
      • putNamedTemplate

        public void putNamedTemplate​(StructuredQName templateName,
                                     Template template)
        Register the named template with a given name
        Parameters:
        templateName - the name of a named XSLT template
        template - the template
      • iterateNamedTemplates

        public java.util.Iterator iterateNamedTemplates()
        Iterate over all the named templates defined in this Executable
        Returns:
        an iterator, the items returned being of class Template
      • getFunctionLibrary

        public FunctionLibrary getFunctionLibrary()
        Get the library containing all the in-scope functions in the static context
        Returns:
        the function libary
      • setFunctionLibrary

        public void setFunctionLibrary​(FunctionLibrary functionLibrary)
        Set the library containing all the in-scope functions in the static context
        Parameters:
        functionLibrary - the function libary
      • setCharacterMapIndex

        public void setCharacterMapIndex​(java.util.HashMap cmi)
        Set the index of named character maps
        Parameters:
        cmi - a hash table that maps the names of character maps to the HashMap objects representing the character maps
      • getCharacterMapIndex

        public java.util.HashMap getCharacterMapIndex()
        Get the index of named character maps
        Returns:
        the hash table that maps the names of character maps to the HashMap objects representing the character maps
      • setStripperRules

        public void setStripperRules​(Mode rules)
        Set the rules determining which nodes are to be stripped from the tree
        Parameters:
        rules - a Mode object containing the whitespace stripping rules. A Mode is generally a collection of template rules, but it is reused here to represent a collection of stripping rules.
      • getStripperRules

        public Mode getStripperRules()
        Get the rules determining which nodes are to be stripped from the tree
        Returns:
        a Mode object containing the whitespace stripping rules. A Mode is generally a collection of template rules, but it is reused here to represent a collection of stripping rules.
      • setStripsWhitespace

        public void setStripsWhitespace​(boolean strips)
        Indicate that the stylesheet does some whitespace stripping
        Parameters:
        strips - true if the stylesheet performs whitespace stripping of one or more elements.
      • newStripper

        public Stripper newStripper()
        Create a Stripper which handles whitespace stripping definitions
        Returns:
        the constructed Stripper object
      • stripsWhitespace

        public boolean stripsWhitespace()
        Determine whether this stylesheet does any whitespace stripping
        Returns:
        true if the stylesheet performs whitespace stripping of one or more elements.
      • setStripsInputTypeAnnotations

        public void setStripsInputTypeAnnotations​(boolean strips)
        Set whether source documents are to have their type annotations stripped
        Parameters:
        strips - true if type annotations are to be stripped
      • stripsInputTypeAnnotations

        public boolean stripsInputTypeAnnotations()
        Ask whether source documents are to have their type annotations stripped
        Returns:
        true if type annotations are stripped from source documents
      • setKeyManager

        public void setKeyManager​(KeyManager km)
        Set the KeyManager which handles key definitions
        Parameters:
        km - the KeyManager containing the xsl:key definitions
      • getKeyManager

        public KeyManager getKeyManager()
        Get the KeyManager which handles key definitions
        Returns:
        the KeyManager containing the xsl:key definitions
      • setDefaultOutputProperties

        public void setDefaultOutputProperties​(java.util.Properties properties)
        Set the default output properties (the properties for the unnamed output format)
        Parameters:
        properties - the output properties to be used when the unnamed output format is selected
      • getDefaultOutputProperties

        public java.util.Properties getDefaultOutputProperties()
        Get the default output properties
        Returns:
        the properties for the unnamed output format
      • setOutputProperties

        public void setOutputProperties​(StructuredQName qName,
                                        java.util.Properties properties)
        Add a named output format
        Parameters:
        qName - the structured QName of the output format
        properties - the properties of the output format
      • getOutputProperties

        public java.util.Properties getOutputProperties​(StructuredQName qName)
        Get a named output format
        Parameters:
        qName - the name of the output format
        Returns:
        properties the properties of the output format. Return null if there are no output properties with the given name
      • setDecimalFormatManager

        public void setDecimalFormatManager​(DecimalFormatManager dfm)
        Set the DecimalFormatManager which handles decimal-format definitions
        Parameters:
        dfm - the DecimalFormatManager containing the named xsl:decimal-format definitions
      • getDecimalFormatManager

        public DecimalFormatManager getDecimalFormatManager()
        Get the DecimalFormatManager which handles decimal-format definitions
        Returns:
        the DecimalFormatManager containing the named xsl:decimal-format definitions
      • setDefaultCollationName

        public void setDefaultCollationName​(java.lang.String name)
        Set the default collation
        Parameters:
        name - the name of the default collation
      • getDefaultCollationName

        public java.lang.String getDefaultCollationName()
        Get the name of the default collation
        Returns:
        the name of the default collation; this is the code point collation URI if no other default has been set up.
      • getDefaultCollation

        public StringCollator getDefaultCollation()
        Get the default collation
        Returns:
        a StringCollator that implements the default collation
      • setCollationTable

        public void setCollationTable​(CollationMap table)
        Set the table of collations
        Parameters:
        table - a hash table that maps collation names (URIs) to objects representing the collation information
      • getCollationTable

        public CollationMap getCollationTable()
        Get the table of collations
        Returns:
        a hash table that maps collation names (URIs) to objects representing the collation information
      • getNamedCollation

        public StringCollator getNamedCollation​(java.lang.String name)
        Find a named collation.
        Parameters:
        name - identifies the name of the collation required; null indicates that the default collation is required
        Returns:
        the requested collation, or null if the collation is not found
      • addQueryLibraryModule

        public void addQueryLibraryModule​(QueryModule module)
        Add an XQuery library module to the configuration. The Executable maintains a table indicating for each module namespace, the set of modules that have been loaded from that namespace. If a module import is encountered that specifies no location hint, all the known modules for that namespace are imported.
        Parameters:
        module - the library module to be added to this executable
      • getQueryLibraryModules

        public java.util.List getQueryLibraryModules​(java.lang.String namespace)
        Locate the known XQuery library modules for a given module namespace.
        Parameters:
        namespace - the module namespace URI
        Returns:
        a list of items each of which is the StaticQueryContext representing a module, or null if the module namespace is unknown
      • getQueryModuleWithSystemId

        public QueryModule getQueryModuleWithSystemId​(java.lang.String systemId,
                                                      QueryModule topModule)
        Get the query library module with a given systemID
        Parameters:
        systemId - the SystemId of the required module
        topModule - the top-level query module (usually a main module, except when importing library modules into XSLT)
        Returns:
        the module with that system id if found, otherwise null
      • getQueryLibraryModules

        public java.util.Iterator getQueryLibraryModules()
        Get an iterator over all the query library modules (does not include the main module)
        Returns:
        an iterator whose returned items are instances of QueryModule
      • fixupQueryModules

        public void fixupQueryModules​(QueryModule main)
                               throws XPathException
        Fix up global variables and functions in all query modules. This is done right at the end, because recursive imports are permitted
        Parameters:
        main - the main query module
        Throws:
        XPathException
      • setPatternSlotSpace

        public void setPatternSlotSpace​(int patternLocals)
        Set the space requirements for variables used in template match patterns
        Parameters:
        patternLocals - The largest number of local variables used in the match pattern of any template rule
      • getGlobalVariableMap

        public SlotManager getGlobalVariableMap()
        Get the global variable map
        Returns:
        the SlotManager defining the allocation of slots to global variables
      • getCompiledGlobalVariables

        public java.util.HashMap getCompiledGlobalVariables()
        Get the index of global variables
        Returns:
        the index of global variables. This is a HashMap in which the key is the StructuredQName of the variable name, and the value is the GlobalVariable object representing the compiled global variable. If there are no global variables, the method may return null.
      • explainGlobalVariables

        public void explainGlobalVariables​(ExpressionPresenter presenter)
        Explain (that is, output an expression tree) the global variables
        Parameters:
        presenter - the destination for the explanation of the global variables
      • registerGlobalVariable

        public void registerGlobalVariable​(GlobalVariable variable)
        Register a global variable
        Parameters:
        variable - the global variable to be registered
      • initializeBindery

        public void initializeBindery​(Bindery bindery)
        Allocate space in bindery for all the variables needed
        Parameters:
        bindery - The bindery to be initialized
      • getLargestPatternStackFrame

        public int getLargestPatternStackFrame()
        Determine the size of the stack frame needed for evaluating match patterns
        Returns:
        the size of the largest stack frame needed for evaluating the match patterns that appear in XSLT template rules
      • setLocationMap

        public void setLocationMap​(LocationMap map)
        Set the location map
        Parameters:
        map - the location map, which is used to identify the module URI and line number of locations of errors
      • getLocationMap

        public LocationMap getLocationMap()
        Get the location map
        Returns:
        the location map, which is used to identify the locations of errors
      • addRequiredParam

        public void addRequiredParam​(StructuredQName qName)
        Add a required parameter
        Parameters:
        qName - the name of the required parameter
      • checkAllRequiredParamsArePresent

        public void checkAllRequiredParamsArePresent​(GlobalParameterSet params)
                                              throws XPathException
        Check that all required parameters have been supplied
        Parameters:
        params - the set of parameters that have been supplied
        Throws:
        XPathException - if there is a required parameter for which no value has been supplied
      • setReasonUnableToCompile

        public void setReasonUnableToCompile​(java.lang.String reason)
        If this Executable can't be compiled, set a message explaining why
        Parameters:
        reason - a message explaining why compilation is not possible
      • getReasonUnableToCompile

        public java.lang.String getReasonUnableToCompile()
        Determine whether this executable can be compiled; and if it can't, return the reason why
        Returns:
        null if the executable can be compiled, or a message otherwise
      • explainNamedTemplates

        public void explainNamedTemplates​(ExpressionPresenter presenter)
        Explain the expression tree for named templates in a stylesheet
        Parameters:
        presenter - destination for the explanatory output
      • setCreatesSecondaryResult

        public void setCreatesSecondaryResult​(boolean flag)
        Set whether this executable represents a stylesheet that uses xsl:result-document to create secondary output documents
        Parameters:
        flag - true if the executable uses xsl:result-document
      • createsSecondaryResult

        public boolean createsSecondaryResult()
        Ask whether this executable represents a stylesheet that uses xsl:result-document to create secondary output documents
        Returns:
        true if the executable uses xsl:result-document