/**
   * Inverts a location path.
   *
   * @param r new root node
   * @param curr current location step
   * @return inverted path
   */
  public final AxisPath invertPath(final Expr r, final AxisStep curr) {
    // hold the steps to the end of the inverted path
    int s = steps.length;
    final Expr[] e = new Expr[s--];
    // add predicates of last step to new root node
    final Expr rt = step(s).preds.length != 0 ? new Filter(input, r, step(s).preds) : r;

    // add inverted steps in a backward manner
    int c = 0;
    while (--s >= 0) {
      e[c++] = AxisStep.get(input, step(s + 1).axis.invert(), step(s).test, step(s).preds);
    }
    e[c] = AxisStep.get(input, step(s + 1).axis.invert(), curr.test);
    return new AxisPath(input, rt, e);
  }
  @Override
  public final Expr addText(final QueryContext ctx) {
    final AxisStep s = step(steps.length - 1);

    if (s.preds.length != 0
        || !s.axis.down
        || s.test.type == NodeType.ATT
        || s.test.test != Name.NAME && s.test.test != Name.STD) return this;

    final Data data = ctx.data();
    if (data == null || !data.meta.uptodate) return this;

    final Stats stats = data.tagindex.stat(data.tagindex.id(s.test.name.local()));
    if (stats != null && stats.isLeaf()) {
      steps = Array.add(steps, AxisStep.get(input, Axis.CHILD, Test.TXT));
      ctx.compInfo(OPTTEXT, this);
    }
    return this;
  }
 /**
  * Returns a copy of the path expression.
  *
  * @return copy
  */
 public final Path copy() {
   final Expr[] stps = new Expr[steps.length];
   for (int s = 0; s < steps.length; ++s) stps[s] = AxisStep.get(step(s));
   return get(input, root, stps);
 }
  /**
   * If possible, returns an expression which accesses the index. Otherwise, returns the original
   * expression.
   *
   * @param ctx query context
   * @param data data reference
   * @return resulting expression
   * @throws QueryException query exception
   */
  private Expr index(final QueryContext ctx, final Data data) throws QueryException {

    // disallow relative paths and numeric predicates
    if (root == null || uses(Use.POS)) return this;

    // cache index access costs
    IndexContext ics = null;
    // cheapest predicate and step
    int pmin = 0;
    int smin = 0;

    // check if path can be converted to an index access
    for (int s = 0; s < steps.length; ++s) {
      // find cheapest index access
      final AxisStep stp = step(s);
      if (!stp.axis.down) break;

      // check if resulting index path will be duplicate free
      final boolean i = pathNodes(data, s) != null;

      // choose cheapest index access
      for (int p = 0; p < stp.preds.length; ++p) {
        final IndexContext ic = new IndexContext(ctx, data, stp, i);
        if (!stp.preds[p].indexAccessible(ic)) continue;

        if (ic.costs() == 0) {
          if (ic.not) {
            // not operator... accept all results
            stp.preds[p] = Bln.TRUE;
            continue;
          }
          // no results...
          ctx.compInfo(OPTNOINDEX, this);
          return Empty.SEQ;
        }
        if (ics == null || ics.costs() > ic.costs()) {
          ics = ic;
          pmin = p;
          smin = s;
        }
      }
    }

    // skip if no index access is possible, or if it is too expensive
    if (ics == null || ics.costs() > data.meta.size) return this;

    // replace expressions for index access
    final AxisStep stp = step(smin);
    final Expr ie = stp.preds[pmin].indexEquivalent(ics);

    if (ics.seq) {
      // sequential evaluation; do not invert path
      stp.preds[pmin] = ie;
    } else {
      // inverted path, which will be represented as predicate
      AxisStep[] invSteps = {};

      // collect remaining predicates
      final Expr[] newPreds = new Expr[stp.preds.length - 1];
      int c = 0;
      for (int p = 0; p != stp.preds.length; ++p) {
        if (p != pmin) newPreds[c++] = stp.preds[p];
      }

      // check if path before index step needs to be inverted and traversed
      final Test test = DocTest.get(ctx, data);
      boolean inv = true;
      if (test == Test.DOC && data.meta.pathindex && data.meta.uptodate) {
        int j = 0;
        for (; j <= smin; ++j) {
          // invert if axis is not a child or has predicates
          final AxisStep s = axisStep(j);
          if (s == null) break;
          if (s.axis != Axis.CHILD || s.preds.length > 0 && j != smin) break;
          if (s.test.test == Name.ALL || s.test.test == null) continue;
          if (s.test.test != Name.NAME) break;

          // support only unique paths with nodes on the correct level
          final int name = data.tagindex.id(s.test.name.local());
          final ObjList<PathNode> pn = data.paths.desc(name, Data.ELEM);
          if (pn.size() != 1 || pn.get(0).level() != j + 1) break;
        }
        inv = j <= smin;
      }

      // invert path before index step
      if (inv) {
        for (int j = smin; j >= 0; --j) {
          final Axis ax = step(j).axis.invert();
          if (ax == null) break;
          if (j != 0) {
            final AxisStep prev = step(j - 1);
            invSteps = Array.add(invSteps, AxisStep.get(input, ax, prev.test, prev.preds));
          } else {
            // add document test for collections and axes other than ancestors
            if (test != Test.DOC || ax != Axis.ANC && ax != Axis.ANCORSELF)
              invSteps = Array.add(invSteps, AxisStep.get(input, ax, test));
          }
        }
      }

      // create resulting expression
      final AxisPath result;
      final boolean simple = invSteps.length == 0 && newPreds.length == 0;
      if (ie instanceof AxisPath) {
        result = (AxisPath) ie;
      } else if (smin + 1 < steps.length || !simple) {
        result =
            simple
                ? new AxisPath(input, ie)
                : new AxisPath(input, ie, AxisStep.get(input, Axis.SELF, Test.NOD));
      } else {
        return ie;
      }

      // add remaining predicates to last step
      final int ls = result.steps.length - 1;
      if (ls >= 0) {
        result.steps[ls] = result.step(ls).addPreds(newPreds);
        // add inverted path as predicate to last step
        if (invSteps.length != 0)
          result.steps[ls] = result.step(ls).addPreds(Path.get(input, null, invSteps));
      }

      // add remaining steps
      for (int s = smin + 1; s < steps.length; ++s) {
        result.steps = Array.add(result.steps, steps[s]);
      }
      return result;
    }
    return this;
  }