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

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `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. id(), extension function, etc.) step.
    `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

    Constructors
    Constructor and Description
    `WalkerFactory()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `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!!!
      See Also:
        Constant Field Values

    - #### BITS_RESERVED

          public static final int BITS_RESERVED

      4 bits are reserved for future use.
      See Also:
        Constant Field Values

    - #### BIT_PREDICATE

          public static final int BIT_PREDICATE

      Bit is on if the expression contains a top-level predicate.
      See Also:
        Constant Field Values

    - #### BIT_ANCESTOR

          public static final int BIT_ANCESTOR

      Bit is on if any of the walkers contain an ancestor step.
      See Also:
        Constant Field Values

    - #### 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.
      See Also:
        Constant Field Values

    - #### BIT_ATTRIBUTE

          public static final int BIT_ATTRIBUTE

      Bit is on if any of the walkers contain an attribute step.
      See Also:
        Constant Field Values

    - #### BIT_CHILD

          public static final int BIT_CHILD

      Bit is on if any of the walkers contain a child step.
      See Also:
        Constant Field Values

    - #### BIT_DESCENDANT

          public static final int BIT_DESCENDANT

      Bit is on if any of the walkers contain a descendant step.
      See Also:
        Constant Field Values

    - #### 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.
      See Also:
        Constant Field Values

    - #### BIT_FOLLOWING

          public static final int BIT_FOLLOWING

      Bit is on if any of the walkers contain a following step.
      See Also:
        Constant Field Values

    - #### BIT_FOLLOWING_SIBLING

          public static final int BIT_FOLLOWING_SIBLING

      Bit is on if any of the walkers contain a following-sibiling step.
      See Also:
        Constant Field Values

    - #### BIT_NAMESPACE

          public static final int BIT_NAMESPACE

      Bit is on if any of the walkers contain a namespace step.
      See Also:
        Constant Field Values

    - #### BIT_PARENT

          public static final int BIT_PARENT

      Bit is on if any of the walkers contain a parent step.
      See Also:
        Constant Field Values

    - #### BIT_PRECEDING

          public static final int BIT_PRECEDING

      Bit is on if any of the walkers contain a preceding step.
      See Also:
        Constant Field Values

    - #### BIT_PRECEDING_SIBLING

          public static final int BIT_PRECEDING_SIBLING

      Bit is on if any of the walkers contain a preceding-sibling step.
      See Also:
        Constant Field Values

    - #### BIT_SELF

          public static final int BIT_SELF

      Bit is on if any of the walkers contain a self step.
      See Also:
        Constant Field Values

    - #### 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.
      See Also:
        Constant Field Values

    - #### BIT_ROOT

          public static final int BIT_ROOT

      Bit is on if any of the walkers contain a root step.
      See Also:
        Constant Field Values

    - #### 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.
      See Also:
        Constant Field Values

    - #### 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.
      See Also:
        Constant Field Values

    - #### BIT_ANY_DESCENDANT_FROM_ROOT

          public static final int BIT_ANY_DESCENDANT_FROM_ROOT

      Found "//foo" pattern
      See Also:
        Constant Field Values

    - #### 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.
      See Also:
        Constant Field Values

    - #### BIT_MATCH_PATTERN

          public static final int BIT_MATCH_PATTERN

      Bit is on if the expression is a match pattern.
      See Also:
        Constant Field Values

  - ### 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 javax.xml.transform.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:
        `javax.xml.transform.TransformerException`

    - #### getAxisFromStep

          public static int getAxisFromStep(Compiler compiler,
                                            int stepOpCodePos)
                                     throws javax.xml.transform.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:
        `javax.xml.transform.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 javax.xml.transform.TransformerException

      Tell if the predicates need to have proximity knowledge.
      Throws:
        `javax.xml.transform.TransformerException`

    - #### 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:
        `javax.xml.transform.TransformerException`

    - #### isOneStep

          public static boolean isOneStep(int analysis)

    - #### getStepCount

          public static int getStepCount(int analysis)

Copyright © 2023 Apache XML Project. All Rights Reserved.