示例#1
0
 private static void reclaim(
     @NotNull final PatriciaReclaimSourceTraverser source,
     @NotNull final PatriciaReclaimActualTraverser actual) {
   final NodeBase actualNode = actual.currentNode;
   final NodeBase sourceNode = source.currentNode;
   if (actualNode.getAddress() == sourceNode.getAddress()) {
     actual.currentNode = actualNode.getMutableCopy(actual.mainTree);
     actual.getItr();
     actual.wasReclaim = true;
     reclaimActualChildren(source, actual);
   } else {
     @NotNull ByteIterator srcItr = sourceNode.keySequence.iterator();
     @NotNull ByteIterator actItr = actualNode.keySequence.iterator();
     int srcPushes = 0;
     int actPushes = 0;
     while (true) {
       if (srcItr.hasNext()) {
         if (actItr.hasNext()) {
           if (srcItr.next() != actItr.next()) { // key is not matching
             break;
           }
         } else {
           final NodeChildrenIterator children = actual.currentNode.getChildren(srcItr.next());
           final ChildReference child = children.getNode();
           if (child == null) {
             break;
           }
           actual.currentChild = child;
           actual.currentIterator = children;
           actual.moveDown();
           ++actPushes;
           actItr = actual.currentNode.keySequence.iterator();
         }
       } else if (actItr.hasNext()) {
         final NodeChildrenIterator children = source.currentNode.getChildren(actItr.next());
         final ChildReference child = children.getNode();
         if (child == null || !source.isAddressReclaimable(child.suffixAddress)) {
           break; // child can be expired if source parent was already not-current
         }
         source.currentChild = child;
         source.currentIterator = children;
         source.moveDown();
         ++srcPushes;
         srcItr = source.currentNode.keySequence.iterator();
       } else { // both iterators matched, here comes the branching
         reclaimChildren(source, actual);
         break;
       }
     }
     for (int i = 0; i < srcPushes; ++i) {
       source.moveUp();
     }
     for (int i = 0; i < actPushes; ++i) {
       actual.popAndMutate();
     }
   }
 }
示例#2
0
 private static void reclaimChildren(
     @NotNull final PatriciaReclaimSourceTraverser source,
     @NotNull final PatriciaReclaimActualTraverser actual) {
   source.moveToNextReclaimable();
   while (source.isValidPos() && actual.isValidPos()) {
     final ChildReference sourceChild = source.currentChild;
     final int sourceByte = sourceChild.firstByte & 0xff;
     final int actualByte = actual.currentChild.firstByte & 0xff;
     if (sourceByte < actualByte) {
       source.moveRight();
     } else if (sourceByte > actualByte) {
       actual.moveRight();
     } else {
       source.moveDown();
       actual.moveDown();
       reclaim(source, actual);
       actual.popAndMutate();
       source.moveUp();
       source.moveRight();
       actual.moveRight();
     }
   }
 }
示例#3
0
 private static void reclaimActualChildren(
     @NotNull final PatriciaReclaimSourceTraverser source,
     @NotNull final PatriciaReclaimActualTraverser actual) {
   while (actual.isValidPos()) {
     final ChildReference actualChild = actual.currentChild;
     final long suffixAddress = actualChild.suffixAddress;
     if (source.isAddressReclaimable(suffixAddress)) {
       actual.moveDown();
       actual.currentNode = actual.currentNode.getMutableCopy(actual.mainTree);
       actual.getItr();
       actual.wasReclaim = true;
       reclaimActualChildren(source, actual);
       actual.popAndMutate();
     }
     actual.moveRight();
   }
 }