## org.apache.xpath.axes
Class WalkerFactory

    java.lang.Object
      |
      +--org.apache.xpath.axes.WalkerFactory

public class WalkerFactory
extends java.lang.Object

This class is both a factory for XPath location path expressions, which are built from the opcode map output, and an analysis engine for the location path expressions in order to provide optimization hints.

Field Summary
`static int` `BIT_ANCESTOR` Bit is on if any of the walkers contain an ancestor step.
`static int` `BIT_ANCESTOR_OR_SELF` Bit is on if any of the walkers contain an ancestor-or-self step.
`static int` `BIT_ANY_DESCENDANT_FROM_ROOT` Found "//foo" pattern
`static int` `BIT_ATTRIBUTE` Bit is on if any of the walkers contain an attribute step.
`static int` `BIT_BACKWARDS_SELF` Bit is on if any of the walkers can go backwards in document order from the context node.
`static int` `BIT_CHILD` Bit is on if any of the walkers contain a child step.
`static int` `BIT_DESCENDANT` Bit is on if any of the walkers contain a descendant step.
`static int` `BIT_DESCENDANT_OR_SELF` Bit is on if any of the walkers contain a descendant-or-self step.
`static int` `BIT_FILTER` Bit is on if any of the walkers contain a filter (i.e.
`static int` `BIT_FOLLOWING` Bit is on if any of the walkers contain a following step.
`static int` `BIT_FOLLOWING_SIBLING` Bit is on if any of the walkers contain a following-sibiling step.
`static int` `BIT_MATCH_PATTERN` Bit is on if the expression is a match pattern.
`static int` `BIT_NAMESPACE` Bit is on if any of the walkers contain a namespace step.
`static int` `BIT_NODETEST_ANY` Bit is on if any of the walkers contain an node() test.
`static int` `BIT_PARENT` Bit is on if any of the walkers contain a parent step.
`static int` `BIT_PRECEDING` Bit is on if any of the walkers contain a preceding step.
`static int` `BIT_PRECEDING_SIBLING` Bit is on if any of the walkers contain a preceding-sibling step.
`static int` `BIT_PREDICATE` Bit is on if the expression contains a top-level predicate.
`static int` `BIT_ROOT` Bit is on if any of the walkers contain a root step.
`static int` `BIT_SELF` Bit is on if any of the walkers contain a self step.
`static int` `BITMASK_TRAVERSES_OUTSIDE_SUBTREE` If any of these bits are on, the expression may likely traverse outside the given subtree.
`static int` `BITS_COUNT` First 8 bits are the number of top-level location steps.
`static int` `BITS_RESERVED` 4 bits are reserved for future use.

Constructor Summary
`WalkerFactory()`

Method Summary
`static boolean` `canCrissCross(int analysis)`
`static boolean` `canSkipSubtrees(int analysis)`
`static void` `diagnoseIterator(java.lang.String name, int analysis, Compiler compiler)`
`static int` `getAnalysisBitFromAxes(int axis)` Get a corresponding BIT_XXX from an axis.
`static java.lang.String` `getAnalysisString(int analysis)`
`static int` `getAxisFromStep(Compiler compiler, int stepOpCodePos)` Special purpose function to see if we can optimize the pattern for a DescendantIterator.
`static int` `getStepCount(int analysis)`
`static boolean` `hasPredicate(int analysis)`
`static boolean` `isAbsolute(int analysis)`
`static boolean` `isDownwardAxisOfMany(int axis)` Tell if the given axis goes downword.
`static boolean` `isNaturalDocOrder(int analysis)` Tell if the pattern can be 'walked' with the iteration steps in natural document order, without duplicates.
`static boolean` `isOneStep(int analysis)`
`static boolean` `isSet(int analysis, int bits)`
`static boolean` `isWild(int analysis)`
`static boolean` `mightBeProximate(Compiler compiler, int opPos, int stepType)` Tell if the predicates need to have proximity knowledge.
`static DTMIterator` `newDTMIterator(Compiler compiler, int opPos, boolean isTopLevel)` Create a new LocPathIterator iterator.
`static boolean` `walksAncestors(int analysis)`
`static boolean` `walksAttributes(int analysis)`
`static boolean` `walksChildren(int analysis)`
`static boolean` `walksChildrenAndExtraAndSelfOnly(int analysis)`
`static boolean` `walksChildrenOnly(int analysis)`
`static boolean` `walksDescendants(int analysis)`
`static boolean` `walksDescendantsAndExtraAndSelfOnly(int analysis)`
`static boolean` `walksDownExtraOnly(int analysis)`
`static boolean` `walksDownOnly(int analysis)`
`static boolean` `walksExtraNodes(int analysis)`
`static boolean` `walksExtraNodesOnly(int analysis)`
`static boolean` `walksFilteredList(int analysis)`
`static boolean` `walksFollowingOnlyMaybeAbsolute(int analysis)`
`static boolean` `walksInDocOrder(int analysis)`
`static boolean` `walksNamespaces(int analysis)`
`static boolean` `walksSelfOnly(int analysis)`
`static boolean` `walksSideways(int analysis)`
`static boolean` `walksSubtree(int analysis)`
`static boolean` `walksSubtreeOnly(int analysis)`
`static boolean` `walksSubtreeOnlyFromRootOrContext(int analysis)`
`static boolean` `walksSubtreeOnlyMaybeAbsolute(int analysis)`
`static boolean` `walksUp(int analysis)`
`static boolean` `walksUpOnly(int analysis)`

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

Field Detail

### BITS_COUNT

    public static final int BITS_COUNT

  First 8 bits are the number of top-level location steps. Hopefully there will never be more that 255 location steps!!!

### BITS_RESERVED

    public static final int BITS_RESERVED

  4 bits are reserved for future use.

### BIT_PREDICATE

    public static final int BIT_PREDICATE

  Bit is on if the expression contains a top-level predicate.

### BIT_ANCESTOR

    public static final int BIT_ANCESTOR

  Bit is on if any of the walkers contain an ancestor step.

### BIT_ANCESTOR_OR_SELF

    public static final int BIT_ANCESTOR_OR_SELF

  Bit is on if any of the walkers contain an ancestor-or-self step.

### BIT_ATTRIBUTE

    public static final int BIT_ATTRIBUTE

  Bit is on if any of the walkers contain an attribute step.

### BIT_CHILD

    public static final int BIT_CHILD

  Bit is on if any of the walkers contain a child step.

### BIT_DESCENDANT

    public static final int BIT_DESCENDANT

  Bit is on if any of the walkers contain a descendant step.

### BIT_DESCENDANT_OR_SELF

    public static final int BIT_DESCENDANT_OR_SELF

  Bit is on if any of the walkers contain a descendant-or-self step.

### BIT_FOLLOWING

    public static final int BIT_FOLLOWING

  Bit is on if any of the walkers contain a following step.

### BIT_FOLLOWING_SIBLING

    public static final int BIT_FOLLOWING_SIBLING

  Bit is on if any of the walkers contain a following-sibiling step.

### BIT_NAMESPACE

    public static final int BIT_NAMESPACE

  Bit is on if any of the walkers contain a namespace step.

### BIT_PARENT

    public static final int BIT_PARENT

  Bit is on if any of the walkers contain a parent step.

### BIT_PRECEDING

    public static final int BIT_PRECEDING

  Bit is on if any of the walkers contain a preceding step.

### BIT_PRECEDING_SIBLING

    public static final int BIT_PRECEDING_SIBLING

  Bit is on if any of the walkers contain a preceding-sibling step.

### BIT_SELF

    public static final int BIT_SELF

  Bit is on if any of the walkers contain a self step.

### BIT_FILTER

    public static final int BIT_FILTER

  Bit is on if any of the walkers contain a filter (i.e. id(), extension function, etc.) step.

### BIT_ROOT

    public static final int BIT_ROOT

  Bit is on if any of the walkers contain a root step.

### BITMASK_TRAVERSES_OUTSIDE_SUBTREE

    public static final int BITMASK_TRAVERSES_OUTSIDE_SUBTREE

  If any of these bits are on, the expression may likely traverse outside the given subtree.

### BIT_BACKWARDS_SELF

    public static final int BIT_BACKWARDS_SELF

  Bit is on if any of the walkers can go backwards in document order from the context node.

### BIT_ANY_DESCENDANT_FROM_ROOT

    public static final int BIT_ANY_DESCENDANT_FROM_ROOT

  Found "//foo" pattern

### BIT_NODETEST_ANY

    public static final int BIT_NODETEST_ANY

  Bit is on if any of the walkers contain an node() test. This is really only useful if the count is 1.

### BIT_MATCH_PATTERN

    public static final int BIT_MATCH_PATTERN

  Bit is on if the expression is a match pattern.

Constructor Detail

### WalkerFactory

    public WalkerFactory()

Method Detail

### isSet

    public static boolean isSet(int analysis,
                                int bits)

### diagnoseIterator

    public static void diagnoseIterator(java.lang.String name,
                                        int analysis,
                                        Compiler compiler)

### newDTMIterator

    public static DTMIterator newDTMIterator(Compiler compiler,
                                             int opPos,
                                             boolean isTopLevel)
                                      throws TransformerException

  Create a new LocPathIterator iterator. The exact type of iterator returned is based on an analysis of the XPath operations.
  Parameters:
    `compiler` - non-null reference to compiler object that has processed the XPath operations into an opcode map.
    `opPos` - The position of the operation code for this itterator.
  Returns:
    non-null reference to a LocPathIterator or derivative.
  Throws:
    TransformerException -

### getAxisFromStep

    public static int getAxisFromStep(Compiler compiler,
                                      int stepOpCodePos)
                               throws TransformerException

  Special purpose function to see if we can optimize the pattern for a DescendantIterator.
  Parameters:
    `compiler` - non-null reference to compiler object that has processed the XPath operations into an opcode map.
    `stepOpCodePos` - The opcode position for the step.
  Returns:
    32 bits as an integer that give information about the location path as a whole.
  Throws:
    TransformerException -

### getAnalysisBitFromAxes

    public static int getAnalysisBitFromAxes(int axis)

  Get a corresponding BIT_XXX from an axis.
  Parameters:
    `axis` - One of Axis.ANCESTOR, etc.
  Returns:
    One of BIT_ANCESTOR, etc.

### mightBeProximate

    public static boolean mightBeProximate(Compiler compiler,
                                           int opPos,
                                           int stepType)
                                    throws TransformerException

  Tell if the predicates need to have proximity knowledge.

### isDownwardAxisOfMany

    public static boolean isDownwardAxisOfMany(int axis)

  Tell if the given axis goes downword. Bogus name, if you can think of a better one, please do tell. This really has to do with inverting attribute axis.
  Parameters:
    `axis` - One of Axis.XXX.
  Returns:
    true if the axis is not a child axis and does not go up from the axis root.

### getAnalysisString

    public static java.lang.String getAnalysisString(int analysis)

### hasPredicate

    public static boolean hasPredicate(int analysis)

### isWild

    public static boolean isWild(int analysis)

### walksAncestors

    public static boolean walksAncestors(int analysis)

### walksAttributes

    public static boolean walksAttributes(int analysis)

### walksNamespaces

    public static boolean walksNamespaces(int analysis)

### walksChildren

    public static boolean walksChildren(int analysis)

### walksDescendants

    public static boolean walksDescendants(int analysis)

### walksSubtree

    public static boolean walksSubtree(int analysis)

### walksSubtreeOnlyMaybeAbsolute

    public static boolean walksSubtreeOnlyMaybeAbsolute(int analysis)

### walksSubtreeOnly

    public static boolean walksSubtreeOnly(int analysis)

### walksFilteredList

    public static boolean walksFilteredList(int analysis)

### walksSubtreeOnlyFromRootOrContext

    public static boolean walksSubtreeOnlyFromRootOrContext(int analysis)

### walksInDocOrder

    public static boolean walksInDocOrder(int analysis)

### walksFollowingOnlyMaybeAbsolute

    public static boolean walksFollowingOnlyMaybeAbsolute(int analysis)

### walksUp

    public static boolean walksUp(int analysis)

### walksSideways

    public static boolean walksSideways(int analysis)

### walksExtraNodes

    public static boolean walksExtraNodes(int analysis)

### walksExtraNodesOnly

    public static boolean walksExtraNodesOnly(int analysis)

### isAbsolute

    public static boolean isAbsolute(int analysis)

### walksChildrenOnly

    public static boolean walksChildrenOnly(int analysis)

### walksChildrenAndExtraAndSelfOnly

    public static boolean walksChildrenAndExtraAndSelfOnly(int analysis)

### walksDescendantsAndExtraAndSelfOnly

    public static boolean walksDescendantsAndExtraAndSelfOnly(int analysis)

### walksSelfOnly

    public static boolean walksSelfOnly(int analysis)

### walksUpOnly

    public static boolean walksUpOnly(int analysis)

### walksDownOnly

    public static boolean walksDownOnly(int analysis)

### walksDownExtraOnly

    public static boolean walksDownExtraOnly(int analysis)

### canSkipSubtrees

    public static boolean canSkipSubtrees(int analysis)

### canCrissCross

    public static boolean canCrissCross(int analysis)

### isNaturalDocOrder

    public static boolean isNaturalDocOrder(int analysis)

  Tell if the pattern can be 'walked' with the iteration steps in natural document order, without duplicates.
  Parameters:
    `analysis` - The general analysis of the pattern.
  Returns:
    true if the walk can be done in natural order.
  Throws:
    TransformerException -

### isOneStep

    public static boolean isOneStep(int analysis)

### getStepCount

    public static int getStepCount(int analysis)

Copyright © 2006 Apache XML Project. All Rights Reserved.