accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ctubb...@apache.org
Subject [35/66] [abbrv] accumulo git commit: ACCUMULO-3451 Format master branch (1.7.0-SNAPSHOT)
Date Fri, 09 Jan 2015 02:44:39 GMT
http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/conf/PerColumnIteratorConfig.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/conf/PerColumnIteratorConfig.java b/core/src/main/java/org/apache/accumulo/core/iterators/conf/PerColumnIteratorConfig.java
index 1d8a1b3..310776aa 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/conf/PerColumnIteratorConfig.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/conf/PerColumnIteratorConfig.java
@@ -20,56 +20,56 @@ import org.apache.hadoop.io.Text;
 
 /**
  * @deprecated since 1.4
- * 
+ *
  * @see org.apache.accumulo.core.client.IteratorSetting.Column
  * @see org.apache.accumulo.core.iterators.Combiner#setColumns(org.apache.accumulo.core.client.IteratorSetting, java.util.List)
  */
 @Deprecated
 public class PerColumnIteratorConfig {
-  
+
   private String parameter;
   private Text colq;
   private Text colf;
-  
+
   public PerColumnIteratorConfig(Text columnFamily, String parameter) {
     this.colf = columnFamily;
     this.colq = null;
     this.parameter = parameter;
   }
-  
+
   public PerColumnIteratorConfig(Text columnFamily, Text columnQualifier, String parameter) {
     this.colf = columnFamily;
     this.colq = columnQualifier;
     this.parameter = parameter;
   }
-  
+
   public Text getColumnFamily() {
     return colf;
   }
-  
+
   public Text getColumnQualifier() {
     return colq;
   }
-  
+
   public String encodeColumns() {
     return encodeColumns(this);
   }
-  
+
   public String getClassName() {
     return parameter;
   }
-  
+
   private static String encodeColumns(PerColumnIteratorConfig pcic) {
     return ColumnSet.encodeColumns(pcic.colf, pcic.colq);
   }
-  
+
   public static String encodeColumns(Text columnFamily, Text columnQualifier) {
     return ColumnSet.encodeColumns(columnFamily, columnQualifier);
   }
 
   public static PerColumnIteratorConfig decodeColumns(String columns, String className) {
     String[] cols = columns.split(":");
-    
+
     if (cols.length == 1) {
       return new PerColumnIteratorConfig(ColumnSet.decode(cols[0]), className);
     } else if (cols.length == 2) {

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/system/ColumnFamilySkippingIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/system/ColumnFamilySkippingIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/system/ColumnFamilySkippingIterator.java
index 7df57c5..350c4cd 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/system/ColumnFamilySkippingIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/system/ColumnFamilySkippingIterator.java
@@ -33,27 +33,27 @@ import org.apache.accumulo.core.iterators.SkippingIterator;
 import org.apache.accumulo.core.iterators.SortedKeyValueIterator;
 
 public class ColumnFamilySkippingIterator extends SkippingIterator implements InterruptibleIterator {
-  
+
   protected Set<ByteSequence> colFamSet = null;
   protected TreeSet<ByteSequence> sortedColFams = null;
-  
+
   protected boolean inclusive = false;
   protected Range range;
-  
+
   public ColumnFamilySkippingIterator(SortedKeyValueIterator<Key,Value> source) {
     this.setSource(source);
   }
-  
+
   protected ColumnFamilySkippingIterator(SortedKeyValueIterator<Key,Value> source, Set<ByteSequence> colFamSet, boolean inclusive) {
     this(source);
     this.colFamSet = colFamSet;
     this.inclusive = inclusive;
   }
-  
+
   @Override
   protected void consume() throws IOException {
     int count = 0;
-    
+
     if (inclusive)
       while (getSource().hasTop() && !colFamSet.contains(getSource().getTopKey().getColumnFamilyData())) {
         if (count < 10) {
@@ -70,7 +70,7 @@ public class ColumnFamilySkippingIterator extends SkippingIterator implements In
             // seek to the next column family in the sorted list of column families
             reseek(new Key(getSource().getTopKey().getRowData().toArray(), higherCF.toArray(), new byte[0], new byte[0], Long.MAX_VALUE));
           }
-          
+
           count = 0;
         }
       }
@@ -86,7 +86,7 @@ public class ColumnFamilySkippingIterator extends SkippingIterator implements In
         }
       }
   }
-  
+
   private void reseek(Key key) throws IOException {
     if (range.afterEndKey(key)) {
       range = new Range(range.getEndKey(), true, range.getEndKey(), range.isEndKeyInclusive());
@@ -96,36 +96,36 @@ public class ColumnFamilySkippingIterator extends SkippingIterator implements In
       getSource().seek(range, colFamSet, inclusive);
     }
   }
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     return new ColumnFamilySkippingIterator(getSource().deepCopy(env), colFamSet, inclusive);
   }
-  
+
   @Override
   public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
-    
+
     if (columnFamilies instanceof Set<?>) {
       colFamSet = (Set<ByteSequence>) columnFamilies;
     } else {
       colFamSet = new HashSet<ByteSequence>();
       colFamSet.addAll(columnFamilies);
     }
-    
+
     if (inclusive) {
       sortedColFams = new TreeSet<ByteSequence>(colFamSet);
     } else {
       sortedColFams = null;
     }
-    
+
     this.range = range;
     this.inclusive = inclusive;
     super.seek(range, colFamSet, inclusive);
   }
-  
+
   @Override
   public void setInterruptFlag(AtomicBoolean flag) {
     ((InterruptibleIterator) getSource()).setInterruptFlag(flag);
   }
-  
+
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/system/ColumnQualifierFilter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/system/ColumnQualifierFilter.java b/core/src/main/java/org/apache/accumulo/core/iterators/system/ColumnQualifierFilter.java
index d5ca3b4..6e0f6e1 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/system/ColumnQualifierFilter.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/system/ColumnQualifierFilter.java
@@ -34,14 +34,14 @@ public class ColumnQualifierFilter extends Filter {
   private boolean scanColumns;
   private HashSet<ByteSequence> columnFamilies;
   private HashMap<ByteSequence,HashSet<ByteSequence>> columnsQualifiers;
-  
+
   public ColumnQualifierFilter() {}
-  
+
   public ColumnQualifierFilter(SortedKeyValueIterator<Key,Value> iterator, Set<Column> columns) {
     setSource(iterator);
     init(columns);
   }
-  
+
   public ColumnQualifierFilter(SortedKeyValueIterator<Key,Value> iterator, HashSet<ByteSequence> columnFamilies,
       HashMap<ByteSequence,HashSet<ByteSequence>> columnsQualifiers, boolean scanColumns) {
     setSource(iterator);
@@ -49,25 +49,25 @@ public class ColumnQualifierFilter extends Filter {
     this.columnsQualifiers = columnsQualifiers;
     this.scanColumns = scanColumns;
   }
-  
+
   public boolean accept(Key key, Value v) {
     if (!scanColumns)
       return true;
-    
+
     if (columnFamilies.contains(key.getColumnFamilyData()))
       return true;
-    
+
     HashSet<ByteSequence> cfset = columnsQualifiers.get(key.getColumnQualifierData());
     // ensure the columm qualifier goes with a paired column family,
     // it is possible that a column qualifier could occur with a
     // column family it was not paired with
     return cfset != null && cfset.contains(key.getColumnFamilyData());
   }
-  
+
   public void init(Set<Column> columns) {
     this.columnFamilies = new HashSet<ByteSequence>();
     this.columnsQualifiers = new HashMap<ByteSequence,HashSet<ByteSequence>>();
-    
+
     for (Iterator<Column> iter = columns.iterator(); iter.hasNext();) {
       Column col = iter.next();
       if (col.columnQualifier != null) {
@@ -77,18 +77,18 @@ public class ColumnQualifierFilter extends Filter {
           cfset = new HashSet<ByteSequence>();
           this.columnsQualifiers.put(cq, cfset);
         }
-        
+
         cfset.add(new ArrayByteSequence(col.columnFamily));
       } else {
         // this whole column family should pass
         columnFamilies.add(new ArrayByteSequence(col.columnFamily));
       }
     }
-    
+
     // only take action when column qualifies are present
     scanColumns = this.columnsQualifiers.size() > 0;
   }
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     return new ColumnQualifierFilter(getSource().deepCopy(env), columnFamilies, columnsQualifiers, scanColumns);

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/system/CountingIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/system/CountingIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/system/CountingIterator.java
index 010136a..b75ce67 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/system/CountingIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/system/CountingIterator.java
@@ -26,34 +26,34 @@ import org.apache.accumulo.core.iterators.SortedKeyValueIterator;
 import org.apache.accumulo.core.iterators.WrappingIterator;
 
 public class CountingIterator extends WrappingIterator {
-  
+
   private long count;
-  
+
   public CountingIterator deepCopy(IteratorEnvironment env) {
     return new CountingIterator(this, env);
   }
-  
+
   private CountingIterator(CountingIterator other, IteratorEnvironment env) {
     setSource(other.getSource().deepCopy(env));
     count = 0;
   }
-  
+
   public CountingIterator(SortedKeyValueIterator<Key,Value> source) {
     this.setSource(source);
     count = 0;
   }
-  
+
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) {
     throw new UnsupportedOperationException();
   }
-  
+
   @Override
   public void next() throws IOException {
     super.next();
     count++;
   }
-  
+
   public long getCount() {
     return count;
   }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/system/DeletingIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/system/DeletingIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/system/DeletingIterator.java
index e770351..1e7bd0d 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/system/DeletingIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/system/DeletingIterator.java
@@ -33,23 +33,23 @@ import org.apache.accumulo.core.iterators.WrappingIterator;
 public class DeletingIterator extends WrappingIterator {
   private boolean propogateDeletes;
   private Key workKey = new Key();
-  
+
   public DeletingIterator deepCopy(IteratorEnvironment env) {
     return new DeletingIterator(this, env);
   }
-  
+
   public DeletingIterator(DeletingIterator other, IteratorEnvironment env) {
     setSource(other.getSource().deepCopy(env));
     propogateDeletes = other.propogateDeletes;
   }
-  
+
   public DeletingIterator() {}
-  
+
   public DeletingIterator(SortedKeyValueIterator<Key,Value> iterator, boolean propogateDeletes) throws IOException {
     this.setSource(iterator);
     this.propogateDeletes = propogateDeletes;
   }
-  
+
   @Override
   public void next() throws IOException {
     if (super.getTopKey().isDeleted())
@@ -58,26 +58,26 @@ public class DeletingIterator extends WrappingIterator {
       getSource().next();
     findTop();
   }
-  
+
   @Override
   public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
     // do not want to seek to the middle of a row
     Range seekRange = IteratorUtil.maximizeStartKeyTimeStamp(range);
-    
+
     super.seek(seekRange, columnFamilies, inclusive);
     findTop();
-    
+
     if (range.getStartKey() != null) {
       while (getSource().hasTop() && getSource().getTopKey().compareTo(range.getStartKey(), PartialKey.ROW_COLFAM_COLQUAL_COLVIS_TIME) < 0) {
         next();
       }
-      
+
       while (hasTop() && range.beforeStartKey(getTopKey())) {
         next();
       }
     }
   }
-  
+
   private void findTop() throws IOException {
     if (!propogateDeletes) {
       while (getSource().hasTop() && getSource().getTopKey().isDeleted()) {
@@ -85,18 +85,18 @@ public class DeletingIterator extends WrappingIterator {
       }
     }
   }
-  
+
   private void skipRowColumn() throws IOException {
     workKey.set(getSource().getTopKey());
-    
+
     Key keyToSkip = workKey;
     getSource().next();
-    
+
     while (getSource().hasTop() && getSource().getTopKey().equals(keyToSkip, PartialKey.ROW_COLFAM_COLQUAL_COLVIS)) {
       getSource().next();
     }
   }
-  
+
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) {
     throw new UnsupportedOperationException();

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/system/LocalityGroupIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/system/LocalityGroupIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/system/LocalityGroupIterator.java
index 71d2d8b..b2fae6d 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/system/LocalityGroupIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/system/LocalityGroupIterator.java
@@ -34,7 +34,7 @@ import org.apache.accumulo.core.iterators.SortedKeyValueIterator;
 import org.apache.commons.lang.mutable.MutableLong;
 
 /**
- * 
+ *
  */
 public class LocalityGroupIterator extends HeapIterator implements InterruptibleIterator {
 
@@ -45,12 +45,12 @@ public class LocalityGroupIterator extends HeapIterator implements Interruptible
       this(localityGroup.columnFamilies, localityGroup.isDefaultLocalityGroup);
       this.iterator = (InterruptibleIterator) localityGroup.iterator.deepCopy(env);
     }
-    
+
     public LocalityGroup(InterruptibleIterator iterator, Map<ByteSequence,MutableLong> columnFamilies, boolean isDefaultLocalityGroup) {
       this(columnFamilies, isDefaultLocalityGroup);
       this.iterator = iterator;
     }
-    
+
     public LocalityGroup(Map<ByteSequence,MutableLong> columnFamilies, boolean isDefaultLocalityGroup) {
       this.isDefaultLocalityGroup = isDefaultLocalityGroup;
       this.columnFamilies = columnFamilies;
@@ -64,7 +64,7 @@ public class LocalityGroupIterator extends HeapIterator implements Interruptible
     protected Map<ByteSequence,MutableLong> columnFamilies;
     private InterruptibleIterator iterator;
   }
-  
+
   private LocalityGroup groups[];
   private Set<ByteSequence> nonDefaultColumnFamilies;
   private AtomicBoolean interruptFlag;
@@ -79,13 +79,13 @@ public class LocalityGroupIterator extends HeapIterator implements Interruptible
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
     throw new UnsupportedOperationException();
   }
-  
+
   public static final int seek(HeapIterator hiter, LocalityGroup[] groups, Set<ByteSequence> nonDefaultColumnFamilies, Range range,
       Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
     hiter.clear();
-    
+
     int numLGSeeked = 0;
-    
+
     Set<ByteSequence> cfSet;
     if (columnFamilies.size() > 0)
       if (columnFamilies instanceof Set<?>) {
@@ -101,13 +101,13 @@ public class LocalityGroupIterator extends HeapIterator implements Interruptible
       // when include is set to true it means this locality groups contains
       // wanted column families
       boolean include = false;
-      
+
       if (cfSet.size() == 0) {
         include = !inclusive;
       } else if (lgr.isDefaultLocalityGroup && lgr.columnFamilies == null) {
         // do not know what column families are in the default locality group,
         // only know what column families are not in it
-        
+
         if (inclusive) {
           if (!nonDefaultColumnFamilies.containsAll(cfSet)) {
             // default LG may contain wanted and unwanted column families
@@ -123,7 +123,7 @@ public class LocalityGroupIterator extends HeapIterator implements Interruptible
          * Need to consider the following cases for inclusive and exclusive (lgcf:locality group column family set, cf:column family set) lgcf and cf are
          * disjoint lgcf and cf are the same cf contains lgcf lgcf contains cf lgccf and cf intersect but neither is a subset of the other
          */
-        
+
         for (Entry<ByteSequence,MutableLong> entry : lgr.columnFamilies.entrySet())
           if (entry.getValue().longValue() > 0)
             if (cfSet.contains(entry.getKey())) {
@@ -140,7 +140,7 @@ public class LocalityGroupIterator extends HeapIterator implements Interruptible
         numLGSeeked++;
       }// every column family is excluded, zero count, or not present
     }
-    
+
     return numLGSeeked;
   }
 
@@ -152,16 +152,16 @@ public class LocalityGroupIterator extends HeapIterator implements Interruptible
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     LocalityGroup[] groupsCopy = new LocalityGroup[groups.length];
-    
+
     for (int i = 0; i < groups.length; i++) {
       groupsCopy[i] = new LocalityGroup(groups[i], env);
       if (interruptFlag != null)
         groupsCopy[i].getIterator().setInterruptFlag(interruptFlag);
     }
-    
+
     return new LocalityGroupIterator(groupsCopy, nonDefaultColumnFamilies);
   }
-  
+
   @Override
   public void setInterruptFlag(AtomicBoolean flag) {
     this.interruptFlag = flag;
@@ -169,5 +169,5 @@ public class LocalityGroupIterator extends HeapIterator implements Interruptible
       lgr.getIterator().setInterruptFlag(flag);
     }
   }
-  
+
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/system/MapFileIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/system/MapFileIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/system/MapFileIterator.java
index 37a234c..b9a4e31 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/system/MapFileIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/system/MapFileIterator.java
@@ -49,7 +49,7 @@ public class MapFileIterator implements FileSKVIterator {
   private int interruptCheckCount = 0;
   private FileSystem fs;
   private String dirName;
-  
+
   public MapFileIterator(AccumuloConfiguration acuconf, FileSystem fs, String dir, Configuration conf) throws IOException {
     this.reader = MapFileUtil.openMapFile(acuconf, fs, dir, conf);
     this.fs = fs;
@@ -60,59 +60,59 @@ public class MapFileIterator implements FileSKVIterator {
   public void setInterruptFlag(AtomicBoolean flag) {
     this.interruptFlag = flag;
   }
-  
+
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
     throw new UnsupportedOperationException();
   }
-  
+
   @Override
   public boolean hasTop() {
     return topKey != null;
   }
-  
+
   @Override
   public void next() throws IOException {
     if (interruptFlag != null && interruptCheckCount++ % 100 == 0 && interruptFlag.get())
       throw new IterationInterruptedException();
-    
+
     reader.next(topKey, topValue);
   }
-  
+
   @Override
   public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
     if (columnFamilies.size() != 0 || inclusive) {
       throw new IllegalArgumentException("I do not know how to filter column families");
     }
-    
+
     if (range == null)
       throw new IllegalArgumentException("Cannot seek to null range");
-    
+
     if (interruptFlag != null && interruptFlag.get())
       throw new IterationInterruptedException();
-    
+
     Key key = range.getStartKey();
     if (key == null) {
       key = new Key();
     }
-    
+
     reader.seek(key);
-    
+
     while (hasTop() && range.beforeStartKey(getTopKey())) {
       next();
     }
   }
-  
+
   @Override
   public Key getTopKey() {
     return topKey;
   }
-  
+
   @Override
   public Value getTopValue() {
     return topValue;
   }
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     try {
@@ -125,17 +125,17 @@ public class MapFileIterator implements FileSKVIterator {
       throw new RuntimeException(e);
     }
   }
-  
+
   @Override
   public Key getFirstKey() throws IOException {
     throw new UnsupportedOperationException();
   }
-  
+
   @Override
   public Key getLastKey() throws IOException {
     throw new UnsupportedOperationException();
   }
-  
+
   @Override
   public DataInputStream getMetaStore(String name) throws IOException {
     Path path = new Path(this.dirName, name);
@@ -143,12 +143,12 @@ public class MapFileIterator implements FileSKVIterator {
       throw new NoSuchMetaStoreException("name = " + name);
     return fs.open(path);
   }
-  
+
   @Override
   public void closeDeepCopies() throws IOException {
     // nothing to do, deep copies are externally managed/closed
   }
-  
+
   @Override
   public void close() throws IOException {
     reader.close();

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/system/MultiIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/system/MultiIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/system/MultiIterator.java
index f406fee..26ad8e9 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/system/MultiIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/system/MultiIterator.java
@@ -32,21 +32,21 @@ import org.apache.accumulo.core.iterators.SortedKeyValueIterator;
 
 /**
  * An iterator capable of iterating over other iterators in sorted order.
- * 
- * 
- * 
+ *
+ *
+ *
  */
 
 public class MultiIterator extends HeapIterator {
-  
+
   private List<SortedKeyValueIterator<Key,Value>> iters;
   private Range fence;
-  
+
   // deep copy with no seek/scan state
   public MultiIterator deepCopy(IteratorEnvironment env) {
     return new MultiIterator(this, env);
   }
-  
+
   private MultiIterator(MultiIterator other, IteratorEnvironment env) {
     super(other.iters.size());
     this.iters = new ArrayList<SortedKeyValueIterator<Key,Value>>();
@@ -55,58 +55,58 @@ public class MultiIterator extends HeapIterator {
       iters.add(iter.deepCopy(env));
     }
   }
-  
+
   private void init() {
     for (SortedKeyValueIterator<Key,Value> skvi : iters)
       addSource(skvi);
   }
-  
+
   private MultiIterator(List<SortedKeyValueIterator<Key,Value>> iters, Range seekFence, boolean init) {
     super(iters.size());
-    
+
     if (seekFence != null && init) {
       // throw this exception because multi-iterator does not seek on init, therefore the
       // fence would not be enforced in anyway, so do not want to give the impression it
       // will enforce this
       throw new IllegalArgumentException("Initializing not supported when seek fence set");
     }
-    
+
     this.fence = seekFence;
     this.iters = iters;
-    
+
     if (init) {
       init();
     }
   }
-  
+
   public MultiIterator(List<SortedKeyValueIterator<Key,Value>> iters, Range seekFence) {
     this(iters, seekFence, false);
   }
-  
+
   public MultiIterator(List<SortedKeyValueIterator<Key,Value>> iters2, KeyExtent extent) {
     this(iters2, new Range(extent.getPrevEndRow(), false, extent.getEndRow(), true), false);
   }
-  
+
   public MultiIterator(List<SortedKeyValueIterator<Key,Value>> readers, boolean init) {
     this(readers, (Range) null, init);
   }
-  
+
   @Override
   public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
     clear();
-    
+
     if (fence != null) {
       range = fence.clip(range, true);
       if (range == null)
         return;
     }
-    
+
     for (SortedKeyValueIterator<Key,Value> skvi : iters) {
       skvi.seek(range, columnFamilies, inclusive);
       addSource(skvi);
     }
   }
-  
+
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
     throw new UnsupportedOperationException();

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/system/SequenceFileIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/system/SequenceFileIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/system/SequenceFileIterator.java
index f593ee2..266b638 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/system/SequenceFileIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/system/SequenceFileIterator.java
@@ -33,89 +33,89 @@ import org.apache.hadoop.io.SequenceFile;
 import org.apache.hadoop.io.SequenceFile.Reader;
 
 public class SequenceFileIterator implements FileSKVIterator {
-  
+
   private Reader reader;
   private Value top_value;
   private Key top_key;
   private boolean readValue;
-  
+
   public SequenceFileIterator deepCopy(IteratorEnvironment env) {
     throw new UnsupportedOperationException("SequenceFileIterator does not yet support cloning");
   }
-  
+
   @Override
   public void closeDeepCopies() throws IOException {
     throw new UnsupportedOperationException();
   }
-  
+
   public SequenceFileIterator(SequenceFile.Reader reader, boolean readValue) throws IOException {
     this.reader = reader;
     this.readValue = readValue;
-    
+
     top_key = new Key();
-    
+
     if (readValue)
       top_value = new Value();
-    
+
     next();
   }
-  
+
   public Key getTopKey() {
     return top_key;
   }
-  
+
   public Value getTopValue() {
     return top_value;
   }
-  
+
   public boolean hasTop() {
     return top_key != null;
   }
-  
+
   public void next() throws IOException {
     boolean valid;
     if (readValue)
       valid = reader.next(top_key, top_value);
     else
       valid = reader.next(top_key);
-    
+
     if (!valid) {
       top_key = null;
       top_value = null;
     }
-    
+
   }
-  
+
   @Override
   public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
     throw new UnsupportedOperationException("seek() not supported");
   }
-  
+
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
     throw new UnsupportedOperationException();
-    
+
   }
-  
+
   @Override
   public void close() throws IOException {
     reader.close();
   }
-  
+
   @Override
   public Key getFirstKey() throws IOException {
     throw new UnsupportedOperationException("getFirstKey() not supported");
   }
-  
+
   @Override
   public Key getLastKey() throws IOException {
     throw new UnsupportedOperationException("getLastKey() not supported");
   }
-  
+
   @Override
   public DataInputStream getMetaStore(String name) throws IOException {
     throw new UnsupportedOperationException();
   }
-  
+
   @Override
   public void setInterruptFlag(AtomicBoolean flag) {
     throw new UnsupportedOperationException();

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/system/StatsIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/system/StatsIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/system/StatsIterator.java
index 1f23577..f92d1ec 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/system/StatsIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/system/StatsIterator.java
@@ -29,36 +29,36 @@ import org.apache.accumulo.core.iterators.SortedKeyValueIterator;
 import org.apache.accumulo.core.iterators.WrappingIterator;
 
 /**
- * 
+ *
  */
 public class StatsIterator extends WrappingIterator {
-  
+
   private int numRead = 0;
   private AtomicLong seekCounter;
   private AtomicLong readCounter;
-  
+
   public StatsIterator(SortedKeyValueIterator<Key,Value> source, AtomicLong seekCounter, AtomicLong readCounter) {
     super.setSource(source);
     this.seekCounter = seekCounter;
     this.readCounter = readCounter;
   }
-  
+
   @Override
   public void next() throws IOException {
     super.next();
     numRead++;
-    
+
     if (numRead % 23 == 0) {
       readCounter.addAndGet(numRead);
       numRead = 0;
     }
   }
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     return new StatsIterator(getSource().deepCopy(env), seekCounter, readCounter);
   }
-  
+
   @Override
   public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
     super.seek(range, columnFamilies, inclusive);
@@ -66,7 +66,7 @@ public class StatsIterator extends WrappingIterator {
     readCounter.addAndGet(numRead);
     numRead = 0;
   }
-  
+
   public void report() {
     readCounter.addAndGet(numRead);
     numRead = 0;

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/system/TimeSettingIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/system/TimeSettingIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/system/TimeSettingIterator.java
index 4eef14d..3e1b7a9 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/system/TimeSettingIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/system/TimeSettingIterator.java
@@ -30,48 +30,48 @@ import org.apache.accumulo.core.iterators.IteratorUtil;
 import org.apache.accumulo.core.iterators.SortedKeyValueIterator;
 
 public class TimeSettingIterator implements InterruptibleIterator {
-  
+
   private SortedKeyValueIterator<Key,Value> source;
   private long time;
   private Range range;
-  
+
   public TimeSettingIterator(SortedKeyValueIterator<Key,Value> source, long time) {
     this.source = source;
     this.time = time;
   }
-  
+
   @Override
   public Key getTopKey() {
     Key key = new Key(source.getTopKey());
     key.setTimestamp(time);
     return key;
   }
-  
+
   @Override
   public void setInterruptFlag(AtomicBoolean flag) {
     ((InterruptibleIterator) source).setInterruptFlag(flag);
   }
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     return new TimeSettingIterator(source.deepCopy(env), time);
   }
-  
+
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
-    
+
   }
-  
+
   @Override
   public boolean hasTop() {
     return source.hasTop() && !range.afterEndKey(getTopKey());
   }
-  
+
   @Override
   public void next() throws IOException {
     source.next();
   }
-  
+
   @Override
   public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
     Range seekRange = IteratorUtil.maximizeStartKeyTimeStamp(range);
@@ -81,12 +81,12 @@ public class TimeSettingIterator implements InterruptibleIterator {
     while (hasTop() && range.beforeStartKey(getTopKey())) {
       next();
     }
-    
+
   }
-  
+
   @Override
   public Value getTopValue() {
     return source.getTopValue();
   }
-  
+
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/system/VisibilityFilter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/system/VisibilityFilter.java b/core/src/main/java/org/apache/accumulo/core/iterators/system/VisibilityFilter.java
index 15c33fa..4bbd819 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/system/VisibilityFilter.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/system/VisibilityFilter.java
@@ -37,11 +37,11 @@ public class VisibilityFilter extends Filter {
   protected LRUMap cache;
   protected Text tmpVis;
   protected Authorizations authorizations;
-  
+
   private static final Logger log = Logger.getLogger(VisibilityFilter.class);
-  
+
   public VisibilityFilter() {}
-  
+
   public VisibilityFilter(SortedKeyValueIterator<Key,Value> iterator, Authorizations authorizations, byte[] defaultVisibility) {
     setSource(iterator);
     this.ve = new VisibilityEvaluator(authorizations);
@@ -50,25 +50,25 @@ public class VisibilityFilter extends Filter {
     this.cache = new LRUMap(1000);
     this.tmpVis = new Text();
   }
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     return new VisibilityFilter(getSource().deepCopy(env), authorizations, TextUtil.getBytes(defaultVisibility));
   }
-  
+
   @Override
   public boolean accept(Key k, Value v) {
     Text testVis = k.getColumnVisibility(tmpVis);
-    
+
     if (testVis.getLength() == 0 && defaultVisibility.getLength() == 0)
       return true;
     else if (testVis.getLength() == 0)
       testVis = defaultVisibility;
-    
+
     Boolean b = (Boolean) cache.get(testVis);
     if (b != null)
       return b;
-    
+
     try {
       Boolean bb = ve.evaluate(new ColumnVisibility(testVis));
       cache.put(new Text(testVis), bb);

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/user/AgeOffFilter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/AgeOffFilter.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/AgeOffFilter.java
index 6e9a571..705f990 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/AgeOffFilter.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/AgeOffFilter.java
@@ -28,7 +28,7 @@ import org.apache.accumulo.core.iterators.SortedKeyValueIterator;
 
 /**
  * A filter that ages off key/value pairs based on the Key's timestamp. It removes an entry if its timestamp is less than currentTime - threshold.
- * 
+ *
  * This filter requires a "ttl" option, in milliseconds, to determine the age off threshold.
  */
 public class AgeOffFilter extends Filter {
@@ -36,10 +36,10 @@ public class AgeOffFilter extends Filter {
   private static final String CURRENT_TIME = "currentTime";
   private long threshold;
   private long currentTime;
-  
+
   /**
    * Accepts entries whose timestamps are less than currentTime - threshold.
-   * 
+   *
    * @see org.apache.accumulo.core.iterators.Filter#accept(org.apache.accumulo.core.data.Key, org.apache.accumulo.core.data.Value)
    */
   @Override
@@ -48,29 +48,29 @@ public class AgeOffFilter extends Filter {
       return false;
     return true;
   }
-  
+
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
     if (options == null)
       throw new IllegalArgumentException(TTL + " must be set for AgeOffFilter");
-    
+
     String ttl = options.get(TTL);
     if (ttl == null)
       throw new IllegalArgumentException(TTL + " must be set for AgeOffFilter");
-    
+
     super.init(source, options, env);
     threshold = -1;
     threshold = Long.parseLong(ttl);
-    
+
     String time = options.get(CURRENT_TIME);
     if (time != null)
       currentTime = Long.parseLong(time);
     else
       currentTime = System.currentTimeMillis();
-    
+
     // add sanity checks for threshold and currentTime?
   }
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     AgeOffFilter copy = (AgeOffFilter) super.deepCopy(env);
@@ -78,7 +78,7 @@ public class AgeOffFilter extends Filter {
     copy.threshold = threshold;
     return copy;
   }
-  
+
   @Override
   public IteratorOptions describeOptions() {
     IteratorOptions io = super.describeOptions();
@@ -88,7 +88,7 @@ public class AgeOffFilter extends Filter {
     io.setDescription("AgeOffFilter removes entries with timestamps more than <ttl> milliseconds old");
     return io;
   }
-  
+
   @Override
   public boolean validateOptions(Map<String,String> options) {
     if (super.validateOptions(options) == false)
@@ -100,10 +100,10 @@ public class AgeOffFilter extends Filter {
     }
     return true;
   }
-  
+
   /**
    * A convenience method for setting the age off threshold.
-   * 
+   *
    * @param is
    *          IteratorSetting object to configure.
    * @param ttl
@@ -112,10 +112,10 @@ public class AgeOffFilter extends Filter {
   public static void setTTL(IteratorSetting is, Long ttl) {
     is.addOption(TTL, Long.toString(ttl));
   }
-  
+
   /**
    * A convenience method for setting the current time (from which to measure the age off threshold).
-   * 
+   *
    * @param is
    *          IteratorSetting object to configure.
    * @param currentTime

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/user/BigDecimalCombiner.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/BigDecimalCombiner.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/BigDecimalCombiner.java
index a9cd774..86c9e73 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/BigDecimalCombiner.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/BigDecimalCombiner.java
@@ -31,18 +31,17 @@ import org.apache.accumulo.core.iterators.TypedValueCombiner;
 import org.apache.accumulo.core.iterators.ValueFormatException;
 
 /**
- * A family of combiners that treat values as BigDecimals, encoding and 
- * decoding using the built-in BigDecimal String input/output functions.
+ * A family of combiners that treat values as BigDecimals, encoding and decoding using the built-in BigDecimal String input/output functions.
  */
 public abstract class BigDecimalCombiner extends TypedValueCombiner<BigDecimal> {
   private final static BigDecimalEncoder BDE = new BigDecimalEncoder();
-  
+
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
     super.init(source, options, env);
     setEncoder(BDE);
   }
-  
+
   @Override
   public IteratorOptions describeOptions() {
     IteratorOptions io = super.describeOptions();
@@ -50,14 +49,14 @@ public abstract class BigDecimalCombiner extends TypedValueCombiner<BigDecimal>
     io.setDescription("bigdecimalcombiner interprets Values as BigDecimals before combining");
     return io;
   }
-  
+
   @Override
   public boolean validateOptions(Map<String,String> options) {
     if (super.validateOptions(options) == false)
       return false;
     return true;
   }
-  
+
   public static class BigDecimalSummingCombiner extends BigDecimalCombiner {
     @Override
     public BigDecimal typedReduce(Key key, Iterator<BigDecimal> iter) {
@@ -70,7 +69,7 @@ public abstract class BigDecimalCombiner extends TypedValueCombiner<BigDecimal>
       return sum;
     }
   }
-  
+
   public static class BigDecimalMaxCombiner extends BigDecimalCombiner {
     @Override
     public BigDecimal typedReduce(Key key, Iterator<BigDecimal> iter) {
@@ -83,7 +82,7 @@ public abstract class BigDecimalCombiner extends TypedValueCombiner<BigDecimal>
       return max;
     }
   }
-  
+
   public static class BigDecimalMinCombiner extends BigDecimalCombiner {
     @Override
     public BigDecimal typedReduce(Key key, Iterator<BigDecimal> iter) {
@@ -96,17 +95,17 @@ public abstract class BigDecimalCombiner extends TypedValueCombiner<BigDecimal>
       return min;
     }
   }
-  
+
   /**
    * Provides the ability to encode scientific notation.
-   * 
+   *
    */
   public static class BigDecimalEncoder implements org.apache.accumulo.core.iterators.TypedValueCombiner.Encoder<BigDecimal> {
     @Override
     public byte[] encode(BigDecimal v) {
       return v.toString().getBytes(UTF_8);
     }
-    
+
     @Override
     public BigDecimal decode(byte[] b) throws ValueFormatException {
       try {

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/user/ColumnAgeOffFilter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/ColumnAgeOffFilter.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/ColumnAgeOffFilter.java
index 51e9ed3..c3da5c1 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/ColumnAgeOffFilter.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/ColumnAgeOffFilter.java
@@ -39,14 +39,14 @@ public class ColumnAgeOffFilter extends Filter {
   public static class TTLSet extends ColumnToClassMapping<Long> {
     public TTLSet(Map<String,String> objectStrings) {
       super();
-      
+
       for (Entry<String,String> entry : objectStrings.entrySet()) {
         String column = entry.getKey();
         String ttl = entry.getValue();
         Long l = Long.parseLong(ttl);
-        
+
         Pair<Text,Text> colPair = ColumnSet.decodeColumns(column);
-        
+
         if (colPair.getSecond() == null) {
           addObject(colPair.getFirst(), l);
         } else {
@@ -55,10 +55,10 @@ public class ColumnAgeOffFilter extends Filter {
       }
     }
   }
-  
+
   TTLSet ttls;
   long currentTime = 0;
-  
+
   @Override
   public boolean accept(Key k, Value v) {
     Long threshold = ttls.getObject(k);
@@ -68,14 +68,14 @@ public class ColumnAgeOffFilter extends Filter {
       return false;
     return true;
   }
-  
+
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
     super.init(source, options, env);
     this.ttls = new TTLSet(options);
     currentTime = System.currentTimeMillis();
   }
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     ColumnAgeOffFilter copy = (ColumnAgeOffFilter) super.deepCopy(env);
@@ -83,11 +83,11 @@ public class ColumnAgeOffFilter extends Filter {
     copy.ttls = ttls;
     return copy;
   }
-  
+
   public void overrideCurrentTime(long ts) {
     this.currentTime = ts;
   }
-  
+
   @Override
   public IteratorOptions describeOptions() {
     IteratorOptions io = super.describeOptions();
@@ -96,7 +96,7 @@ public class ColumnAgeOffFilter extends Filter {
     io.addUnnamedOption("<col fam>[:<col qual>] <Long> (escape non-alphanum chars using %<hex>)");
     return io;
   }
-  
+
   @Override
   public boolean validateOptions(Map<String,String> options) {
     if (super.validateOptions(options) == false)
@@ -108,10 +108,10 @@ public class ColumnAgeOffFilter extends Filter {
     }
     return true;
   }
-  
+
   /**
    * A convenience method for adding or changing an age off threshold for a column.
-   * 
+   *
    * @param is
    *          IteratorSetting object to configure.
    * @param column
@@ -122,10 +122,10 @@ public class ColumnAgeOffFilter extends Filter {
   public static void addTTL(IteratorSetting is, IteratorSetting.Column column, Long ttl) {
     is.addOption(ColumnSet.encodeColumns(column.getFirst(), column.getSecond()), Long.toString(ttl));
   }
-  
+
   /**
    * A convenience method for removing an age off threshold for a column.
-   * 
+   *
    * @param is
    *          IteratorSetting object to configure.
    * @param column

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/user/ColumnSliceFilter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/ColumnSliceFilter.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/ColumnSliceFilter.java
index 5dfcd17..5de72d5 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/ColumnSliceFilter.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/ColumnSliceFilter.java
@@ -16,6 +16,9 @@
  */
 package org.apache.accumulo.core.iterators.user;
 
+import java.io.IOException;
+import java.util.Map;
+
 import org.apache.accumulo.core.client.IteratorSetting;
 import org.apache.accumulo.core.data.Key;
 import org.apache.accumulo.core.data.Value;
@@ -23,93 +26,90 @@ import org.apache.accumulo.core.iterators.Filter;
 import org.apache.accumulo.core.iterators.IteratorEnvironment;
 import org.apache.accumulo.core.iterators.SortedKeyValueIterator;
 
-import java.io.IOException;
-import java.util.Map;
-
 public class ColumnSliceFilter extends Filter {
-    public static final String START_BOUND = "startBound";
-    public static final String START_INCLUSIVE = "startInclusive";
-    public static final String END_BOUND = "endBound";
-    public static final String END_INCLUSIVE = "endInclusive";
+  public static final String START_BOUND = "startBound";
+  public static final String START_INCLUSIVE = "startInclusive";
+  public static final String END_BOUND = "endBound";
+  public static final String END_INCLUSIVE = "endInclusive";
 
-    private String startBound;
-    private String endBound;
-    private boolean startInclusive;
-    private boolean endInclusive;
+  private String startBound;
+  private String endBound;
+  private boolean startInclusive;
+  private boolean endInclusive;
 
-    @Override
-    public boolean accept(Key key, Value value) {
-        String colQ = key.getColumnQualifier().toString();
-        return (startBound == null || (startInclusive ? (colQ.compareTo(startBound) >= 0) : (colQ.compareTo(startBound) > 0)))
-                && (endBound == null || (endInclusive ? (colQ.compareTo(endBound) <= 0) : (colQ.compareTo(endBound) < 0)));
-    }
+  @Override
+  public boolean accept(Key key, Value value) {
+    String colQ = key.getColumnQualifier().toString();
+    return (startBound == null || (startInclusive ? (colQ.compareTo(startBound) >= 0) : (colQ.compareTo(startBound) > 0)))
+        && (endBound == null || (endInclusive ? (colQ.compareTo(endBound) <= 0) : (colQ.compareTo(endBound) < 0)));
+  }
 
-    @Override
-    public void init(SortedKeyValueIterator<Key, Value> source, Map<String, String> options, IteratorEnvironment env) throws IOException {
-        super.init(source, options, env);
-        if (options.containsKey(START_BOUND)) {
-            startBound = options.get(START_BOUND);
-        } else {
-            startBound = null;
-        }
-
-        if (options.containsKey(START_INCLUSIVE)) {
-            startInclusive = Boolean.parseBoolean(options.get(START_INCLUSIVE));
-        } else {
-            startInclusive = true;
-        }
-
-        if (options.containsKey(END_BOUND)) {
-            endBound = options.get(END_BOUND);
-        } else {
-            endBound = null;
-        }
+  @Override
+  public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
+    super.init(source, options, env);
+    if (options.containsKey(START_BOUND)) {
+      startBound = options.get(START_BOUND);
+    } else {
+      startBound = null;
+    }
 
-        if (options.containsKey(END_INCLUSIVE)) {
-            endInclusive = Boolean.parseBoolean(options.get(END_INCLUSIVE));
-        } else {
-            endInclusive = false;
-        }
+    if (options.containsKey(START_INCLUSIVE)) {
+      startInclusive = Boolean.parseBoolean(options.get(START_INCLUSIVE));
+    } else {
+      startInclusive = true;
     }
 
-    @Override
-    public IteratorOptions describeOptions() {
-        IteratorOptions io = super.describeOptions();
-        io.setName("columnSlice");
-        io.setDescription("The ColumnSliceFilter/Iterator allows you to filter for key/value pairs based on a lexicographic range of column qualifier names");
-        io.addNamedOption(START_BOUND, "start string in slice");
-        io.addNamedOption(END_BOUND, "end string in slice");
-        io.addNamedOption(START_INCLUSIVE, "include the start bound in the result set");
-        io.addNamedOption(END_INCLUSIVE, "include the end bound in the result set");
-        return io;
+    if (options.containsKey(END_BOUND)) {
+      endBound = options.get(END_BOUND);
+    } else {
+      endBound = null;
     }
 
-    public static void setSlice(IteratorSetting si, String start, String end) {
-        setSlice(si, start, true, end, false);
+    if (options.containsKey(END_INCLUSIVE)) {
+      endInclusive = Boolean.parseBoolean(options.get(END_INCLUSIVE));
+    } else {
+      endInclusive = false;
     }
+  }
 
-    public static void setSlice(IteratorSetting si, String start, boolean startInclusive, String end, boolean endInclusive) {
-        if (start != null && end != null && (start.compareTo(end) > 0 || (start.compareTo(end) == 0 && (!startInclusive || !endInclusive)))) {
-            throw new IllegalArgumentException("Start key must be less than end key or equal with both sides inclusive in range (" + start + ", " + end + ")");
-        }
+  @Override
+  public IteratorOptions describeOptions() {
+    IteratorOptions io = super.describeOptions();
+    io.setName("columnSlice");
+    io.setDescription("The ColumnSliceFilter/Iterator allows you to filter for key/value pairs based on a lexicographic range of column qualifier names");
+    io.addNamedOption(START_BOUND, "start string in slice");
+    io.addNamedOption(END_BOUND, "end string in slice");
+    io.addNamedOption(START_INCLUSIVE, "include the start bound in the result set");
+    io.addNamedOption(END_INCLUSIVE, "include the end bound in the result set");
+    return io;
+  }
 
-        if (start != null) {
-            si.addOption(START_BOUND, start);
-        }
-        if (end != null) {
-            si.addOption(END_BOUND, end);
-        }
-        si.addOption(START_INCLUSIVE, String.valueOf(startInclusive));
-        si.addOption(END_INCLUSIVE, String.valueOf(endInclusive));
+  public static void setSlice(IteratorSetting si, String start, String end) {
+    setSlice(si, start, true, end, false);
+  }
+
+  public static void setSlice(IteratorSetting si, String start, boolean startInclusive, String end, boolean endInclusive) {
+    if (start != null && end != null && (start.compareTo(end) > 0 || (start.compareTo(end) == 0 && (!startInclusive || !endInclusive)))) {
+      throw new IllegalArgumentException("Start key must be less than end key or equal with both sides inclusive in range (" + start + ", " + end + ")");
     }
 
-    @Override
-    public SortedKeyValueIterator<Key, Value> deepCopy(IteratorEnvironment env) {
-        ColumnSliceFilter result = (ColumnSliceFilter) super.deepCopy(env);
-        result.startBound = startBound;
-        result.startInclusive = startInclusive;
-        result.endBound = endBound;
-        result.endInclusive = endInclusive;
-        return result;
+    if (start != null) {
+      si.addOption(START_BOUND, start);
+    }
+    if (end != null) {
+      si.addOption(END_BOUND, end);
     }
+    si.addOption(START_INCLUSIVE, String.valueOf(startInclusive));
+    si.addOption(END_INCLUSIVE, String.valueOf(endInclusive));
+  }
+
+  @Override
+  public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
+    ColumnSliceFilter result = (ColumnSliceFilter) super.deepCopy(env);
+    result.startBound = startBound;
+    result.startInclusive = startInclusive;
+    result.endBound = endBound;
+    result.endInclusive = endInclusive;
+    return result;
+  }
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/user/GrepIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/GrepIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/GrepIterator.java
index e859363..043a729 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/GrepIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/GrepIterator.java
@@ -34,43 +34,43 @@ import org.apache.accumulo.core.iterators.SortedKeyValueIterator;
  * This iterator provides exact string matching. It searches both the Key and Value for the string. The string to match is specified by the "term" option.
  */
 public class GrepIterator extends Filter {
-  
+
   private byte term[];
-  
+
   @Override
   public boolean accept(Key k, Value v) {
     return match(v.get()) || match(k.getRowData()) || match(k.getColumnFamilyData()) || match(k.getColumnQualifierData());
   }
-  
+
   private boolean match(ByteSequence bs) {
     return indexOf(bs.getBackingArray(), bs.offset(), bs.length(), term) >= 0;
   }
-  
+
   private boolean match(byte[] ba) {
     return indexOf(ba, 0, ba.length, term) >= 0;
   }
-  
+
   // copied code below from java string and modified
-  
+
   private static int indexOf(byte[] source, int sourceOffset, int sourceCount, byte[] target) {
     byte first = target[0];
     int targetCount = target.length;
     int max = sourceOffset + (sourceCount - targetCount);
-    
+
     for (int i = sourceOffset; i <= max; i++) {
       /* Look for first character. */
       if (source[i] != first) {
         while (++i <= max && source[i] != first)
           continue;
       }
-      
+
       /* Found first character, now look at the rest of v2 */
       if (i <= max) {
         int j = i + 1;
         int end = j + targetCount - 1;
         for (int k = 1; j < end && source[j] == target[k]; j++, k++)
           continue;
-        
+
         if (j == end) {
           /* Found whole string. */
           return i - sourceOffset;
@@ -79,20 +79,20 @@ public class GrepIterator extends Filter {
     }
     return -1;
   }
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     GrepIterator copy = (GrepIterator) super.deepCopy(env);
     copy.term = Arrays.copyOf(term, term.length);
     return copy;
   }
-  
+
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
     super.init(source, options, env);
     term = options.get("term").getBytes(UTF_8);
   }
-  
+
   /**
    * Encode the grep term as an option for a ScanIterator
    */

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/user/IndexedDocIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/IndexedDocIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/IndexedDocIterator.java
index 2e9f049..9ef2bf6 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/IndexedDocIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/IndexedDocIterator.java
@@ -40,37 +40,37 @@ import org.slf4j.LoggerFactory;
  * docID. As with the IntersectingIterator, documents are grouped together and indexed into a single row of an Accumulo table. This allows a tablet server to
  * perform boolean AND operations on terms in the index. This iterator also stores the document contents in a separate column family in the same row so that the
  * full document can be returned with each query.
- * 
+ *
  * The table structure should have the following form:
- * 
+ *
  * row: shardID, colfam: docColf\0doctype, colqual: docID, value: doc
- * 
+ *
  * row: shardID, colfam: indexColf, colqual: term\0doctype\0docID\0info, value: (empty)
- * 
+ *
  * When you configure this iterator with a set of terms, it will return only the docIDs and docs that appear with all of the specified terms. The result will
  * have the following form:
- * 
+ *
  * row: shardID, colfam: indexColf, colqual: doctype\0docID\0info, value: doc
- * 
+ *
  * This iterator is commonly used with BatchScanner or AccumuloInputFormat, to parallelize the search over all shardIDs.
  */
 public class IndexedDocIterator extends IntersectingIterator {
   private static final Logger log = LoggerFactory.getLogger(IndexedDocIterator.class);
   public static final Text DEFAULT_INDEX_COLF = new Text("i");
   public static final Text DEFAULT_DOC_COLF = new Text("e");
-  
+
   private static final String indexFamilyOptionName = "indexFamily";
   private static final String docFamilyOptionName = "docFamily";
-  
+
   private Text indexColf = DEFAULT_INDEX_COLF;
   private Text docColf = DEFAULT_DOC_COLF;
   private Set<ByteSequence> indexColfSet;
   private Set<ByteSequence> docColfSet;
-  
+
   private static final byte[] nullByte = {0};
-  
+
   public SortedKeyValueIterator<Key,Value> docSource;
-  
+
   @Override
   protected Key buildKey(Text partition, Text term, Text docID) {
     Text colq = new Text(term);
@@ -79,18 +79,18 @@ public class IndexedDocIterator extends IntersectingIterator {
     colq.append(nullByte, 0, 1);
     return new Key(partition, indexColf, colq);
   }
-  
+
   @Override
   protected Key buildKey(Text partition, Text term) {
     Text colq = new Text(term);
     return new Key(partition, indexColf, colq);
   }
-  
+
   @Override
   protected Text getDocID(Key key) {
     return parseDocID(key);
   }
-  
+
   public static Text parseDocID(Key key) {
     Text colq = key.getColumnQualifier();
     int firstZeroIndex = colq.find("\0");
@@ -113,7 +113,7 @@ public class IndexedDocIterator extends IntersectingIterator {
     }
     return docID;
   }
-  
+
   @Override
   protected Text getTerm(Key key) {
     if (indexColf.compareTo(key.getColumnFamily().getBytes(), 0, indexColf.getLength()) < 0) {
@@ -127,7 +127,7 @@ public class IndexedDocIterator extends IntersectingIterator {
     term.set(colq.getBytes(), 0, zeroIndex);
     return term;
   }
-  
+
   @Override
   synchronized public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
     super.init(source, options, env);
@@ -137,23 +137,23 @@ public class IndexedDocIterator extends IntersectingIterator {
       docColf = new Text(options.get(docFamilyOptionName));
     docSource = source.deepCopy(env);
     indexColfSet = Collections.singleton((ByteSequence) new ArrayByteSequence(indexColf.getBytes(), 0, indexColf.getLength()));
-    
+
     for (TermSource ts : this.sources) {
       ts.seekColfams = indexColfSet;
     }
   }
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     throw new UnsupportedOperationException();
   }
-  
+
   @Override
   public void seek(Range range, Collection<ByteSequence> seekColumnFamilies, boolean inclusive) throws IOException {
     super.seek(range, null, true);
-    
+
   }
-  
+
   @Override
   protected void advanceToIntersection() throws IOException {
     super.advanceToIntersection();
@@ -169,7 +169,7 @@ public class IndexedDocIterator extends IntersectingIterator {
     }
     log.debug("got doc value: " + value.toString());
   }
-  
+
   protected Key buildDocKey() {
     if (log.isTraceEnabled())
       log.trace("building doc key for " + currentPartition + " " + currentDocID);
@@ -189,10 +189,10 @@ public class IndexedDocIterator extends IntersectingIterator {
       log.trace("built doc key for seek: " + k.toString());
     return k;
   }
-  
+
   /**
    * A convenience method for setting the index column family.
-   * 
+   *
    * @param is
    *          IteratorSetting object to configure.
    * @param indexColf
@@ -201,10 +201,10 @@ public class IndexedDocIterator extends IntersectingIterator {
   public static void setIndexColf(IteratorSetting is, String indexColf) {
     is.addOption(indexFamilyOptionName, indexColf);
   }
-  
+
   /**
    * A convenience method for setting the document column family prefix.
-   * 
+   *
    * @param is
    *          IteratorSetting object to configure.
    * @param docColfPrefix
@@ -213,10 +213,10 @@ public class IndexedDocIterator extends IntersectingIterator {
   public static void setDocColfPrefix(IteratorSetting is, String docColfPrefix) {
     is.addOption(docFamilyOptionName, docColfPrefix);
   }
-  
+
   /**
    * A convenience method for setting the index column family and document column family prefix.
-   * 
+   *
    * @param is
    *          IteratorSetting object to configure.
    * @param indexColf

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/user/IntersectingIterator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/IntersectingIterator.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/IntersectingIterator.java
index 732a76c..63d6a34 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/IntersectingIterator.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/IntersectingIterator.java
@@ -39,68 +39,68 @@ import org.apache.hadoop.io.Text;
 /**
  * This iterator facilitates document-partitioned indexing. It involves grouping a set of documents together and indexing those documents into a single row of
  * an Accumulo table. This allows a tablet server to perform boolean AND operations on terms in the index.
- * 
+ *
  * The table structure should have the following form:
- * 
+ *
  * row: shardID, colfam: term, colqual: docID
- * 
+ *
  * When you configure this iterator with a set of terms (column families), it will return only the docIDs that appear with all of the specified terms. The
  * result will have an empty column family, as follows:
- * 
+ *
  * row: shardID, colfam: (empty), colqual: docID
- * 
+ *
  * This iterator is commonly used with BatchScanner or AccumuloInputFormat, to parallelize the search over all shardIDs.
- * 
+ *
  * This iterator will *ignore* any columnFamilies passed to {@link #seek(Range, Collection, boolean)} as it performs intersections over terms. Extending classes
  * should override the {@link TermSource#seekColfams} in their implementation's {@link #init(SortedKeyValueIterator, Map, IteratorEnvironment)} method.
- * 
+ *
  * README.shard in docs/examples shows an example of using the IntersectingIterator.
  */
 public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
-  
+
   protected Text nullText = new Text();
-  
+
   protected Text getPartition(Key key) {
     return key.getRow();
   }
-  
+
   protected Text getTerm(Key key) {
     return key.getColumnFamily();
   }
-  
+
   protected Text getDocID(Key key) {
     return key.getColumnQualifier();
   }
-  
+
   protected Key buildKey(Text partition, Text term) {
     return new Key(partition, (term == null) ? nullText : term);
   }
-  
+
   protected Key buildKey(Text partition, Text term, Text docID) {
     return new Key(partition, (term == null) ? nullText : term, docID);
   }
-  
+
   protected Key buildFollowingPartitionKey(Key key) {
     return key.followingKey(PartialKey.ROW);
   }
-  
+
   public static class TermSource {
     public SortedKeyValueIterator<Key,Value> iter;
     public Text term;
     public Collection<ByteSequence> seekColfams;
     public boolean notFlag;
-    
+
     public TermSource(TermSource other) {
       this.iter = other.iter;
       this.term = other.term;
       this.notFlag = other.notFlag;
       this.seekColfams = other.seekColfams;
     }
-    
+
     public TermSource(SortedKeyValueIterator<Key,Value> iter, Text term) {
       this(iter, term, false);
     }
-    
+
     public TermSource(SortedKeyValueIterator<Key,Value> iter, Text term, boolean notFlag) {
       this.iter = iter;
       this.term = term;
@@ -108,32 +108,32 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
       // The desired column families for this source is the term itself
       this.seekColfams = Collections.<ByteSequence> singletonList(new ArrayByteSequence(term.getBytes(), 0, term.getLength()));
     }
-    
+
     public String getTermString() {
       return (this.term == null) ? "Iterator" : this.term.toString();
     }
   }
-  
+
   protected TermSource[] sources;
   int sourcesCount = 0;
-  
+
   Range overallRange;
-  
+
   // query-time settings
   protected Text currentPartition = null;
   protected Text currentDocID = new Text(emptyByteArray);
   static final byte[] emptyByteArray = new byte[0];
-  
+
   protected Key topKey = null;
   protected Value value = new Value(emptyByteArray);
-  
+
   public IntersectingIterator() {}
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     return new IntersectingIterator(this, env);
   }
-  
+
   private IntersectingIterator(IntersectingIterator other, IteratorEnvironment env) {
     if (other.sources != null) {
       sourcesCount = other.sourcesCount;
@@ -143,29 +143,29 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
       }
     }
   }
-  
+
   @Override
   public Key getTopKey() {
     return topKey;
   }
-  
+
   @Override
   public Value getTopValue() {
     // we don't really care about values
     return value;
   }
-  
+
   @Override
   public boolean hasTop() {
     return currentPartition != null;
   }
-  
+
   // precondition: currentRow is not null
   private boolean seekOneSource(int sourceID) throws IOException {
     // find the next key in the appropriate column family that is at or beyond the cursor (currentRow, currentCQ)
     // advance the cursor if this source goes beyond it
     // return whether we advanced the cursor
-    
+
     // within this loop progress must be made in one of the following forms:
     // - currentRow or currentCQ must be increased
     // - the given source must advance its iterator
@@ -174,7 +174,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     // - the given source is out of data and currentRow is set to null
     // - the given source has advanced beyond the endRow and currentRow is set to null
     boolean advancedCursor = false;
-    
+
     if (sources[sourceID].notFlag) {
       while (true) {
         if (sources[sourceID].iter.hasTop() == false) {
@@ -194,7 +194,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
         int partitionCompare = currentPartition.compareTo(getPartition(sources[sourceID].iter.getTopKey()));
         // check if this source is already at or beyond currentRow
         // if not, then seek to at least the current row
-        
+
         if (partitionCompare > 0) {
           // seek to at least the currentRow
           Key seekKey = buildKey(currentPartition, sources[sourceID].term);
@@ -224,7 +224,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
             break;
           }
         }
-        
+
         // we have verified that we are in currentRow and the correct column family
         // make sure we are at or beyond columnQualifier
         Text docID = getDocID(sources[sourceID].iter.getTopKey());
@@ -260,7 +260,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
         // check if we're past the end key
         int endCompare = -1;
         // we should compare the row to the end of the range
-        
+
         if (overallRange.getEndKey() != null) {
           endCompare = overallRange.getEndKey().getRow().compareTo(sources[sourceID].iter.getTopKey().getRow());
           if ((!overallRange.isEndKeyInclusive() && endCompare <= 0) || endCompare < 0) {
@@ -289,7 +289,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
         // we have verified that the current source is positioned in currentRow
         // now we must make sure we're in the right columnFamily in the current row
         // Note: Iterators are auto-magically set to the correct columnFamily
-        
+
         if (sources[sourceID].term != null) {
           int termCompare = sources[sourceID].term.compareTo(getTerm(sources[sourceID].iter.getTopKey()));
           // check if this source is already on the right columnFamily
@@ -343,7 +343,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     }
     return advancedCursor;
   }
-  
+
   @Override
   public void next() throws IOException {
     if (currentPartition == null) {
@@ -354,7 +354,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     sources[0].iter.next();
     advanceToIntersection();
   }
-  
+
   protected void advanceToIntersection() throws IOException {
     boolean cursorChanged = true;
     while (cursorChanged) {
@@ -373,16 +373,16 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     }
     topKey = buildKey(currentPartition, nullText, currentDocID);
   }
-  
+
   public static String stringTopKey(SortedKeyValueIterator<Key,Value> iter) {
     if (iter.hasTop())
       return iter.getTopKey().toString();
     return "";
   }
-  
+
   private static final String columnFamiliesOptionName = "columnFamilies";
   private static final String notFlagOptionName = "notFlag";
-  
+
   /**
    * @return encoded columns
    */
@@ -394,7 +394,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     }
     return sb.toString();
   }
-  
+
   /**
    * @return encoded flags
    */
@@ -408,7 +408,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     }
     return Base64.encodeBase64String(bytes);
   }
-  
+
   protected static Text[] decodeColumns(String columns) {
     String[] columnStrings = columns.split("\n");
     Text[] columnTexts = new Text[columnStrings.length];
@@ -417,7 +417,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     }
     return columnTexts;
   }
-  
+
   /**
    * @return decoded flags
    */
@@ -425,7 +425,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     // return null of there were no flags
     if (flags == null)
       return null;
-    
+
     byte[] bytes = Base64.decodeBase64(flags.getBytes(UTF_8));
     boolean[] bFlags = new boolean[bytes.length];
     for (int i = 0; i < bytes.length; i++) {
@@ -436,16 +436,16 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     }
     return bFlags;
   }
-  
+
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
     Text[] terms = decodeColumns(options.get(columnFamiliesOptionName));
     boolean[] notFlag = decodeBooleans(options.get(notFlagOptionName));
-    
+
     if (terms.length < 1) {
       throw new IllegalArgumentException("IntersectionIterator requires one or more columns families");
     }
-    
+
     // Scan the not flags.
     // There must be at least one term that isn't negated
     // And we are going to re-order such that the first term is not a ! term
@@ -469,7 +469,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
         throw new IllegalArgumentException("IntersectionIterator requires at lest one column family without not");
       }
     }
-    
+
     sources = new TermSource[terms.length];
     sources[0] = new TermSource(source, terms[0]);
     for (int i = 1; i < terms.length; i++) {
@@ -477,13 +477,13 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     }
     sourcesCount = terms.length;
   }
-  
+
   @Override
   public void seek(Range range, Collection<ByteSequence> seekColumnFamilies, boolean inclusive) throws IOException {
     overallRange = new Range(range);
     currentPartition = new Text();
     currentDocID.set(emptyByteArray);
-    
+
     // seek each of the sources to the right column family within the row given by key
     for (int i = 0; i < sourcesCount; i++) {
       Key sourceKey;
@@ -502,7 +502,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     }
     advanceToIntersection();
   }
-  
+
   /**
    * @deprecated since 1.6.0
    */
@@ -526,7 +526,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
     sources[sourcesCount] = new TermSource(source.deepCopy(env), term, notFlag);
     sourcesCount++;
   }
-  
+
   /**
    * Encode the columns to be used when iterating.
    */
@@ -535,7 +535,7 @@ public class IntersectingIterator implements SortedKeyValueIterator<Key,Value> {
       throw new IllegalArgumentException("Must supply at least one term to intersect");
     cfg.addOption(IntersectingIterator.columnFamiliesOptionName, IntersectingIterator.encodeColumns(columns));
   }
-  
+
   /**
    * Encode columns and NOT flags indicating which columns should be negated (docIDs will be excluded if matching negated columns, instead of included).
    */

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/user/LargeRowFilter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/LargeRowFilter.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/LargeRowFilter.java
index 4db379b..59a5dec 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/LargeRowFilter.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/LargeRowFilter.java
@@ -41,40 +41,40 @@ import org.apache.hadoop.io.Text;
 /**
  * This iterator suppresses rows that exceed a specified number of columns. Once a row exceeds the threshold, a marker is emitted and the row is always
  * suppressed by this iterator after that point in time.
- * 
+ *
  * This iterator works in a similar way to the RowDeletingIterator. See its javadoc about locality groups.
  */
 public class LargeRowFilter implements SortedKeyValueIterator<Key,Value>, OptionDescriber {
-  
+
   public static final Value SUPPRESS_ROW_VALUE = new Value("SUPPRESS_ROW".getBytes(UTF_8));
-  
+
   private static final ByteSequence EMPTY = new ArrayByteSequence(new byte[] {});
-  
+
   /* key into hash map, value refers to the row supression limit (maxColumns) */
   private static final String MAX_COLUMNS = "max_columns";
-  
+
   private SortedKeyValueIterator<Key,Value> source;
-  
+
   // a cache of keys
   private ArrayList<Key> keys = new ArrayList<Key>();
   private ArrayList<Value> values = new ArrayList<Value>();
-  
+
   private int currentPosition;
-  
+
   private int maxColumns;
-  
+
   private boolean propogateSuppression = false;
-  
+
   private Range range;
   private Collection<ByteSequence> columnFamilies;
   private boolean inclusive;
   private boolean dropEmptyColFams;
-  
+
   private boolean isSuppressionMarker(Key key, Value val) {
     return key.getColumnFamilyData().length() == 0 && key.getColumnQualifierData().length() == 0 && key.getColumnVisibilityData().length() == 0
         && val.equals(SUPPRESS_ROW_VALUE);
   }
-  
+
   private void reseek(Key key) throws IOException {
     if (range.afterEndKey(key)) {
       range = new Range(range.getEndKey(), true, range.getEndKey(), range.isEndKeyInclusive());
@@ -84,11 +84,11 @@ public class LargeRowFilter implements SortedKeyValueIterator<Key,Value>, Option
       source.seek(range, columnFamilies, inclusive);
     }
   }
-  
+
   private void consumeRow(ByteSequence row) throws IOException {
     // try reading a few and if still not to next row, then seek
     int count = 0;
-    
+
     while (source.hasTop() && source.getTopKey().getRowData().equals(row)) {
       source.next();
       count++;
@@ -99,7 +99,7 @@ public class LargeRowFilter implements SortedKeyValueIterator<Key,Value>, Option
       }
     }
   }
-  
+
   private void addKeyValue(Key k, Value v) {
     if (dropEmptyColFams && k.getColumnFamilyData().equals(EMPTY)) {
       return;
@@ -107,34 +107,34 @@ public class LargeRowFilter implements SortedKeyValueIterator<Key,Value>, Option
     keys.add(new Key(k));
     values.add(new Value(v));
   }
-  
+
   private void bufferNextRow() throws IOException {
-    
+
     keys.clear();
     values.clear();
     currentPosition = 0;
-    
+
     while (source.hasTop() && keys.size() == 0) {
-      
+
       addKeyValue(source.getTopKey(), source.getTopValue());
-      
+
       if (isSuppressionMarker(source.getTopKey(), source.getTopValue())) {
-        
+
         consumeRow(source.getTopKey().getRowData());
-        
+
       } else {
-        
+
         ByteSequence currentRow = keys.get(0).getRowData();
         source.next();
-        
+
         while (source.hasTop() && source.getTopKey().getRowData().equals(currentRow)) {
-          
+
           addKeyValue(source.getTopKey(), source.getTopValue());
-          
+
           if (keys.size() > maxColumns) {
             keys.clear();
             values.clear();
-            
+
             // when the row is to big, just emit a suppression
             // marker
             addKeyValue(new Key(new Text(currentRow.toArray())), SUPPRESS_ROW_VALUE);
@@ -144,56 +144,56 @@ public class LargeRowFilter implements SortedKeyValueIterator<Key,Value>, Option
           }
         }
       }
-      
+
     }
   }
-  
+
   private void readNextRow() throws IOException {
-    
+
     bufferNextRow();
-    
+
     while (!propogateSuppression && currentPosition < keys.size() && isSuppressionMarker(keys.get(0), values.get(0))) {
       bufferNextRow();
     }
   }
-  
+
   private LargeRowFilter(SortedKeyValueIterator<Key,Value> source, boolean propogateSuppression, int maxColumns) {
     this.source = source;
     this.propogateSuppression = propogateSuppression;
     this.maxColumns = maxColumns;
   }
-  
+
   public LargeRowFilter() {}
-  
+
   @Override
   public void init(SortedKeyValueIterator<Key,Value> source, Map<String,String> options, IteratorEnvironment env) throws IOException {
     this.source = source;
     this.maxColumns = Integer.parseInt(options.get(MAX_COLUMNS));
     this.propogateSuppression = env.getIteratorScope() != IteratorScope.scan;
   }
-  
+
   @Override
   public boolean hasTop() {
     return currentPosition < keys.size();
   }
-  
+
   @Override
   public void next() throws IOException {
-    
+
     if (currentPosition >= keys.size()) {
       throw new IllegalStateException("Called next() when hasTop() is false");
     }
-    
+
     currentPosition++;
-    
+
     if (currentPosition == keys.size()) {
       readNextRow();
     }
   }
-  
+
   @Override
   public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
-    
+
     if (inclusive && !columnFamilies.contains(EMPTY)) {
       columnFamilies = new HashSet<ByteSequence>(columnFamilies);
       columnFamilies.add(EMPTY);
@@ -205,48 +205,48 @@ public class LargeRowFilter implements SortedKeyValueIterator<Key,Value>, Option
     } else {
       dropEmptyColFams = false;
     }
-    
+
     this.range = range;
     this.columnFamilies = columnFamilies;
     this.inclusive = inclusive;
-    
+
     if (range.getStartKey() != null) {
       // seek to beginning of row to see if there is a suppression marker
       Range newRange = new Range(new Key(range.getStartKey().getRow()), true, range.getEndKey(), range.isEndKeyInclusive());
       source.seek(newRange, columnFamilies, inclusive);
-      
+
       readNextRow();
-      
+
       // it is possible that all or some of the data read for the current
       // row is before the start of the range
       while (currentPosition < keys.size() && range.beforeStartKey(keys.get(currentPosition)))
         currentPosition++;
-      
+
       if (currentPosition == keys.size())
         readNextRow();
-      
+
     } else {
       source.seek(range, columnFamilies, inclusive);
       readNextRow();
     }
-    
+
   }
-  
+
   @Override
   public Key getTopKey() {
     return keys.get(currentPosition);
   }
-  
+
   @Override
   public Value getTopValue() {
     return values.get(currentPosition);
   }
-  
+
   @Override
   public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) {
     return new LargeRowFilter(source.deepCopy(env), propogateSuppression, maxColumns);
   }
-  
+
   @Override
   public IteratorOptions describeOptions() {
     String description = "This iterator suppresses rows that exceed a specified number of columns. Once\n"
@@ -255,13 +255,13 @@ public class LargeRowFilter implements SortedKeyValueIterator<Key,Value>, Option
     return new IteratorOptions(this.getClass().getSimpleName(), description, Collections.singletonMap(MAX_COLUMNS, "Number Of Columns To Begin Suppression"),
         null);
   }
-  
+
   @Override
   public boolean validateOptions(Map<String,String> options) {
     if (options == null || options.size() < 1) {
       throw new IllegalArgumentException("Bad # of options, must supply: " + MAX_COLUMNS + " as value");
     }
-    
+
     if (!options.containsKey(MAX_COLUMNS))
       throw new IllegalArgumentException("Bad # of options, must supply: " + MAX_COLUMNS + " as value");
     try {
@@ -269,13 +269,13 @@ public class LargeRowFilter implements SortedKeyValueIterator<Key,Value>, Option
     } catch (Exception e) {
       throw new IllegalArgumentException("bad integer " + MAX_COLUMNS + ":" + options.get(MAX_COLUMNS));
     }
-    
+
     return true;
   }
-  
+
   /**
    * A convenience method for setting the maximum number of columns to keep.
-   * 
+   *
    * @param is
    *          IteratorSetting object to configure.
    * @param maxColumns

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/user/MaxCombiner.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/MaxCombiner.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/MaxCombiner.java
index 1b5a4e2..08ec483 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/MaxCombiner.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/MaxCombiner.java
@@ -35,7 +35,7 @@ public class MaxCombiner extends LongCombiner {
     }
     return max;
   }
-  
+
   @Override
   public IteratorOptions describeOptions() {
     IteratorOptions io = super.describeOptions();

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6bc67602/core/src/main/java/org/apache/accumulo/core/iterators/user/MinCombiner.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/MinCombiner.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/MinCombiner.java
index 891806e..31be086 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/MinCombiner.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/MinCombiner.java
@@ -35,7 +35,7 @@ public class MinCombiner extends LongCombiner {
     }
     return min;
   }
-  
+
   @Override
   public IteratorOptions describeOptions() {
     IteratorOptions io = super.describeOptions();


Mime
View raw message