コード例 #1
0
 /** Calculates the accumulated PRE value shifts for all updates on the list. */
 private void accumulatePreValueShifts() {
   if (!dirty) return;
   int s = 0;
   for (int i = updStructural.size() - 1; i >= 0; i--) {
     final BasicUpdate t = updStructural.get(i);
     s += t.shifts;
     t.accumulatedShifts = s;
   }
   dirty = false;
 }
コード例 #2
0
  /**
   * Checks the list of updates for violations. Updates must be ordered strictly from the highest to
   * the lowest PRE value.
   *
   * <p>A single node must not be affected by more than one {@link Rename}, {@link UpdateValue}
   * operation.
   *
   * <p>A single node must not be affected by more than one destructive operation. These operations
   * include {@link Replace}, {@link Delete}.
   */
  public void check() {
    if (ok || updStructural.size() < 2 && updValue.size() < 2) return;

    int i = 0;
    while (i + 1 < updStructural.size()) {
      final BasicUpdate current = updStructural.get(i);
      final BasicUpdate next = updStructural.get(++i);

      // check order of location PRE
      if (current.location < next.location)
        Util.notexpected("Invalid order at location " + current.location);

      if (current.location == next.location) {
        // check multiple {@link Delete}, {@link Replace}
        if (current.destructive() && next.destructive())
          Util.notexpected("Multiple deletes/replaces on node " + current.location);
      }
    }

    i = 0;
    while (i + 1 < updValue.size()) {
      final BasicUpdate current = updValue.get(i++);
      final BasicUpdate next = updValue.get(i);

      // check order of location PRE
      if (current.location < next.location)
        Util.notexpected("Invalid order at location " + current.location);

      if (current.location == next.location) {
        // check multiple {@link Rename}
        if (current instanceof Rename && next instanceof Rename)
          Util.notexpected("Multiple renames on node " + current.location);

        // check multiple {@link UpdateValue}
        if (current instanceof UpdateValue && next instanceof UpdateValue)
          Util.notexpected("Multiple updates on node " + current.location);
      }
    }
    ok = true;
  }
コード例 #3
0
  /**
   * Resolves unwanted text node adjacency which can result from structural changes in the database.
   * Adjacent text nodes are two text nodes A and B, where PRE(B)=PRE(A)+1 and PARENT(A)=PARENT(B).
   */
  private void resolveTextAdjacency() {
    // Text node merges are also gathered on a separate list to leverage optimizations.
    final AtomicUpdateList allMerges = new AtomicUpdateList(data);

    // keep track of the visited locations to avoid superfluous checks
    final IntSet s = new IntSet();
    // Text nodes have to be merged from the highest to the lowest pre value
    for (int i = 0; i < updStructural.size(); i++) {
      final BasicUpdate u = updStructural.get(i);
      final Data insseq = u.getInsertionData();
      // calculate the new location of the update, here we have to check for adjacency
      final int newLocation = u.location + u.accumulatedShifts - u.shifts;
      final int beforeNewLocation = newLocation - 1;
      // check surroundings of this location for adjacent text nodes depending on the
      // kind of update, first the one with higher PRE values (due to shifts!)
      // ... for insert/replace ...
      if (insseq != null) {
        // calculate the current following node
        final int followingNode = newLocation + insseq.meta.size;
        final int beforeFollowingNode = followingNode - 1;
        // check the nodes at the end of/after the insertion sequence
        if (!s.contains(beforeFollowingNode)) {
          final AtomicUpdateList merges = necessaryMerges(beforeFollowingNode, allMerges.data);
          mergeNodes(merges);
          allMerges.merge(merges);
          s.add(beforeFollowingNode);
        }
      }
      // check nodes for delete and for insert before the updated location
      if (!s.contains(beforeNewLocation)) {
        final AtomicUpdateList merges = necessaryMerges(beforeNewLocation, allMerges.data);
        mergeNodes(merges);
        allMerges.merge(merges);
        s.add(beforeNewLocation);
      }
    }

    allMerges.updateDistances();
    allMerges.clear();
  }
コード例 #4
0
  /**
   * Removes superfluous update operations. If a node T is deleted or replaced, all updates on the
   * descendant axis of T can be left out as they won't affect the database after all.
   *
   * <p>Superfluous updates can have a minimum PRE value of pre(T)+1 and a maximum PRE value of
   * pre(T)+size(T).
   *
   * <p>An update with location pre(T)+size(T) can only be removed if the update is an atomic insert
   * and the inserted node is then part of the subtree of T.
   */
  public void optimize() {
    if (opt) return;

    check();
    // traverse from lowest to highest PRE value
    int i = updStructural.size() - 1;
    while (i >= 0) {
      final BasicUpdate u = updStructural.get(i);
      // If this update can lead to superfluous updates ...
      if (u.destructive()) {
        // we determine the lowest and highest PRE values of a superfluous update
        final int pre = u.location;
        final int fol = pre + data.size(pre, data.kind(pre));
        i--;
        // and have a look at the next candidate
        while (i >= 0) {
          final BasicUpdate desc = updStructural.get(i);
          final int descpre = desc.location;
          // if the candidate operates on the subtree of T and inserts a node ...
          if (descpre <= fol
              && (desc instanceof Insert || desc instanceof InsertAttr)
              && desc.parent() >= pre
              && desc.parent() < fol) {
            // it is removed.
            updStructural.remove(i--);

            // Other updates (not inserting a node) that operate on the subtree of T can
            // only have a PRE value that is smaller than the following PRE of T
          } else if (descpre < fol) {
            // these we delete.
            updStructural.remove(i--);

            // Else there's nothing to delete
          } else break;
        }
      } else i--;
    }
    opt = true;
  }
コード例 #5
0
  /**
   * Finds the position of the update with the lowest index that affects the given PRE value P. If
   * there are multiple updates whose affected PRE value equals P, the search has to be further
   * refined as this method returns the first match.
   *
   * @param pre given PRE value
   * @param beforeUpdates compare based on PRE values before/after updates
   * @return index of update
   */
  private int find(final int pre, final boolean beforeUpdates) {
    int left = 0;
    int right = updStructural.size() - 1;

    while (left <= right) {
      if (left == right) {
        if (c(updStructural, left, beforeUpdates) <= pre) return left;
        return -1;
      }
      if (right - left == 1) {
        if (c(updStructural, left, beforeUpdates) <= pre) return left;
        if (c(updStructural, right, beforeUpdates) <= pre) return right;
        return -1;
      }
      final int middle = left + right >>> 1;
      final int value = c(updStructural, middle, beforeUpdates);
      if (value == pre) return middle;
      else if (value > pre) left = middle + 1;
      else right = middle;
    }

    // empty array
    return -1;
  }
コード例 #6
0
 /**
  * Returns the number of value updates.
  *
  * @return number of value updates
  */
 public int valueUpdatesSize() {
   return updValue.size();
 }
コード例 #7
0
 /**
  * Returns the number of structural updates.
  *
  * @return number of structural updates
  */
 public int structuralUpdatesSize() {
   return updStructural.size();
 }