accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From e..@apache.org
Subject svn commit: r1437820 [3/4] - in /accumulo/trunk: core/src/main/java/org/apache/accumulo/core/client/admin/ proxy/ proxy/src/main/java/org/apache/accumulo/proxy/ proxy/src/main/java/org/apache/accumulo/proxy/thrift/ proxy/src/main/thrift/ proxy/src/test...
Date Thu, 24 Jan 2013 01:13:25 GMT
Modified: accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ActiveCompaction.java
URL: http://svn.apache.org/viewvc/accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ActiveCompaction.java?rev=1437820&r1=1437819&r2=1437820&view=diff
==============================================================================
--- accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ActiveCompaction.java (original)
+++ accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ActiveCompaction.java Thu Jan 24 01:13:24 2013
@@ -1112,13 +1112,13 @@ import org.slf4j.LoggerFactory;
           case 3: // INPUT_FILES
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list42 = iprot.readListBegin();
-                struct.inputFiles = new ArrayList<String>(_list42.size);
-                for (int _i43 = 0; _i43 < _list42.size; ++_i43)
+                org.apache.thrift.protocol.TList _list98 = iprot.readListBegin();
+                struct.inputFiles = new ArrayList<String>(_list98.size);
+                for (int _i99 = 0; _i99 < _list98.size; ++_i99)
                 {
-                  String _elem44; // required
-                  _elem44 = iprot.readString();
-                  struct.inputFiles.add(_elem44);
+                  String _elem100; // required
+                  _elem100 = iprot.readString();
+                  struct.inputFiles.add(_elem100);
                 }
                 iprot.readListEnd();
               }
@@ -1178,14 +1178,14 @@ import org.slf4j.LoggerFactory;
           case 10: // ITERATORS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list45 = iprot.readListBegin();
-                struct.iterators = new ArrayList<IteratorSetting>(_list45.size);
-                for (int _i46 = 0; _i46 < _list45.size; ++_i46)
+                org.apache.thrift.protocol.TList _list101 = iprot.readListBegin();
+                struct.iterators = new ArrayList<IteratorSetting>(_list101.size);
+                for (int _i102 = 0; _i102 < _list101.size; ++_i102)
                 {
-                  IteratorSetting _elem47; // required
-                  _elem47 = new IteratorSetting();
-                  _elem47.read(iprot);
-                  struct.iterators.add(_elem47);
+                  IteratorSetting _elem103; // required
+                  _elem103 = new IteratorSetting();
+                  _elem103.read(iprot);
+                  struct.iterators.add(_elem103);
                 }
                 iprot.readListEnd();
               }
@@ -1221,9 +1221,9 @@ import org.slf4j.LoggerFactory;
         oprot.writeFieldBegin(INPUT_FILES_FIELD_DESC);
         {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.inputFiles.size()));
-          for (String _iter48 : struct.inputFiles)
+          for (String _iter104 : struct.inputFiles)
           {
-            oprot.writeString(_iter48);
+            oprot.writeString(_iter104);
           }
           oprot.writeListEnd();
         }
@@ -1259,9 +1259,9 @@ import org.slf4j.LoggerFactory;
         oprot.writeFieldBegin(ITERATORS_FIELD_DESC);
         {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.iterators.size()));
-          for (IteratorSetting _iter49 : struct.iterators)
+          for (IteratorSetting _iter105 : struct.iterators)
           {
-            _iter49.write(oprot);
+            _iter105.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -1325,9 +1325,9 @@ import org.slf4j.LoggerFactory;
       if (struct.isSetInputFiles()) {
         {
           oprot.writeI32(struct.inputFiles.size());
-          for (String _iter50 : struct.inputFiles)
+          for (String _iter106 : struct.inputFiles)
           {
-            oprot.writeString(_iter50);
+            oprot.writeString(_iter106);
           }
         }
       }
@@ -1352,9 +1352,9 @@ import org.slf4j.LoggerFactory;
       if (struct.isSetIterators()) {
         {
           oprot.writeI32(struct.iterators.size());
-          for (IteratorSetting _iter51 : struct.iterators)
+          for (IteratorSetting _iter107 : struct.iterators)
           {
-            _iter51.write(oprot);
+            _iter107.write(oprot);
           }
         }
       }
@@ -1375,13 +1375,13 @@ import org.slf4j.LoggerFactory;
       }
       if (incoming.get(2)) {
         {
-          org.apache.thrift.protocol.TList _list52 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-          struct.inputFiles = new ArrayList<String>(_list52.size);
-          for (int _i53 = 0; _i53 < _list52.size; ++_i53)
+          org.apache.thrift.protocol.TList _list108 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+          struct.inputFiles = new ArrayList<String>(_list108.size);
+          for (int _i109 = 0; _i109 < _list108.size; ++_i109)
           {
-            String _elem54; // required
-            _elem54 = iprot.readString();
-            struct.inputFiles.add(_elem54);
+            String _elem110; // required
+            _elem110 = iprot.readString();
+            struct.inputFiles.add(_elem110);
           }
         }
         struct.setInputFilesIsSet(true);
@@ -1412,14 +1412,14 @@ import org.slf4j.LoggerFactory;
       }
       if (incoming.get(9)) {
         {
-          org.apache.thrift.protocol.TList _list55 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.iterators = new ArrayList<IteratorSetting>(_list55.size);
-          for (int _i56 = 0; _i56 < _list55.size; ++_i56)
+          org.apache.thrift.protocol.TList _list111 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.iterators = new ArrayList<IteratorSetting>(_list111.size);
+          for (int _i112 = 0; _i112 < _list111.size; ++_i112)
           {
-            IteratorSetting _elem57; // required
-            _elem57 = new IteratorSetting();
-            _elem57.read(iprot);
-            struct.iterators.add(_elem57);
+            IteratorSetting _elem113; // required
+            _elem113 = new IteratorSetting();
+            _elem113.read(iprot);
+            struct.iterators.add(_elem113);
           }
         }
         struct.setIteratorsIsSet(true);

Modified: accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ActiveScan.java
URL: http://svn.apache.org/viewvc/accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ActiveScan.java?rev=1437820&r1=1437819&r2=1437820&view=diff
==============================================================================
--- accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ActiveScan.java (original)
+++ accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ActiveScan.java Thu Jan 24 01:13:24 2013
@@ -1263,14 +1263,14 @@ import org.slf4j.LoggerFactory;
           case 9: // COLUMNS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list18 = iprot.readListBegin();
-                struct.columns = new ArrayList<Column>(_list18.size);
-                for (int _i19 = 0; _i19 < _list18.size; ++_i19)
+                org.apache.thrift.protocol.TList _list74 = iprot.readListBegin();
+                struct.columns = new ArrayList<Column>(_list74.size);
+                for (int _i75 = 0; _i75 < _list74.size; ++_i75)
                 {
-                  Column _elem20; // required
-                  _elem20 = new Column();
-                  _elem20.read(iprot);
-                  struct.columns.add(_elem20);
+                  Column _elem76; // required
+                  _elem76 = new Column();
+                  _elem76.read(iprot);
+                  struct.columns.add(_elem76);
                 }
                 iprot.readListEnd();
               }
@@ -1282,14 +1282,14 @@ import org.slf4j.LoggerFactory;
           case 10: // ITERATORS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list21 = iprot.readListBegin();
-                struct.iterators = new ArrayList<IteratorSetting>(_list21.size);
-                for (int _i22 = 0; _i22 < _list21.size; ++_i22)
+                org.apache.thrift.protocol.TList _list77 = iprot.readListBegin();
+                struct.iterators = new ArrayList<IteratorSetting>(_list77.size);
+                for (int _i78 = 0; _i78 < _list77.size; ++_i78)
                 {
-                  IteratorSetting _elem23; // required
-                  _elem23 = new IteratorSetting();
-                  _elem23.read(iprot);
-                  struct.iterators.add(_elem23);
+                  IteratorSetting _elem79; // required
+                  _elem79 = new IteratorSetting();
+                  _elem79.read(iprot);
+                  struct.iterators.add(_elem79);
                 }
                 iprot.readListEnd();
               }
@@ -1301,13 +1301,13 @@ import org.slf4j.LoggerFactory;
           case 11: // AUTHORIZATIONS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list24 = iprot.readListBegin();
-                struct.authorizations = new ArrayList<ByteBuffer>(_list24.size);
-                for (int _i25 = 0; _i25 < _list24.size; ++_i25)
+                org.apache.thrift.protocol.TList _list80 = iprot.readListBegin();
+                struct.authorizations = new ArrayList<ByteBuffer>(_list80.size);
+                for (int _i81 = 0; _i81 < _list80.size; ++_i81)
                 {
-                  ByteBuffer _elem26; // required
-                  _elem26 = iprot.readBinary();
-                  struct.authorizations.add(_elem26);
+                  ByteBuffer _elem82; // required
+                  _elem82 = iprot.readBinary();
+                  struct.authorizations.add(_elem82);
                 }
                 iprot.readListEnd();
               }
@@ -1371,9 +1371,9 @@ import org.slf4j.LoggerFactory;
         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
         {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
-          for (Column _iter27 : struct.columns)
+          for (Column _iter83 : struct.columns)
           {
-            _iter27.write(oprot);
+            _iter83.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -1383,9 +1383,9 @@ import org.slf4j.LoggerFactory;
         oprot.writeFieldBegin(ITERATORS_FIELD_DESC);
         {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.iterators.size()));
-          for (IteratorSetting _iter28 : struct.iterators)
+          for (IteratorSetting _iter84 : struct.iterators)
           {
-            _iter28.write(oprot);
+            _iter84.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -1395,9 +1395,9 @@ import org.slf4j.LoggerFactory;
         oprot.writeFieldBegin(AUTHORIZATIONS_FIELD_DESC);
         {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.authorizations.size()));
-          for (ByteBuffer _iter29 : struct.authorizations)
+          for (ByteBuffer _iter85 : struct.authorizations)
           {
-            oprot.writeBinary(_iter29);
+            oprot.writeBinary(_iter85);
           }
           oprot.writeListEnd();
         }
@@ -1482,27 +1482,27 @@ import org.slf4j.LoggerFactory;
       if (struct.isSetColumns()) {
         {
           oprot.writeI32(struct.columns.size());
-          for (Column _iter30 : struct.columns)
+          for (Column _iter86 : struct.columns)
           {
-            _iter30.write(oprot);
+            _iter86.write(oprot);
           }
         }
       }
       if (struct.isSetIterators()) {
         {
           oprot.writeI32(struct.iterators.size());
-          for (IteratorSetting _iter31 : struct.iterators)
+          for (IteratorSetting _iter87 : struct.iterators)
           {
-            _iter31.write(oprot);
+            _iter87.write(oprot);
           }
         }
       }
       if (struct.isSetAuthorizations()) {
         {
           oprot.writeI32(struct.authorizations.size());
-          for (ByteBuffer _iter32 : struct.authorizations)
+          for (ByteBuffer _iter88 : struct.authorizations)
           {
-            oprot.writeBinary(_iter32);
+            oprot.writeBinary(_iter88);
           }
         }
       }
@@ -1547,41 +1547,41 @@ import org.slf4j.LoggerFactory;
       }
       if (incoming.get(8)) {
         {
-          org.apache.thrift.protocol.TList _list33 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.columns = new ArrayList<Column>(_list33.size);
-          for (int _i34 = 0; _i34 < _list33.size; ++_i34)
+          org.apache.thrift.protocol.TList _list89 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.columns = new ArrayList<Column>(_list89.size);
+          for (int _i90 = 0; _i90 < _list89.size; ++_i90)
           {
-            Column _elem35; // required
-            _elem35 = new Column();
-            _elem35.read(iprot);
-            struct.columns.add(_elem35);
+            Column _elem91; // required
+            _elem91 = new Column();
+            _elem91.read(iprot);
+            struct.columns.add(_elem91);
           }
         }
         struct.setColumnsIsSet(true);
       }
       if (incoming.get(9)) {
         {
-          org.apache.thrift.protocol.TList _list36 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.iterators = new ArrayList<IteratorSetting>(_list36.size);
-          for (int _i37 = 0; _i37 < _list36.size; ++_i37)
+          org.apache.thrift.protocol.TList _list92 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.iterators = new ArrayList<IteratorSetting>(_list92.size);
+          for (int _i93 = 0; _i93 < _list92.size; ++_i93)
           {
-            IteratorSetting _elem38; // required
-            _elem38 = new IteratorSetting();
-            _elem38.read(iprot);
-            struct.iterators.add(_elem38);
+            IteratorSetting _elem94; // required
+            _elem94 = new IteratorSetting();
+            _elem94.read(iprot);
+            struct.iterators.add(_elem94);
           }
         }
         struct.setIteratorsIsSet(true);
       }
       if (incoming.get(10)) {
         {
-          org.apache.thrift.protocol.TList _list39 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
-          struct.authorizations = new ArrayList<ByteBuffer>(_list39.size);
-          for (int _i40 = 0; _i40 < _list39.size; ++_i40)
+          org.apache.thrift.protocol.TList _list95 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+          struct.authorizations = new ArrayList<ByteBuffer>(_list95.size);
+          for (int _i96 = 0; _i96 < _list95.size; ++_i96)
           {
-            ByteBuffer _elem41; // required
-            _elem41 = iprot.readBinary();
-            struct.authorizations.add(_elem41);
+            ByteBuffer _elem97; // required
+            _elem97 = iprot.readBinary();
+            struct.authorizations.add(_elem97);
           }
         }
         struct.setAuthorizationsIsSet(true);

Added: accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/BatchScanOptions.java
URL: http://svn.apache.org/viewvc/accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/BatchScanOptions.java?rev=1437820&view=auto
==============================================================================
--- accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/BatchScanOptions.java (added)
+++ accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/BatchScanOptions.java Thu Jan 24 01:13:24 2013
@@ -0,0 +1,1021 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.accumulo.proxy.thrift;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings("all") public class BatchScanOptions implements org.apache.thrift.TBase<BatchScanOptions, BatchScanOptions._Fields>, java.io.Serializable, Cloneable {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("BatchScanOptions");
+
+  private static final org.apache.thrift.protocol.TField AUTHORIZATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("authorizations", org.apache.thrift.protocol.TType.SET, (short)1);
+  private static final org.apache.thrift.protocol.TField RANGES_FIELD_DESC = new org.apache.thrift.protocol.TField("ranges", org.apache.thrift.protocol.TType.LIST, (short)2);
+  private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3);
+  private static final org.apache.thrift.protocol.TField ITERATORS_FIELD_DESC = new org.apache.thrift.protocol.TField("iterators", org.apache.thrift.protocol.TType.LIST, (short)4);
+  private static final org.apache.thrift.protocol.TField BUFFER_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("bufferSize", org.apache.thrift.protocol.TType.I32, (short)5);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new BatchScanOptionsStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new BatchScanOptionsTupleSchemeFactory());
+  }
+
+  public Set<ByteBuffer> authorizations; // optional
+  public List<Range> ranges; // optional
+  public List<ScanColumn> columns; // optional
+  public List<IteratorSetting> iterators; // optional
+  public int bufferSize; // optional
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    AUTHORIZATIONS((short)1, "authorizations"),
+    RANGES((short)2, "ranges"),
+    COLUMNS((short)3, "columns"),
+    ITERATORS((short)4, "iterators"),
+    BUFFER_SIZE((short)5, "bufferSize");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // AUTHORIZATIONS
+          return AUTHORIZATIONS;
+        case 2: // RANGES
+          return RANGES;
+        case 3: // COLUMNS
+          return COLUMNS;
+        case 4: // ITERATORS
+          return ITERATORS;
+        case 5: // BUFFER_SIZE
+          return BUFFER_SIZE;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  private static final int __BUFFERSIZE_ISSET_ID = 0;
+  private byte __isset_bitfield = 0;
+  private _Fields optionals[] = {_Fields.AUTHORIZATIONS,_Fields.RANGES,_Fields.COLUMNS,_Fields.ITERATORS,_Fields.BUFFER_SIZE};
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.AUTHORIZATIONS, new org.apache.thrift.meta_data.FieldMetaData("authorizations", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.SetMetaData(org.apache.thrift.protocol.TType.SET, 
+            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING            , true))));
+    tmpMap.put(_Fields.RANGES, new org.apache.thrift.meta_data.FieldMetaData("ranges", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
+            new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Range.class))));
+    tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
+            new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ScanColumn.class))));
+    tmpMap.put(_Fields.ITERATORS, new org.apache.thrift.meta_data.FieldMetaData("iterators", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
+            new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, IteratorSetting.class))));
+    tmpMap.put(_Fields.BUFFER_SIZE, new org.apache.thrift.meta_data.FieldMetaData("bufferSize", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(BatchScanOptions.class, metaDataMap);
+  }
+
+  public BatchScanOptions() {
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public BatchScanOptions(BatchScanOptions other) {
+    __isset_bitfield = other.__isset_bitfield;
+    if (other.isSetAuthorizations()) {
+      Set<ByteBuffer> __this__authorizations = new HashSet<ByteBuffer>();
+      for (ByteBuffer other_element : other.authorizations) {
+        ByteBuffer temp_binary_element = org.apache.thrift.TBaseHelper.copyBinary(other_element);
+;
+        __this__authorizations.add(temp_binary_element);
+      }
+      this.authorizations = __this__authorizations;
+    }
+    if (other.isSetRanges()) {
+      List<Range> __this__ranges = new ArrayList<Range>();
+      for (Range other_element : other.ranges) {
+        __this__ranges.add(new Range(other_element));
+      }
+      this.ranges = __this__ranges;
+    }
+    if (other.isSetColumns()) {
+      List<ScanColumn> __this__columns = new ArrayList<ScanColumn>();
+      for (ScanColumn other_element : other.columns) {
+        __this__columns.add(new ScanColumn(other_element));
+      }
+      this.columns = __this__columns;
+    }
+    if (other.isSetIterators()) {
+      List<IteratorSetting> __this__iterators = new ArrayList<IteratorSetting>();
+      for (IteratorSetting other_element : other.iterators) {
+        __this__iterators.add(new IteratorSetting(other_element));
+      }
+      this.iterators = __this__iterators;
+    }
+    this.bufferSize = other.bufferSize;
+  }
+
+  public BatchScanOptions deepCopy() {
+    return new BatchScanOptions(this);
+  }
+
+  @Override
+  public void clear() {
+    this.authorizations = null;
+    this.ranges = null;
+    this.columns = null;
+    this.iterators = null;
+    setBufferSizeIsSet(false);
+    this.bufferSize = 0;
+  }
+
+  public int getAuthorizationsSize() {
+    return (this.authorizations == null) ? 0 : this.authorizations.size();
+  }
+
+  public java.util.Iterator<ByteBuffer> getAuthorizationsIterator() {
+    return (this.authorizations == null) ? null : this.authorizations.iterator();
+  }
+
+  public void addToAuthorizations(ByteBuffer elem) {
+    if (this.authorizations == null) {
+      this.authorizations = new HashSet<ByteBuffer>();
+    }
+    this.authorizations.add(elem);
+  }
+
+  public Set<ByteBuffer> getAuthorizations() {
+    return this.authorizations;
+  }
+
+  public BatchScanOptions setAuthorizations(Set<ByteBuffer> authorizations) {
+    this.authorizations = authorizations;
+    return this;
+  }
+
+  public void unsetAuthorizations() {
+    this.authorizations = null;
+  }
+
+  /** Returns true if field authorizations is set (has been assigned a value) and false otherwise */
+  public boolean isSetAuthorizations() {
+    return this.authorizations != null;
+  }
+
+  public void setAuthorizationsIsSet(boolean value) {
+    if (!value) {
+      this.authorizations = null;
+    }
+  }
+
+  public int getRangesSize() {
+    return (this.ranges == null) ? 0 : this.ranges.size();
+  }
+
+  public java.util.Iterator<Range> getRangesIterator() {
+    return (this.ranges == null) ? null : this.ranges.iterator();
+  }
+
+  public void addToRanges(Range elem) {
+    if (this.ranges == null) {
+      this.ranges = new ArrayList<Range>();
+    }
+    this.ranges.add(elem);
+  }
+
+  public List<Range> getRanges() {
+    return this.ranges;
+  }
+
+  public BatchScanOptions setRanges(List<Range> ranges) {
+    this.ranges = ranges;
+    return this;
+  }
+
+  public void unsetRanges() {
+    this.ranges = null;
+  }
+
+  /** Returns true if field ranges is set (has been assigned a value) and false otherwise */
+  public boolean isSetRanges() {
+    return this.ranges != null;
+  }
+
+  public void setRangesIsSet(boolean value) {
+    if (!value) {
+      this.ranges = null;
+    }
+  }
+
+  public int getColumnsSize() {
+    return (this.columns == null) ? 0 : this.columns.size();
+  }
+
+  public java.util.Iterator<ScanColumn> getColumnsIterator() {
+    return (this.columns == null) ? null : this.columns.iterator();
+  }
+
+  public void addToColumns(ScanColumn elem) {
+    if (this.columns == null) {
+      this.columns = new ArrayList<ScanColumn>();
+    }
+    this.columns.add(elem);
+  }
+
+  public List<ScanColumn> getColumns() {
+    return this.columns;
+  }
+
+  public BatchScanOptions setColumns(List<ScanColumn> columns) {
+    this.columns = columns;
+    return this;
+  }
+
+  public void unsetColumns() {
+    this.columns = null;
+  }
+
+  /** Returns true if field columns is set (has been assigned a value) and false otherwise */
+  public boolean isSetColumns() {
+    return this.columns != null;
+  }
+
+  public void setColumnsIsSet(boolean value) {
+    if (!value) {
+      this.columns = null;
+    }
+  }
+
+  public int getIteratorsSize() {
+    return (this.iterators == null) ? 0 : this.iterators.size();
+  }
+
+  public java.util.Iterator<IteratorSetting> getIteratorsIterator() {
+    return (this.iterators == null) ? null : this.iterators.iterator();
+  }
+
+  public void addToIterators(IteratorSetting elem) {
+    if (this.iterators == null) {
+      this.iterators = new ArrayList<IteratorSetting>();
+    }
+    this.iterators.add(elem);
+  }
+
+  public List<IteratorSetting> getIterators() {
+    return this.iterators;
+  }
+
+  public BatchScanOptions setIterators(List<IteratorSetting> iterators) {
+    this.iterators = iterators;
+    return this;
+  }
+
+  public void unsetIterators() {
+    this.iterators = null;
+  }
+
+  /** Returns true if field iterators is set (has been assigned a value) and false otherwise */
+  public boolean isSetIterators() {
+    return this.iterators != null;
+  }
+
+  public void setIteratorsIsSet(boolean value) {
+    if (!value) {
+      this.iterators = null;
+    }
+  }
+
+  public int getBufferSize() {
+    return this.bufferSize;
+  }
+
+  public BatchScanOptions setBufferSize(int bufferSize) {
+    this.bufferSize = bufferSize;
+    setBufferSizeIsSet(true);
+    return this;
+  }
+
+  public void unsetBufferSize() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __BUFFERSIZE_ISSET_ID);
+  }
+
+  /** Returns true if field bufferSize is set (has been assigned a value) and false otherwise */
+  public boolean isSetBufferSize() {
+    return EncodingUtils.testBit(__isset_bitfield, __BUFFERSIZE_ISSET_ID);
+  }
+
+  public void setBufferSizeIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __BUFFERSIZE_ISSET_ID, value);
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case AUTHORIZATIONS:
+      if (value == null) {
+        unsetAuthorizations();
+      } else {
+        setAuthorizations((Set<ByteBuffer>)value);
+      }
+      break;
+
+    case RANGES:
+      if (value == null) {
+        unsetRanges();
+      } else {
+        setRanges((List<Range>)value);
+      }
+      break;
+
+    case COLUMNS:
+      if (value == null) {
+        unsetColumns();
+      } else {
+        setColumns((List<ScanColumn>)value);
+      }
+      break;
+
+    case ITERATORS:
+      if (value == null) {
+        unsetIterators();
+      } else {
+        setIterators((List<IteratorSetting>)value);
+      }
+      break;
+
+    case BUFFER_SIZE:
+      if (value == null) {
+        unsetBufferSize();
+      } else {
+        setBufferSize((Integer)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case AUTHORIZATIONS:
+      return getAuthorizations();
+
+    case RANGES:
+      return getRanges();
+
+    case COLUMNS:
+      return getColumns();
+
+    case ITERATORS:
+      return getIterators();
+
+    case BUFFER_SIZE:
+      return Integer.valueOf(getBufferSize());
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case AUTHORIZATIONS:
+      return isSetAuthorizations();
+    case RANGES:
+      return isSetRanges();
+    case COLUMNS:
+      return isSetColumns();
+    case ITERATORS:
+      return isSetIterators();
+    case BUFFER_SIZE:
+      return isSetBufferSize();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof BatchScanOptions)
+      return this.equals((BatchScanOptions)that);
+    return false;
+  }
+
+  public boolean equals(BatchScanOptions that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_authorizations = true && this.isSetAuthorizations();
+    boolean that_present_authorizations = true && that.isSetAuthorizations();
+    if (this_present_authorizations || that_present_authorizations) {
+      if (!(this_present_authorizations && that_present_authorizations))
+        return false;
+      if (!this.authorizations.equals(that.authorizations))
+        return false;
+    }
+
+    boolean this_present_ranges = true && this.isSetRanges();
+    boolean that_present_ranges = true && that.isSetRanges();
+    if (this_present_ranges || that_present_ranges) {
+      if (!(this_present_ranges && that_present_ranges))
+        return false;
+      if (!this.ranges.equals(that.ranges))
+        return false;
+    }
+
+    boolean this_present_columns = true && this.isSetColumns();
+    boolean that_present_columns = true && that.isSetColumns();
+    if (this_present_columns || that_present_columns) {
+      if (!(this_present_columns && that_present_columns))
+        return false;
+      if (!this.columns.equals(that.columns))
+        return false;
+    }
+
+    boolean this_present_iterators = true && this.isSetIterators();
+    boolean that_present_iterators = true && that.isSetIterators();
+    if (this_present_iterators || that_present_iterators) {
+      if (!(this_present_iterators && that_present_iterators))
+        return false;
+      if (!this.iterators.equals(that.iterators))
+        return false;
+    }
+
+    boolean this_present_bufferSize = true && this.isSetBufferSize();
+    boolean that_present_bufferSize = true && that.isSetBufferSize();
+    if (this_present_bufferSize || that_present_bufferSize) {
+      if (!(this_present_bufferSize && that_present_bufferSize))
+        return false;
+      if (this.bufferSize != that.bufferSize)
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    return 0;
+  }
+
+  public int compareTo(BatchScanOptions other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+    BatchScanOptions typedOther = (BatchScanOptions)other;
+
+    lastComparison = Boolean.valueOf(isSetAuthorizations()).compareTo(typedOther.isSetAuthorizations());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetAuthorizations()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authorizations, typedOther.authorizations);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetRanges()).compareTo(typedOther.isSetRanges());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetRanges()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ranges, typedOther.ranges);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetColumns()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetIterators()).compareTo(typedOther.isSetIterators());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetIterators()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.iterators, typedOther.iterators);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetBufferSize()).compareTo(typedOther.isSetBufferSize());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetBufferSize()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bufferSize, typedOther.bufferSize);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("BatchScanOptions(");
+    boolean first = true;
+
+    if (isSetAuthorizations()) {
+      sb.append("authorizations:");
+      if (this.authorizations == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.authorizations);
+      }
+      first = false;
+    }
+    if (isSetRanges()) {
+      if (!first) sb.append(", ");
+      sb.append("ranges:");
+      if (this.ranges == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.ranges);
+      }
+      first = false;
+    }
+    if (isSetColumns()) {
+      if (!first) sb.append(", ");
+      sb.append("columns:");
+      if (this.columns == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.columns);
+      }
+      first = false;
+    }
+    if (isSetIterators()) {
+      if (!first) sb.append(", ");
+      sb.append("iterators:");
+      if (this.iterators == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.iterators);
+      }
+      first = false;
+    }
+    if (isSetBufferSize()) {
+      if (!first) sb.append(", ");
+      sb.append("bufferSize:");
+      sb.append(this.bufferSize);
+      first = false;
+    }
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    // check for sub-struct validity
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bitfield = 0;
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class BatchScanOptionsStandardSchemeFactory implements SchemeFactory {
+    public BatchScanOptionsStandardScheme getScheme() {
+      return new BatchScanOptionsStandardScheme();
+    }
+  }
+
+  private static class BatchScanOptionsStandardScheme extends StandardScheme<BatchScanOptions> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, BatchScanOptions struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // AUTHORIZATIONS
+            if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
+              {
+                org.apache.thrift.protocol.TSet _set42 = iprot.readSetBegin();
+                struct.authorizations = new HashSet<ByteBuffer>(2*_set42.size);
+                for (int _i43 = 0; _i43 < _set42.size; ++_i43)
+                {
+                  ByteBuffer _elem44; // required
+                  _elem44 = iprot.readBinary();
+                  struct.authorizations.add(_elem44);
+                }
+                iprot.readSetEnd();
+              }
+              struct.setAuthorizationsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // RANGES
+            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list45 = iprot.readListBegin();
+                struct.ranges = new ArrayList<Range>(_list45.size);
+                for (int _i46 = 0; _i46 < _list45.size; ++_i46)
+                {
+                  Range _elem47; // required
+                  _elem47 = new Range();
+                  _elem47.read(iprot);
+                  struct.ranges.add(_elem47);
+                }
+                iprot.readListEnd();
+              }
+              struct.setRangesIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 3: // COLUMNS
+            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
+                struct.columns = new ArrayList<ScanColumn>(_list48.size);
+                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
+                {
+                  ScanColumn _elem50; // required
+                  _elem50 = new ScanColumn();
+                  _elem50.read(iprot);
+                  struct.columns.add(_elem50);
+                }
+                iprot.readListEnd();
+              }
+              struct.setColumnsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 4: // ITERATORS
+            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list51 = iprot.readListBegin();
+                struct.iterators = new ArrayList<IteratorSetting>(_list51.size);
+                for (int _i52 = 0; _i52 < _list51.size; ++_i52)
+                {
+                  IteratorSetting _elem53; // required
+                  _elem53 = new IteratorSetting();
+                  _elem53.read(iprot);
+                  struct.iterators.add(_elem53);
+                }
+                iprot.readListEnd();
+              }
+              struct.setIteratorsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 5: // BUFFER_SIZE
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.bufferSize = iprot.readI32();
+              struct.setBufferSizeIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+
+      // check for required fields of primitive type, which can't be checked in the validate method
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, BatchScanOptions struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (struct.authorizations != null) {
+        if (struct.isSetAuthorizations()) {
+          oprot.writeFieldBegin(AUTHORIZATIONS_FIELD_DESC);
+          {
+            oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, struct.authorizations.size()));
+            for (ByteBuffer _iter54 : struct.authorizations)
+            {
+              oprot.writeBinary(_iter54);
+            }
+            oprot.writeSetEnd();
+          }
+          oprot.writeFieldEnd();
+        }
+      }
+      if (struct.ranges != null) {
+        if (struct.isSetRanges()) {
+          oprot.writeFieldBegin(RANGES_FIELD_DESC);
+          {
+            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.ranges.size()));
+            for (Range _iter55 : struct.ranges)
+            {
+              _iter55.write(oprot);
+            }
+            oprot.writeListEnd();
+          }
+          oprot.writeFieldEnd();
+        }
+      }
+      if (struct.columns != null) {
+        if (struct.isSetColumns()) {
+          oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
+          {
+            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
+            for (ScanColumn _iter56 : struct.columns)
+            {
+              _iter56.write(oprot);
+            }
+            oprot.writeListEnd();
+          }
+          oprot.writeFieldEnd();
+        }
+      }
+      if (struct.iterators != null) {
+        if (struct.isSetIterators()) {
+          oprot.writeFieldBegin(ITERATORS_FIELD_DESC);
+          {
+            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.iterators.size()));
+            for (IteratorSetting _iter57 : struct.iterators)
+            {
+              _iter57.write(oprot);
+            }
+            oprot.writeListEnd();
+          }
+          oprot.writeFieldEnd();
+        }
+      }
+      if (struct.isSetBufferSize()) {
+        oprot.writeFieldBegin(BUFFER_SIZE_FIELD_DESC);
+        oprot.writeI32(struct.bufferSize);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class BatchScanOptionsTupleSchemeFactory implements SchemeFactory {
+    public BatchScanOptionsTupleScheme getScheme() {
+      return new BatchScanOptionsTupleScheme();
+    }
+  }
+
+  private static class BatchScanOptionsTupleScheme extends TupleScheme<BatchScanOptions> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, BatchScanOptions struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      BitSet optionals = new BitSet();
+      if (struct.isSetAuthorizations()) {
+        optionals.set(0);
+      }
+      if (struct.isSetRanges()) {
+        optionals.set(1);
+      }
+      if (struct.isSetColumns()) {
+        optionals.set(2);
+      }
+      if (struct.isSetIterators()) {
+        optionals.set(3);
+      }
+      if (struct.isSetBufferSize()) {
+        optionals.set(4);
+      }
+      oprot.writeBitSet(optionals, 5);
+      if (struct.isSetAuthorizations()) {
+        {
+          oprot.writeI32(struct.authorizations.size());
+          for (ByteBuffer _iter58 : struct.authorizations)
+          {
+            oprot.writeBinary(_iter58);
+          }
+        }
+      }
+      if (struct.isSetRanges()) {
+        {
+          oprot.writeI32(struct.ranges.size());
+          for (Range _iter59 : struct.ranges)
+          {
+            _iter59.write(oprot);
+          }
+        }
+      }
+      if (struct.isSetColumns()) {
+        {
+          oprot.writeI32(struct.columns.size());
+          for (ScanColumn _iter60 : struct.columns)
+          {
+            _iter60.write(oprot);
+          }
+        }
+      }
+      if (struct.isSetIterators()) {
+        {
+          oprot.writeI32(struct.iterators.size());
+          for (IteratorSetting _iter61 : struct.iterators)
+          {
+            _iter61.write(oprot);
+          }
+        }
+      }
+      if (struct.isSetBufferSize()) {
+        oprot.writeI32(struct.bufferSize);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, BatchScanOptions struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      BitSet incoming = iprot.readBitSet(5);
+      if (incoming.get(0)) {
+        {
+          org.apache.thrift.protocol.TSet _set62 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+          struct.authorizations = new HashSet<ByteBuffer>(2*_set62.size);
+          for (int _i63 = 0; _i63 < _set62.size; ++_i63)
+          {
+            ByteBuffer _elem64; // required
+            _elem64 = iprot.readBinary();
+            struct.authorizations.add(_elem64);
+          }
+        }
+        struct.setAuthorizationsIsSet(true);
+      }
+      if (incoming.get(1)) {
+        {
+          org.apache.thrift.protocol.TList _list65 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.ranges = new ArrayList<Range>(_list65.size);
+          for (int _i66 = 0; _i66 < _list65.size; ++_i66)
+          {
+            Range _elem67; // required
+            _elem67 = new Range();
+            _elem67.read(iprot);
+            struct.ranges.add(_elem67);
+          }
+        }
+        struct.setRangesIsSet(true);
+      }
+      if (incoming.get(2)) {
+        {
+          org.apache.thrift.protocol.TList _list68 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.columns = new ArrayList<ScanColumn>(_list68.size);
+          for (int _i69 = 0; _i69 < _list68.size; ++_i69)
+          {
+            ScanColumn _elem70; // required
+            _elem70 = new ScanColumn();
+            _elem70.read(iprot);
+            struct.columns.add(_elem70);
+          }
+        }
+        struct.setColumnsIsSet(true);
+      }
+      if (incoming.get(3)) {
+        {
+          org.apache.thrift.protocol.TList _list71 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.iterators = new ArrayList<IteratorSetting>(_list71.size);
+          for (int _i72 = 0; _i72 < _list71.size; ++_i72)
+          {
+            IteratorSetting _elem73; // required
+            _elem73 = new IteratorSetting();
+            _elem73.read(iprot);
+            struct.iterators.add(_elem73);
+          }
+        }
+        struct.setIteratorsIsSet(true);
+      }
+      if (incoming.get(4)) {
+        struct.bufferSize = iprot.readI32();
+        struct.setBufferSizeIsSet(true);
+      }
+    }
+  }
+
+}
+

Propchange: accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/BatchScanOptions.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ScanColumn.java
URL: http://svn.apache.org/viewvc/accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ScanColumn.java?rev=1437820&view=auto
==============================================================================
--- accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ScanColumn.java (added)
+++ accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ScanColumn.java Thu Jan 24 01:13:24 2013
@@ -0,0 +1,527 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.accumulo.proxy.thrift;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings("all") public class ScanColumn implements org.apache.thrift.TBase<ScanColumn, ScanColumn._Fields>, java.io.Serializable, Cloneable {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ScanColumn");
+
+  private static final org.apache.thrift.protocol.TField COL_FAMILY_FIELD_DESC = new org.apache.thrift.protocol.TField("colFamily", org.apache.thrift.protocol.TType.STRING, (short)1);
+  private static final org.apache.thrift.protocol.TField COL_QUALIFIER_FIELD_DESC = new org.apache.thrift.protocol.TField("colQualifier", org.apache.thrift.protocol.TType.STRING, (short)2);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new ScanColumnStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new ScanColumnTupleSchemeFactory());
+  }
+
+  public ByteBuffer colFamily; // required
+  public ByteBuffer colQualifier; // optional
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    COL_FAMILY((short)1, "colFamily"),
+    COL_QUALIFIER((short)2, "colQualifier");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // COL_FAMILY
+          return COL_FAMILY;
+        case 2: // COL_QUALIFIER
+          return COL_QUALIFIER;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  private _Fields optionals[] = {_Fields.COL_QUALIFIER};
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.COL_FAMILY, new org.apache.thrift.meta_data.FieldMetaData("colFamily", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , true)));
+    tmpMap.put(_Fields.COL_QUALIFIER, new org.apache.thrift.meta_data.FieldMetaData("colQualifier", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , true)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ScanColumn.class, metaDataMap);
+  }
+
+  public ScanColumn() {
+  }
+
+  public ScanColumn(
+    ByteBuffer colFamily)
+  {
+    this();
+    this.colFamily = colFamily;
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public ScanColumn(ScanColumn other) {
+    if (other.isSetColFamily()) {
+      this.colFamily = org.apache.thrift.TBaseHelper.copyBinary(other.colFamily);
+;
+    }
+    if (other.isSetColQualifier()) {
+      this.colQualifier = org.apache.thrift.TBaseHelper.copyBinary(other.colQualifier);
+;
+    }
+  }
+
+  public ScanColumn deepCopy() {
+    return new ScanColumn(this);
+  }
+
+  @Override
+  public void clear() {
+    this.colFamily = null;
+    this.colQualifier = null;
+  }
+
+  public byte[] getColFamily() {
+    setColFamily(org.apache.thrift.TBaseHelper.rightSize(colFamily));
+    return colFamily == null ? null : colFamily.array();
+  }
+
+  public ByteBuffer bufferForColFamily() {
+    return colFamily;
+  }
+
+  public ScanColumn setColFamily(byte[] colFamily) {
+    setColFamily(colFamily == null ? (ByteBuffer)null : ByteBuffer.wrap(colFamily));
+    return this;
+  }
+
+  public ScanColumn setColFamily(ByteBuffer colFamily) {
+    this.colFamily = colFamily;
+    return this;
+  }
+
+  public void unsetColFamily() {
+    this.colFamily = null;
+  }
+
+  /** Returns true if field colFamily is set (has been assigned a value) and false otherwise */
+  public boolean isSetColFamily() {
+    return this.colFamily != null;
+  }
+
+  public void setColFamilyIsSet(boolean value) {
+    if (!value) {
+      this.colFamily = null;
+    }
+  }
+
+  public byte[] getColQualifier() {
+    setColQualifier(org.apache.thrift.TBaseHelper.rightSize(colQualifier));
+    return colQualifier == null ? null : colQualifier.array();
+  }
+
+  public ByteBuffer bufferForColQualifier() {
+    return colQualifier;
+  }
+
+  public ScanColumn setColQualifier(byte[] colQualifier) {
+    setColQualifier(colQualifier == null ? (ByteBuffer)null : ByteBuffer.wrap(colQualifier));
+    return this;
+  }
+
+  public ScanColumn setColQualifier(ByteBuffer colQualifier) {
+    this.colQualifier = colQualifier;
+    return this;
+  }
+
+  public void unsetColQualifier() {
+    this.colQualifier = null;
+  }
+
+  /** Returns true if field colQualifier is set (has been assigned a value) and false otherwise */
+  public boolean isSetColQualifier() {
+    return this.colQualifier != null;
+  }
+
+  public void setColQualifierIsSet(boolean value) {
+    if (!value) {
+      this.colQualifier = null;
+    }
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case COL_FAMILY:
+      if (value == null) {
+        unsetColFamily();
+      } else {
+        setColFamily((ByteBuffer)value);
+      }
+      break;
+
+    case COL_QUALIFIER:
+      if (value == null) {
+        unsetColQualifier();
+      } else {
+        setColQualifier((ByteBuffer)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case COL_FAMILY:
+      return getColFamily();
+
+    case COL_QUALIFIER:
+      return getColQualifier();
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case COL_FAMILY:
+      return isSetColFamily();
+    case COL_QUALIFIER:
+      return isSetColQualifier();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof ScanColumn)
+      return this.equals((ScanColumn)that);
+    return false;
+  }
+
+  public boolean equals(ScanColumn that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_colFamily = true && this.isSetColFamily();
+    boolean that_present_colFamily = true && that.isSetColFamily();
+    if (this_present_colFamily || that_present_colFamily) {
+      if (!(this_present_colFamily && that_present_colFamily))
+        return false;
+      if (!this.colFamily.equals(that.colFamily))
+        return false;
+    }
+
+    boolean this_present_colQualifier = true && this.isSetColQualifier();
+    boolean that_present_colQualifier = true && that.isSetColQualifier();
+    if (this_present_colQualifier || that_present_colQualifier) {
+      if (!(this_present_colQualifier && that_present_colQualifier))
+        return false;
+      if (!this.colQualifier.equals(that.colQualifier))
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    return 0;
+  }
+
+  public int compareTo(ScanColumn other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+    ScanColumn typedOther = (ScanColumn)other;
+
+    lastComparison = Boolean.valueOf(isSetColFamily()).compareTo(typedOther.isSetColFamily());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetColFamily()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.colFamily, typedOther.colFamily);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetColQualifier()).compareTo(typedOther.isSetColQualifier());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetColQualifier()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.colQualifier, typedOther.colQualifier);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("ScanColumn(");
+    boolean first = true;
+
+    sb.append("colFamily:");
+    if (this.colFamily == null) {
+      sb.append("null");
+    } else {
+      org.apache.thrift.TBaseHelper.toString(this.colFamily, sb);
+    }
+    first = false;
+    if (isSetColQualifier()) {
+      if (!first) sb.append(", ");
+      sb.append("colQualifier:");
+      if (this.colQualifier == null) {
+        sb.append("null");
+      } else {
+        org.apache.thrift.TBaseHelper.toString(this.colQualifier, sb);
+      }
+      first = false;
+    }
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    // check for sub-struct validity
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class ScanColumnStandardSchemeFactory implements SchemeFactory {
+    public ScanColumnStandardScheme getScheme() {
+      return new ScanColumnStandardScheme();
+    }
+  }
+
+  private static class ScanColumnStandardScheme extends StandardScheme<ScanColumn> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, ScanColumn struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // COL_FAMILY
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.colFamily = iprot.readBinary();
+              struct.setColFamilyIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // COL_QUALIFIER
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.colQualifier = iprot.readBinary();
+              struct.setColQualifierIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+
+      // check for required fields of primitive type, which can't be checked in the validate method
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, ScanColumn struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (struct.colFamily != null) {
+        oprot.writeFieldBegin(COL_FAMILY_FIELD_DESC);
+        oprot.writeBinary(struct.colFamily);
+        oprot.writeFieldEnd();
+      }
+      if (struct.colQualifier != null) {
+        if (struct.isSetColQualifier()) {
+          oprot.writeFieldBegin(COL_QUALIFIER_FIELD_DESC);
+          oprot.writeBinary(struct.colQualifier);
+          oprot.writeFieldEnd();
+        }
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class ScanColumnTupleSchemeFactory implements SchemeFactory {
+    public ScanColumnTupleScheme getScheme() {
+      return new ScanColumnTupleScheme();
+    }
+  }
+
+  private static class ScanColumnTupleScheme extends TupleScheme<ScanColumn> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, ScanColumn struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      BitSet optionals = new BitSet();
+      if (struct.isSetColFamily()) {
+        optionals.set(0);
+      }
+      if (struct.isSetColQualifier()) {
+        optionals.set(1);
+      }
+      oprot.writeBitSet(optionals, 2);
+      if (struct.isSetColFamily()) {
+        oprot.writeBinary(struct.colFamily);
+      }
+      if (struct.isSetColQualifier()) {
+        oprot.writeBinary(struct.colQualifier);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, ScanColumn struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      BitSet incoming = iprot.readBitSet(2);
+      if (incoming.get(0)) {
+        struct.colFamily = iprot.readBinary();
+        struct.setColFamilyIsSet(true);
+      }
+      if (incoming.get(1)) {
+        struct.colQualifier = iprot.readBinary();
+        struct.setColQualifierIsSet(true);
+      }
+    }
+  }
+
+}
+

Propchange: accumulo/trunk/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ScanColumn.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message