예제 #1
0
  private boolean remove(Object searchBounds, AbstractNode node, Object item) {
    // first try removing item from this node
    boolean found = removeItem(node, item);
    if (found) return true;

    AbstractNode childToPrune = null;
    // next try removing item from lower nodes
    for (Iterator i = node.getChildBoundables().iterator(); i.hasNext(); ) {
      Boundable childBoundable = (Boundable) i.next();
      if (!getIntersectsOp().intersects(childBoundable.getBounds(), searchBounds)) {
        continue;
      }
      if (childBoundable instanceof AbstractNode) {
        found = remove(searchBounds, (AbstractNode) childBoundable, item);
        // if found, record child for pruning and exit
        if (found) {
          childToPrune = (AbstractNode) childBoundable;
          break;
        }
      }
    }
    // prune child if possible
    if (childToPrune != null) {
      if (childToPrune.getChildBoundables().isEmpty()) {
        node.getChildBoundables().remove(childToPrune);
      }
    }
    return found;
  }
예제 #2
0
 private boolean removeItem(AbstractNode node, Object item) {
   Boundable childToRemove = null;
   for (Iterator i = node.getChildBoundables().iterator(); i.hasNext(); ) {
     Boundable childBoundable = (Boundable) i.next();
     if (childBoundable instanceof ItemBoundable) {
       if (((ItemBoundable) childBoundable).getItem() == item) childToRemove = childBoundable;
     }
   }
   if (childToRemove != null) {
     node.getChildBoundables().remove(childToRemove);
     return true;
   }
   return false;
 }
예제 #3
0
 protected int depth(AbstractNode node) {
   int maxChildDepth = 0;
   for (Iterator i = node.getChildBoundables().iterator(); i.hasNext(); ) {
     Boundable childBoundable = (Boundable) i.next();
     if (childBoundable instanceof AbstractNode) {
       int childDepth = depth((AbstractNode) childBoundable);
       if (childDepth > maxChildDepth) maxChildDepth = childDepth;
     }
   }
   return maxChildDepth + 1;
 }
예제 #4
0
 protected int size(AbstractNode node) {
   int size = 0;
   for (Iterator i = node.getChildBoundables().iterator(); i.hasNext(); ) {
     Boundable childBoundable = (Boundable) i.next();
     if (childBoundable instanceof AbstractNode) {
       size += size((AbstractNode) childBoundable);
     } else if (childBoundable instanceof ItemBoundable) {
       size += 1;
     }
   }
   return size;
 }
예제 #5
0
 private void query(Object searchBounds, AbstractNode node, ItemVisitor visitor) {
   List childBoundables = node.getChildBoundables();
   for (int i = 0; i < childBoundables.size(); i++) {
     Boundable childBoundable = (Boundable) childBoundables.get(i);
     if (!getIntersectsOp().intersects(childBoundable.getBounds(), searchBounds)) {
       continue;
     }
     if (childBoundable instanceof AbstractNode) {
       query(searchBounds, (AbstractNode) childBoundable, visitor);
     } else if (childBoundable instanceof ItemBoundable) {
       visitor.visitItem(((ItemBoundable) childBoundable).getItem());
     } else {
       Assert.shouldNeverReachHere();
     }
   }
 }
예제 #6
0
 private List itemsTree(AbstractNode node) {
   List valuesTreeForNode = new ArrayList();
   for (Iterator i = node.getChildBoundables().iterator(); i.hasNext(); ) {
     Boundable childBoundable = (Boundable) i.next();
     if (childBoundable instanceof AbstractNode) {
       List valuesTreeForChild = itemsTree((AbstractNode) childBoundable);
       // only add if not null (which indicates an item somewhere in this tree
       if (valuesTreeForChild != null) valuesTreeForNode.add(valuesTreeForChild);
     } else if (childBoundable instanceof ItemBoundable) {
       valuesTreeForNode.add(((ItemBoundable) childBoundable).getItem());
     } else {
       Assert.shouldNeverReachHere();
     }
   }
   if (valuesTreeForNode.size() <= 0) return null;
   return valuesTreeForNode;
 }
예제 #7
0
 /** @param level -1 to get items */
 private void boundablesAtLevel(int level, AbstractNode top, Collection boundables) {
   Assert.isTrue(level > -2);
   if (top.getLevel() == level) {
     boundables.add(top);
     return;
   }
   for (Iterator i = top.getChildBoundables().iterator(); i.hasNext(); ) {
     Boundable boundable = (Boundable) i.next();
     if (boundable instanceof AbstractNode) {
       boundablesAtLevel(level, (AbstractNode) boundable, boundables);
     } else {
       Assert.isTrue(boundable instanceof ItemBoundable);
       if (level == -1) {
         boundables.add(boundable);
       }
     }
   }
   return;
 }