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 Optimizer

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

All Implemented Interfaces:
  java.io.Serializable

public class Optimizer
extends java.lang.Object
implements java.io.Serializable

This class doesn't actually do any optimization itself, despite the name. Rather, it is intended to act as a factory for implementation classes that perform optimization, so that the appropriate level of optimization can be selected.

See Also:
  Serialized Form

Field Summary
`protected Configuration` | `config`

Constructor Summary
`Optimizer(Configuration config)`

Method Summary
`Expression` | `convertPathExpressionToKey(PathExpression pathExp, StaticContext env)` Examine a path expression to see whether it can be replaced by a call on the key() function; if so, generate an appropriate key definition and return the call on key().
`FilterExpression` | `convertToFilterExpression(PathExpression pathExp, TypeHierarchy th)` Convert a path expression such as a/b/c[predicate] into a filter expression of the form (a/b/c)[predicate].
`Configuration` | `getConfiguration()`
`int` | `isIndexableFilter(Expression filter)` Test whether a filter predicate is indexable.
`Closure` | `makeClosure(Expression expression, int ref)` Make a Closure, given the expected reference count
`BinaryExpression` | `makeGeneralComparison(Expression p0, int op, Expression p1, boolean backwardsCompatible)` Create a GeneralComparison expression
`Expression` | `optimizeCopy(Expression select)` Attempt to optimize a copy operation.
`SequenceIterator` | `tryIndexedFilter(ValueRepresentation startValue, Expression filter, int isIndexable, XPathContext context)`

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

Field Detail

### config

    protected Configuration config

Constructor Detail

### Optimizer

    public Optimizer(Configuration config)

Method Detail

### getConfiguration

    public Configuration getConfiguration()

### makeGeneralComparison

    public BinaryExpression makeGeneralComparison(Expression p0,
                                                  int op,
                                                  Expression p1,
                                                  boolean backwardsCompatible)

  Create a GeneralComparison expression

### optimizeCopy

    public Expression optimizeCopy(Expression select)
                            throws XPathException

  Attempt to optimize a copy operation. Return null if no optimization is possible.

  Parameters:
    `select` - the expression that selects the items to be copied
  Returns:
    null if no optimization is possible, or an expression that does an optimized copy of these items otherwise
  Throws:
    `XPathException`

### makeClosure

    public Closure makeClosure(Expression expression,
                               int ref)

  Make a Closure, given the expected reference count

### convertPathExpressionToKey

    public Expression convertPathExpressionToKey(PathExpression pathExp,
                                                 StaticContext env)
                                          throws XPathException

  Examine a path expression to see whether it can be replaced by a call on the key() function; if so, generate an appropriate key definition and return the call on key(). If not, return null.

  Parameters:
    `pathExp` - The path expression to be converted.
  Throws:
    `XPathException`

### convertToFilterExpression

    public FilterExpression convertToFilterExpression(PathExpression pathExp,
                                                      TypeHierarchy th)
                                               throws StaticError

  Convert a path expression such as a/b/c[predicate] into a filter expression of the form (a/b/c)[predicate]. This is possible whenever the predicate is non-positional. The conversion is useful in the case where the path expression appears inside a loop, where the predicate depends on the loop variable but a/b/c does not.

  Parameters:
    `pathExp` - the path expression to be converted
  Returns:
    the resulting filterexpression if conversion is possible, or null if not
  Throws:
    `StaticError`

### tryIndexedFilter

    public SequenceIterator tryIndexedFilter(ValueRepresentation startValue,
                                             Expression filter,
                                             int isIndexable,
                                             XPathContext context)
                                      throws XPathException

  Throws:
    `XPathException`

### isIndexableFilter

    public int isIndexableFilter(Expression filter)

  Test whether a filter predicate is indexable.

  Parameters:
    `filter` - the predicate expression
  Returns:
    0 if not indexable; +1 if the predicate is in the form expression=value; -1 if it is in the form value=expression

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