Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## net.sf.saxon.expr.instruct
Class Template

    java.lang.Object
      net.sf.saxon.expr.instruct.Procedure
          net.sf.saxon.expr.instruct.Template

All Implemented Interfaces:
  Serializable, SourceLocator, LocationProvider, SaxonLocator, Container, InstructionInfo, RuleTarget, Locator

    public class Template

extends Procedure
implements RuleTarget

The runtime object corresponding to an xsl:template element in the stylesheet. Note that the Template object no longer has precedence information associated with it; this is now only in the Rule object that references this Template. This allows two rules to share the same template, with different precedences. This occurs when a stylesheet module is imported more than once, from different places, with different import precedences.

See Also:
  Serialized Form

Field Summary

Fields inherited from class net.sf.saxon.expr.instruct.Procedure
`body`

Constructor Summary
`Template()` Create a template

Method Summary
`void` | `apply(XPathContextMajor context)` Process the template, without returning any tail calls.
`TailCall` | `applyLeavingTail(XPathContextMajor context)` Process this template, with the possibility of returning a tail call package if the template contains any tail calls that are to be performed by the caller.
`TailCall` | `expand(XPathContext context)` Expand the template.
`void` | `explain(ExpressionPresenter presenter)` Output diagnostic explanation to an ExpressionPresenter
`int` | `getConstructType()` Get the type of construct.
`LocalParam` | `getLocalParam(int id)` Get the local parameter with a given parameter id
`Pattern` | `getMatchPattern()` Get the match pattern used with this template
`StructuredQName` | `getObjectName()` Get a name identifying the object of the expression, for example a function name, template name, variable name, key name, element name, etc.
`SequenceType` | `getRequiredType()` Get the required type to be returned by this template
`StructuredQName` | `getTemplateName()` Get the name of the template (if it is named)
`boolean` | `hasRequiredParams()` Ask whether this template has one or more required parameters
`boolean` | `isStreamable()` Ask whether or not this template is declared as streamable
`void` | `setBody(Expression body)` Set the expression that forms the body of the template
`void` | `setHasRequiredParams(boolean has)` Set whether this template has one or more required parameters
`void` | `setMatchPattern(Pattern pattern)` Set the match pattern used with this template
`void` | `setRequiredType(SequenceType type)` Set the required type to be returned by this template
`void` | `setStreamable(boolean streamable)` Say whether or not this template is declared as streamable
`void` | `setTemplateName(StructuredQName templateName)` Initialize the template

Methods inherited from class net.sf.saxon.expr.instruct.Procedure
`getBody, getColumnNumber, getColumnNumber, getContainerGranularity, getExecutable, getHostLanguage, getLineNumber, getLineNumber, getLocationProvider, getProperties, getProperty, getPublicId, getStackFrameMap, getSystemId, getSystemId, setExecutable, setHostLanguage, setLineNumber, setStackFrameMap, setSystemId`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### Template

    public Template()

  Create a template

Method Detail

### setTemplateName

    public void setTemplateName(StructuredQName templateName)

  Initialize the template

  Parameters:
    `templateName` - the name of the template (if any) performed by apply-imports

### setMatchPattern

    public void setMatchPattern(Pattern pattern)

  Set the match pattern used with this template

  Parameters:
    `pattern` - the match pattern (may be null for a named template)

### getMatchPattern

    public Pattern getMatchPattern()

  Get the match pattern used with this template

  Returns:
    the match pattern, or null if this is a named template with no match pattern

### setBody

    public void setBody(Expression body)

  Set the expression that forms the body of the template

  Overrides:
    `setBody` in class `Procedure`
  Parameters:
    `body` - the body of the template

### getTemplateName

    public StructuredQName getTemplateName()

  Get the name of the template (if it is named)

  Returns:
    the template name, or null if unnamed

### getObjectName

    public StructuredQName getObjectName()

  Get a name identifying the object of the expression, for example a function name, template name, variable name, key name, element name, etc. This is used only where the name is known statically.

  Specified by:
    `getObjectName` in interface `InstructionInfo`
  Returns:
    the QName of the object declared or manipulated by this instruction or expression

### setHasRequiredParams

    public void setHasRequiredParams(boolean has)

  Set whether this template has one or more required parameters

  Parameters:
    `has` - true if the template has at least one required parameter

### hasRequiredParams

    public boolean hasRequiredParams()

  Ask whether this template has one or more required parameters

  Returns:
    true if this template has at least one required parameter

### setRequiredType

    public void setRequiredType(SequenceType type)

  Set the required type to be returned by this template

  Parameters:
    `type` - the required type as defined in the "as" attribute on the xsl:template element

### getRequiredType

    public SequenceType getRequiredType()

  Get the required type to be returned by this template

  Returns:
    the required type as defined in the "as" attribute on the xsl:template element

### setStreamable

    public void setStreamable(boolean streamable)

  Say whether or not this template is declared as streamable

  Parameters:
    `streamable` - true if the template belongs to a streamable mode

### isStreamable

    public boolean isStreamable()

  Ask whether or not this template is declared as streamable

  Returns:
    true if the template belongs to a streamable mode

### getLocalParam

    public LocalParam getLocalParam(int id)

  Get the local parameter with a given parameter id

  Parameters:
    `id` - the parameter id
  Returns:
    the local parameter with this id if found, otherwise null

### apply

    public void apply(XPathContextMajor context)
               throws XPathException

  Process the template, without returning any tail calls. This path is used by xsl:apply-imports and xsl:next-match

  Parameters:
    `context` - The dynamic context, giving access to the current node,
  Throws:
    `XPathException` - if a dynamic error occurs while evaluating the template

### applyLeavingTail

    public TailCall applyLeavingTail(XPathContextMajor context)
                              throws XPathException

  Process this template, with the possibility of returning a tail call package if the template contains any tail calls that are to be performed by the caller.

  Parameters:
    `context` - the XPath dynamic context
  Returns:
    null if the template exited normally; but if it was a tail call, details of the call that hasn't been made yet and needs to be made by the caller
  Throws:
    `XPathException` - if a dynamic error occurs while evaluating the template

### expand

    public TailCall expand(XPathContext context)
                    throws XPathException

  Expand the template. Called when the template is invoked using xsl:call-template. Invoking a template by this method does not change the current template.

  Parameters:
    `context` - the XPath dynamic context
  Returns:
    null if the template exited normally; but if it was a tail call, details of the call that hasn't been made yet and needs to be made by the caller
  Throws:
    `XPathException` - if a dynamic error occurs while evaluating the template

### getConstructType

    public int getConstructType()

  Get the type of construct. This will either be the fingerprint of a standard XSLT instruction name (values in `StandardNames`: all less than 1024) or it will be a constant in class `Location`.

  Specified by:
    `getConstructType` in interface `InstructionInfo`
  Returns:
    an integer identifying the kind of construct

### explain

    public void explain(ExpressionPresenter presenter)

  Output diagnostic explanation to an ExpressionPresenter

  Specified by:
    `explain` in interface `RuleTarget`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

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