accept simple iterator where closeable-ness is not needed
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/177bf5f4 Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/177bf5f4 Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/177bf5f4 Branch: refs/heads/trunk Commit: 177bf5f4fcfab34f868268ae802c1f7fe08f8b64 Parents: 5612b93 Author: Jonathan Ellis <[email protected]> Authored: Wed May 15 17:13:56 2013 -0500 Committer: Jonathan Ellis <[email protected]> Committed: Wed May 15 17:13:56 2013 -0500 ---------------------------------------------------------------------- .../apache/cassandra/db/CollationController.java | 21 +---------- .../apache/cassandra/db/filter/QueryFilter.java | 17 +++------ .../cassandra/io/sstable/ReducingKeyIterator.java | 14 +++---- .../org/apache/cassandra/utils/IMergeIterator.java | 4 ++- .../org/apache/cassandra/utils/MergeIterator.java | 29 ++++++++------- 5 files changed, 31 insertions(+), 54 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/cassandra/blob/177bf5f4/src/java/org/apache/cassandra/db/CollationController.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/CollationController.java b/src/java/org/apache/cassandra/db/CollationController.java index 2a45df5..1bb09ce 100644 --- a/src/java/org/apache/cassandra/db/CollationController.java +++ b/src/java/org/apache/cassandra/db/CollationController.java @@ -156,28 +156,9 @@ public class CollationController return null; // do a final collate. toCollate is boilerplate required to provide a CloseableIterator - CloseableIterator<OnDiskAtom> toCollate = new SimpleAbstractColumnIterator() - { - final Iterator<Column> iter = container.iterator(); - - protected OnDiskAtom computeNext() - { - return iter.hasNext() ? iter.next() : endOfData(); - } - - public ColumnFamily getColumnFamily() - { - return container; - } - - public DecoratedKey getKey() - { - return filter.key; - } - }; ColumnFamily returnCF = container.cloneMeShallow(); Tracing.trace("Collating all results"); - filter.collateOnDiskAtom(returnCF, Collections.singletonList(toCollate), gcBefore); + filter.collateOnDiskAtom(returnCF, Collections.singletonList(container.iterator()), gcBefore); // "hoist up" the requested data into a more recent sstable if (sstablesIterated > cfs.getMinimumCompactionThreshold() http://git-wip-us.apache.org/repos/asf/cassandra/blob/177bf5f4/src/java/org/apache/cassandra/db/filter/QueryFilter.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/db/filter/QueryFilter.java b/src/java/org/apache/cassandra/db/filter/QueryFilter.java index c6414fa..740240c 100644 --- a/src/java/org/apache/cassandra/db/filter/QueryFilter.java +++ b/src/java/org/apache/cassandra/db/filter/QueryFilter.java @@ -67,15 +67,15 @@ public class QueryFilter return filter.getSSTableColumnIterator(sstable, file, key, indexEntry); } - public void collateOnDiskAtom(final ColumnFamily returnCF, List<? extends CloseableIterator<OnDiskAtom>> toCollate, final int gcBefore) + public void collateOnDiskAtom(final ColumnFamily returnCF, List<? extends Iterator<? extends OnDiskAtom>> toCollate, final int gcBefore) { - List<CloseableIterator<Column>> filteredIterators = new ArrayList<CloseableIterator<Column>>(toCollate.size()); - for (CloseableIterator<OnDiskAtom> iter : toCollate) + List<Iterator<Column>> filteredIterators = new ArrayList<Iterator<Column>>(toCollate.size()); + for (Iterator<? extends OnDiskAtom> iter : toCollate) filteredIterators.add(gatherTombstones(returnCF, iter)); collateColumns(returnCF, filteredIterators, gcBefore); } - public void collateColumns(final ColumnFamily returnCF, List<? extends CloseableIterator<Column>> toCollate, final int gcBefore) + public void collateColumns(final ColumnFamily returnCF, List<? extends Iterator<Column>> toCollate, final int gcBefore) { Comparator<Column> fcomp = filter.getColumnComparator(returnCF.getComparator()); // define a 'reduced' iterator that merges columns w/ the same name, which @@ -105,9 +105,9 @@ public class QueryFilter * Given an iterator of on disk atom, returns an iterator that filters the tombstone range * markers adding them to {@code returnCF} and returns the normal column. */ - public static CloseableIterator<Column> gatherTombstones(final ColumnFamily returnCF, final CloseableIterator<OnDiskAtom> iter) + public static Iterator<Column> gatherTombstones(final ColumnFamily returnCF, final Iterator<? extends OnDiskAtom> iter) { - return new CloseableIterator<Column>() + return new Iterator<Column>() { private Column next; @@ -153,11 +153,6 @@ public class QueryFilter { throw new UnsupportedOperationException(); } - - public void close() throws IOException - { - iter.close(); - } }; } http://git-wip-us.apache.org/repos/asf/cassandra/blob/177bf5f4/src/java/org/apache/cassandra/io/sstable/ReducingKeyIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/io/sstable/ReducingKeyIterator.java b/src/java/org/apache/cassandra/io/sstable/ReducingKeyIterator.java index c977cad..6cb8653 100644 --- a/src/java/org/apache/cassandra/io/sstable/ReducingKeyIterator.java +++ b/src/java/org/apache/cassandra/io/sstable/ReducingKeyIterator.java @@ -20,6 +20,7 @@ package org.apache.cassandra.io.sstable; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; +import java.util.Iterator; import org.apache.cassandra.db.DecoratedKey; import org.apache.cassandra.utils.CloseableIterator; @@ -62,18 +63,15 @@ public class ReducingKeyIterator implements CloseableIterator<DecoratedKey> public void close() throws IOException { - for (Object o : mi.iterators()) - { - ((CloseableIterator)o).close(); - } + mi.close(); } public long getTotalBytes() { long m = 0; - for (Object o : mi.iterators()) + for (Iterator<DecoratedKey> iter : mi.iterators()) { - m += ((KeyIterator) o).getTotalBytes(); + m += ((KeyIterator) iter).getTotalBytes(); } return m; } @@ -81,9 +79,9 @@ public class ReducingKeyIterator implements CloseableIterator<DecoratedKey> public long getBytesRead() { long m = 0; - for (Object o : mi.iterators()) + for (Iterator<DecoratedKey> iter : mi.iterators()) { - m += ((KeyIterator) o).getBytesRead(); + m += ((KeyIterator) iter).getBytesRead(); } return m; } http://git-wip-us.apache.org/repos/asf/cassandra/blob/177bf5f4/src/java/org/apache/cassandra/utils/IMergeIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/IMergeIterator.java b/src/java/org/apache/cassandra/utils/IMergeIterator.java index c4cd915..deddc4c 100644 --- a/src/java/org/apache/cassandra/utils/IMergeIterator.java +++ b/src/java/org/apache/cassandra/utils/IMergeIterator.java @@ -17,7 +17,9 @@ */ package org.apache.cassandra.utils; +import java.util.Iterator; + public interface IMergeIterator<In, Out> extends CloseableIterator<Out> { - Iterable<? extends CloseableIterator<In>> iterators(); + Iterable<? extends Iterator<In>> iterators(); } http://git-wip-us.apache.org/repos/asf/cassandra/blob/177bf5f4/src/java/org/apache/cassandra/utils/MergeIterator.java ---------------------------------------------------------------------- diff --git a/src/java/org/apache/cassandra/utils/MergeIterator.java b/src/java/org/apache/cassandra/utils/MergeIterator.java index f05c14b..4c89edb 100644 --- a/src/java/org/apache/cassandra/utils/MergeIterator.java +++ b/src/java/org/apache/cassandra/utils/MergeIterator.java @@ -17,6 +17,7 @@ */ package org.apache.cassandra.utils; +import java.io.Closeable; import java.io.IOException; import java.util.*; @@ -26,15 +27,15 @@ import com.google.common.collect.AbstractIterator; public abstract class MergeIterator<In,Out> extends AbstractIterator<Out> implements IMergeIterator<In, Out> { protected final Reducer<In,Out> reducer; - protected final List<? extends CloseableIterator<In>> iterators; + protected final List<? extends Iterator<In>> iterators; - protected MergeIterator(List<? extends CloseableIterator<In>> iters, Reducer<In, Out> reducer) + protected MergeIterator(List<? extends Iterator<In>> iters, Reducer<In, Out> reducer) { this.iterators = iters; this.reducer = reducer; } - public static <In, Out> IMergeIterator<In, Out> get(final List<? extends CloseableIterator<In>> sources, + public static <In, Out> IMergeIterator<In, Out> get(final List<? extends Iterator<In>> sources, Comparator<In> comparator, final Reducer<In, Out> reducer) { @@ -45,18 +46,18 @@ public abstract class MergeIterator<In,Out> extends AbstractIterator<Out> implem return new ManyToOne<In, Out>(sources, comparator, reducer); } - public Iterable<? extends CloseableIterator<In>> iterators() + public Iterable<? extends Iterator<In>> iterators() { return iterators; } public void close() { - for (CloseableIterator<In> iterator : this.iterators) + for (Iterator<In> iterator : this.iterators) { try { - iterator.close(); + ((Closeable)iterator).close(); } catch (IOException e) { @@ -76,11 +77,11 @@ public abstract class MergeIterator<In,Out> extends AbstractIterator<Out> implem // TODO: if we had our own PriorityQueue implementation we could stash items // at the end of its array, so we wouldn't need this storage protected final ArrayDeque<Candidate<In>> candidates; - public ManyToOne(List<? extends CloseableIterator<In>> iters, Comparator<In> comp, Reducer<In,Out> reducer) + public ManyToOne(List<? extends Iterator<In>> iters, Comparator<In> comp, Reducer<In, Out> reducer) { super(iters, reducer); this.queue = new PriorityQueue<Candidate<In>>(Math.max(1, iters.size())); - for (CloseableIterator<In> iter : iters) + for (Iterator<In> iter : iters) { Candidate<In> candidate = new Candidate<In>(iter, comp); if (!candidate.advance()) @@ -127,11 +128,11 @@ public abstract class MergeIterator<In,Out> extends AbstractIterator<Out> implem // Holds and is comparable by the head item of an iterator it owns protected static final class Candidate<In> implements Comparable<Candidate<In>> { - private final CloseableIterator<In> iter; + private final Iterator<In> iter; private final Comparator<In> comp; private In item; - public Candidate(CloseableIterator<In> iter, Comparator<In> comp) + public Candidate(Iterator<In> iter, Comparator<In> comp) { this.iter = iter; this.comp = comp; @@ -186,9 +187,9 @@ public abstract class MergeIterator<In,Out> extends AbstractIterator<Out> implem private static class OneToOne<In, Out> extends MergeIterator<In, Out> { - private final CloseableIterator<In> source; + private final Iterator<In> source; - public OneToOne(List<? extends CloseableIterator<In>> sources, Reducer<In, Out> reducer) + public OneToOne(List<? extends Iterator<In>> sources, Reducer<In, Out> reducer) { super(sources, reducer); source = sources.get(0); @@ -206,9 +207,9 @@ public abstract class MergeIterator<In,Out> extends AbstractIterator<Out> implem private static class TrivialOneToOne<In, Out> extends MergeIterator<In, Out> { - private final CloseableIterator<?> source; + private final Iterator<In> source; - public TrivialOneToOne(List<? extends CloseableIterator<In>> sources, Reducer<In, Out> reducer) + public TrivialOneToOne(List<? extends Iterator<In>> sources, Reducer<In, Out> reducer) { super(sources, reducer); source = sources.get(0);
