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;
  }
Exemple #2
0
 /** Removes an item from the tree. (Builds the tree, if necessary.) */
 protected boolean remove(Object searchBounds, Object item) {
   build();
   if (itemBoundables.isEmpty()) {
     Assert.isTrue(root.getBounds() == null);
   }
   if (getIntersectsOp().intersects(root.getBounds(), searchBounds)) {
     return remove(searchBounds, root, item);
   }
   return false;
 }
 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;
 }
 /** Removes an item from the tree. (Builds the tree, if necessary.) */
 protected boolean remove(Object searchBounds, Object item) {
   build();
   if (getIntersectsOp().intersects(root.getBounds(), searchBounds)) {
     return remove(searchBounds, root, item);
   }
   return false;
 }
 /** @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;
 }
 /** Also builds the tree, if necessary. */
 protected void query(Object searchBounds, ItemVisitor visitor) {
   build();
   if (isEmpty()) {
     // nothing in tree, so return
     // Assert.isTrue(root.getBounds() == null);
     return;
   }
   if (getIntersectsOp().intersects(root.getBounds(), searchBounds)) {
     query(searchBounds, root, visitor);
   }
 }
 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;
 }
 /** Also builds the tree, if necessary. */
 protected List query(Object searchBounds) {
   build();
   ArrayList matches = new ArrayList();
   if (isEmpty()) {
     // Assert.isTrue(root.getBounds() == null);
     return matches;
   }
   if (getIntersectsOp().intersects(root.getBounds(), searchBounds)) {
     query(searchBounds, root, matches);
   }
   return matches;
 }
 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;
 }
 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();
     }
   }
 }
 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;
 }
 /**
  * Tests whether the index contains any items. This method does not build the index, so items can
  * still be inserted after it has been called.
  *
  * @return true if the index does not contain any items
  */
 public boolean isEmpty() {
   if (!built) return itemBoundables.isEmpty();
   return root.isEmpty();
 }