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

    java.lang.Object
      net.sf.saxon.expr.Expression
          net.sf.saxon.expr.UnaryExpression
              net.sf.saxon.expr.TailCallLoop

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

    public final class TailCallLoop

extends UnaryExpression

A TailCallLoop wraps the body of a function that contains tail-recursive function calls. On completion of the "real" body of the function it tests whether the function has executed a tail call, and if so, iterates to evaluate the tail call.

See Also:
  Serialized Form

Field Summary

Fields inherited from class net.sf.saxon.expr.UnaryExpression
`operand`

Fields inherited from class net.sf.saxon.expr.Expression
`EFFECTIVE_BOOLEAN_VALUE, EVALUATE_METHOD, EVENT_FEED_METHOD, ITEM_FEED_METHOD, ITERATE_METHOD, locationId, MAX_SEQUENCE_LENGTH, MAX_STRING_LENGTH, PROCESS_METHOD, PUSH_SELECTION, staticProperties, UNBOUNDED_LOWER, UNBOUNDED_UPPER, WATCH_METHOD`

Constructor Summary
`TailCallLoop(UserFunction function)` Constructor - create a TailCallLoop

Method Summary
`Expression` | `copy()` Copy an expression.
`Item` | `evaluateItem(XPathContext context)` Evaluate as an Item.
`UserFunction` | `getContainingFunction()` Get the containing function
`String` | `getExpressionName()` Give a string representation of the expression name for use in diagnostics
`int` | `getImplementationMethod()` An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process().
`ItemType` | `getItemType(TypeHierarchy th)` Determine the data type of the items returned by the expression
`SequenceIterator` | `iterate(XPathContext context)` Iterate over the sequence of values
`void` | `process(XPathContext context)` Process the function body
`Expression` | `typeCheck(ExpressionVisitor visitor, ExpressionVisitor.ContextItemType contextItemType)` Type-check the expression

Methods inherited from class net.sf.saxon.expr.UnaryExpression
`computeCardinality, computeSpecialProperties, displayOperator, equals, explain, getBaseExpression, hashCode, iterateSubExpressions, optimize, promote, replaceSubExpression, simplify, toString`

Methods inherited from class net.sf.saxon.expr.Expression
`addToPathMap, adoptChildExpression, checkForUpdatingSubexpressions, checkPermittedContents, computeDependencies, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluateAsString, evaluatePendingUpdates, explain, getCardinality, getColumnNumber, getColumnNumber, getConstructType, getContainer, getDependencies, getEvaluationMethod, getExecutable, getHostLanguage, getIntegerBounds, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getSystemId, getSystemId, hasLoopingSubexpression, hasVariableBinding, implementsStaticTypeCheck, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterateEvents, iterateSameFocusSubExpressions, markTailFunctionCalls, resetLocalStaticProperties, setContainer, setEvaluationMethod, setFiltered, setFlattened, setLocationId, staticTypeCheck, suppressValidation, typeError`

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

Constructor Detail

### TailCallLoop

    public TailCallLoop(UserFunction function)

  Constructor - create a TailCallLoop

  Parameters:
    `function` - the function in which this tail call loop appears

Method Detail

### getContainingFunction

    public UserFunction getContainingFunction()

  Get the containing function

  Returns:
    the containing function

### typeCheck

    public Expression typeCheck(ExpressionVisitor visitor,
                                ExpressionVisitor.ContextItemType contextItemType)
                         throws XPathException

  Type-check the expression

  Overrides:
    `typeCheck` in class `UnaryExpression`
  Parameters:
    `visitor` - an expression visitor
    `contextItemType` - the static type of "." at the point where this expression is invoked. The parameter is set to null if it is known statically that the context item will be undefined. If the type of the context item is not known statically, the argument is set to `Type.ITEM_TYPE`
  Returns:
    the original expression, rewritten to perform necessary run-time type checks, and to perform other type-related optimizations
  Throws:
    `XPathException` - if an error is discovered during this phase (typically a type error)

### getImplementationMethod

    public int getImplementationMethod()

  An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process(). This method indicates which of these methods is provided. This implementation provides both iterate() and process() methods natively.

  Overrides:
    `getImplementationMethod` in class `Expression`
  Returns:
    the implementation method, for example `Expression.ITERATE_METHOD` or `Expression.EVALUATE_METHOD` or `Expression.PROCESS_METHOD`

### copy

    public Expression copy()

  Copy an expression. This makes a deep copy.

  Specified by:
    `copy` in class `Expression`
  Returns:
    the copy of the original expression

### iterate

    public SequenceIterator iterate(XPathContext context)
                             throws XPathException

  Iterate over the sequence of values

  Overrides:
    `iterate` in class `Expression`
  Parameters:
    `context` - supplies the context for evaluation
  Returns:
    a SequenceIterator that can be used to iterate over the result of the expression
  Throws:
    `XPathException` - if any dynamic error occurs evaluating the expression

### evaluateItem

    public Item evaluateItem(XPathContext context)
                      throws XPathException

  Evaluate as an Item.

  Overrides:
    `evaluateItem` in class `Expression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the node or atomic value that results from evaluating the expression; or null to indicate that the result is an empty sequence
  Throws:
    `XPathException` - if any dynamic error occurs evaluating the expression

### process

    public void process(XPathContext context)
                 throws XPathException

  Process the function body

  Overrides:
    `process` in class `Expression`
  Parameters:
    `context` - The dynamic context, giving access to the current node, the current variables, etc.
  Throws:
    `XPathException` - if a dynamic error occurs

### getItemType

    public ItemType getItemType(TypeHierarchy th)

  Determine the data type of the items returned by the expression

  Overrides:
    `getItemType` in class `UnaryExpression`
  Parameters:
    `th` - The type hierarchy cache
  Returns:
    the item type of the items in the result sequence, insofar as this is known statically.

### getExpressionName

    public String getExpressionName()

  Give a string representation of the expression name for use in diagnostics

  Overrides:
    `getExpressionName` in class `Expression`
  Returns:
    the expression name, as a string

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.