## net.sf.saxon.expr
Class ExpressionVisitor

    java.lang.Object
      net.sf.saxon.expr.ExpressionVisitor

All Implemented Interfaces:
  TypeCheckerEnvironment

    public class ExpressionVisitor

extends Object
implements TypeCheckerEnvironment

The ExpressionVisitor supports the various phases of processing of an expression tree which require a recursive walk of the tree structure visiting each node in turn. In maintains a stack holding the ancestor nodes of the node currently being visited.

Constructor Summary
`ExpressionVisitor()` Create an ExpressionVisitor

Method Summary
`CollationMap` `getCollationMap()`
`Configuration` `getConfiguration()` Get the Saxon configuration
`Expression` `getCurrentExpression()` Get the current expression, the one being visited
`Executable` `getExecutable()` Get the Executable containing the expressions being visited
`Expression` `getParentExpression()` Get the parent expression of the current expression in the expression tree
`Stack<Expression>` `getStack()` Get the stack containing all the expressions currently being visited
`StaticContext` `getStaticContext()` Get the static context for the expressions being visited.
`boolean` `isLoopingSubexpression(Expression ancestor)` Return true if the current expression at the top of the visitor's stack is evaluated repeatedly when a given ancestor expression is evaluated once
`boolean` `isOptimizeForStreaming()` Ask whether the visitor is to optimize expressions for evaluation in a streaming environment
`void` `issueWarning(String message, SourceLocator locator)` Issue a warning message
`static ExpressionVisitor` `make(StaticContext env, Executable exec)` Factory method: make an expression visitor
`XPathContext` `makeDynamicContext()` Create a dynamic context suitable for early evaluation of constant subexpressions
`Expression` `optimize(Expression exp, ItemType contextItemType)` Optimize an expression, via the ExpressionVisitor
`void` `resetStaticProperties()` Reset the static properties for the current expression and for all its containing expressions.
`void` `setConfiguration(Configuration configuration)` Set the Saxon configuration
`void` `setExecutable(Executable executable)` Set the Executable containing the expressions being visited
`void` `setOptimizeForStreaming(boolean option)` Tell the visitor to optimize expressions for evaluation in a streaming environment
`void` `setStack(Stack<Expression> stack)` Set the stack used to hold the expressions being visited
`void` `setStaticContext(StaticContext staticContext)` Set the static context for the expressions being visited.
`Expression` `simplify(Expression exp)` Simplify an expression, via the ExpressionVisitor
`Expression` `typeCheck(Expression exp, ItemType contextItemType)` Type check an expression, via the ExpressionVisitor

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

Constructor Detail

### ExpressionVisitor

    public ExpressionVisitor()

  Create an ExpressionVisitor

Method Detail

### getConfiguration

    public Configuration getConfiguration()

  Get the Saxon configuration

  Specified by:
    `getConfiguration` in interface `TypeCheckerEnvironment`
  Returns:
    the Saxon configuration

### setConfiguration

    public void setConfiguration(Configuration configuration)

  Set the Saxon configuration

  Parameters:
    `configuration` - the Saxon configuration

### getExecutable

    public Executable getExecutable()

  Get the Executable containing the expressions being visited

  Returns:
    the Executable

### setExecutable

    public void setExecutable(Executable executable)

  Set the Executable containing the expressions being visited

  Parameters:
    `executable` - the Executable

### getCollationMap

    public CollationMap getCollationMap()

  Specified by:
    `getCollationMap` in interface `TypeCheckerEnvironment`

### getStack

    public Stack<Expression> getStack()

  Get the stack containing all the expressions currently being visited

  Returns:
    the expression stack holding all the containing expressions of the current expression; the objects on this Stack are instances of `Expression`

### setStack

    public void setStack(Stack<Expression> stack)

  Set the stack used to hold the expressions being visited

  Parameters:
    `stack` - the expression stack

### getStaticContext

    public StaticContext getStaticContext()

  Get the static context for the expressions being visited. Note: this may not reflect all changes in static context (e.g. namespace context, base URI) applying to nested expressions

  Returns:
    the static context

### setStaticContext

    public void setStaticContext(StaticContext staticContext)

  Set the static context for the expressions being visited. Note: this may not reflect all changes in static context (e.g. namespace context, base URI) applying to nested expressions

  Parameters:
    `staticContext` - the static context

### getCurrentExpression

    public Expression getCurrentExpression()

  Get the current expression, the one being visited

  Returns:
    the current expression

### make

    public static ExpressionVisitor make(StaticContext env,
                                         Executable exec)

  Factory method: make an expression visitor

  Parameters:
    `env` - the static context
  Returns:
    the new expression visitor

### issueWarning

    public void issueWarning(String message,
                             SourceLocator locator)

  Issue a warning message

  Specified by:
    `issueWarning` in interface `TypeCheckerEnvironment`
  Parameters:
    `message` - the message

### makeDynamicContext

    public XPathContext makeDynamicContext()

  Create a dynamic context suitable for early evaluation of constant subexpressions

  Specified by:
    `makeDynamicContext` in interface `TypeCheckerEnvironment`

### simplify

    public Expression simplify(Expression exp)
                        throws XPathException

  Simplify an expression, via the ExpressionVisitor

  Specified by:
    `simplify` in interface `TypeCheckerEnvironment`
  Parameters:
    `exp` - the expression to be simplified
  Returns:
    the simplified expression
  Throws:
    `XPathException`

### typeCheck

    public Expression typeCheck(Expression exp,
                                ItemType contextItemType)
                         throws XPathException

  Type check an expression, via the ExpressionVisitor

  Specified by:
    `typeCheck` in interface `TypeCheckerEnvironment`
  Parameters:
    `exp` - the expression to be typechecked
    `contextItemType` - the static type of the context item for this expression
  Returns:
    the expression that results from type checking (this may be wrapped in expressions that perform dynamic checking of the item type or cardinality, or that perform atomization or numeric promotion)
  Throws:
    `XPathException` - if static type checking fails, that is, if the expression cannot possibly deliver a value of the required type

### setOptimizeForStreaming

    public void setOptimizeForStreaming(boolean option)

  Tell the visitor to optimize expressions for evaluation in a streaming environment

  Parameters:
    `option` - true if optimizing for streaming

### isOptimizeForStreaming

    public boolean isOptimizeForStreaming()

  Ask whether the visitor is to optimize expressions for evaluation in a streaming environment

  Returns:
    true if optimizing for streaming

### optimize

    public Expression optimize(Expression exp,
                               ItemType contextItemType)
                        throws XPathException

  Optimize an expression, via the ExpressionVisitor

  Parameters:
    `exp` - the expression to be typechecked
    `contextItemType` - the static type of the context item for this expression
  Returns:
    the rewritten expression
  Throws:
    `XPathException`

### getParentExpression

    public Expression getParentExpression()

  Get the parent expression of the current expression in the expression tree

  Returns:
    the parent of the current expression (or null if this is the root)

### isLoopingSubexpression

    public boolean isLoopingSubexpression(Expression ancestor)

  Return true if the current expression at the top of the visitor's stack is evaluated repeatedly when a given ancestor expression is evaluated once

  Parameters:
    `ancestor` - the ancestor expression. May be null, in which case the search goes all the way to the base of the stack.
  Returns:
    true if the current expression is evaluated repeatedly

### resetStaticProperties

    public final void resetStaticProperties()

  Reset the static properties for the current expression and for all its containing expressions. This should be done whenever the expression is changed in a way that might affect the properties. It causes the properties to be recomputed next time they are needed.

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