/** * Adds an object to the results of the search as long as maxCapacity nor maxDistance is not exceeded. * * @param entry The object to add to the results of the search */ void addEntry(Entry<T> entry) { results.put(entry.distance, entry); int size = results.size(); if (size > maxCapacity) { //Removes some entries if maxCapacity is exceeded Float maxDistanceInResults = results.keySet().last(); NavigableSet<Entry<T>> entriesAtThisDistance = results.get(maxDistanceInResults); entriesAtThisDistance.pollLast(); if (entriesAtThisDistance.size() == 0) { results.removeAll(maxDistanceInResults); } maxDistance = results.keySet().last(); } else if (size == maxCapacity) { //If the size is at maxCapacity, then set maxDistance to the distance of the last entry maxDistance = results.keySet().last(); } } }
public void removeType(String descriptor) { ListIterator<Type> iterator = this.types.listIterator(); while (iterator.hasNext()) { Type next = iterator.next(); if (next.descriptor().equals(descriptor)) { // remove from types list iterator.remove(); // remove from type lookup this.typeLookup.get(next.range().getStart()).removeAll(descriptor); } } }
protected SortedSet<Integer> removeContainer(int containerId) { Preconditions.checkArgument(containerToElement.containsKey(containerId), "Container %s doesn't exists", containerId); SortedSet<Integer> removedElements = containerToElement.removeAll(containerId); final C container = containers.remove(containerId); observer.onContainerRemoved(containerId, container); for (Integer elementId : removedElements) { final E element = elements.remove(elementId); elementToContainer.remove(elementId); observer.onElementRemoved(containerId, container, elementId, element); } return removedElements; }
/** * Similar to <code>advanceIterators</code>, but instead of calling <code>next</code> on each sub-tree, this calls <code>move</code> with the supplied * <code>to</code> parameter. * * @param key * @param to * @return */ protected TreeMultimap<T,NestedIterator<T>> moveIterators(T key, T to) { transforms.remove(key); for (NestedIterator<T> itr : includeHeads.removeAll(key)) { T next = itr.move(to); if (next != null) { T transform = transformer.transform(next); transforms.put(transform, next); includeHeads.put(transform, itr); } } return includeHeads; }
/** * Advances all iterators associated with the supplied key and adds them back into the sorted multimap. If any of the sub-trees returns false, then they are * dropped. * * @param key * @return */ protected TreeMultimap<T,NestedIterator<T>> advanceIterators(T key) { transforms.remove(key); for (NestedIterator<T> itr : includeHeads.removeAll(key)) { if (itr.hasNext()) { T next = itr.next(); T transform = transformer.transform(next); transforms.put(transform, next); includeHeads.put(transform, itr); } } return includeHeads; }
/** * Similar to <code>advanceIterators</code>, but instead of calling <code>next</code> on each sub-tree, this calls <code>move</code> with the supplied * <code>to</code> parameter. * * @param key * @param to * @return */ protected TreeMultimap<T,NestedIterator<T>> moveIterators(T key, T to) { transforms.remove(key); for (NestedIterator<T> itr : includeHeads.removeAll(key)) { T next = itr.move(to); if (next == null) { return Util.getEmpty(); } else { T transform = transformer.transform(next); transforms.put(transform, next); includeHeads.put(transform, itr); } } return includeHeads; }
for (NestedIterator<T> filter : filters.removeAll(needsMoving.next())) { T nextFilter = filter.move(t); if (nextFilter != null) {
/** * Advances all iterators associated with the supplied key and adds them back into the sorted multimap. If any of the sub-trees returns false, this method * immediately returns false to indicate that a sub-tree has been exhausted. * * @param key * @return */ protected TreeMultimap<T,NestedIterator<T>> advanceIterators(T key) { transforms.remove(key); for (NestedIterator<T> itr : includeHeads.removeAll(key)) { if (itr.hasNext()) { T next = itr.next(); T transform = transformer.transform(next); transforms.put(transform, next); includeHeads.put(transform, itr); } else { return Util.getEmpty(); } } return includeHeads; }
static TreeMultimap<String,IndexStream> pivot(TreeMultimap<String,IndexStream> children) { TreeMultimap<String,IndexStream> newChildren = TreeMultimap.create(Ordering.<String> natural(), Ordering.arbitrary()); final String max = children.keySet().last(); newChildren.putAll(max, children.removeAll(max)); for (IndexStream itr : children.values()) {