accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From vi...@apache.org
Subject [16/17] ACCUMULO-2197 updating files for this version
Date Tue, 04 Feb 2014 22:19:53 GMT
http://git-wip-us.apache.org/repos/asf/accumulo/blob/3298263a/proxy/src/main/cpp/AccumuloProxy.cpp
----------------------------------------------------------------------
diff --git a/proxy/src/main/cpp/AccumuloProxy.cpp b/proxy/src/main/cpp/AccumuloProxy.cpp
index 2717c2c..d700ed4 100644
--- a/proxy/src/main/cpp/AccumuloProxy.cpp
+++ b/proxy/src/main/cpp/AccumuloProxy.cpp
@@ -56,17 +56,17 @@ uint32_t AccumuloProxy_login_args::read(::apache::thrift::protocol::TProtocol* i
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->loginProperties.clear();
-            uint32_t _size92;
-            ::apache::thrift::protocol::TType _ktype93;
-            ::apache::thrift::protocol::TType _vtype94;
-            xfer += iprot->readMapBegin(_ktype93, _vtype94, _size92);
-            uint32_t _i96;
-            for (_i96 = 0; _i96 < _size92; ++_i96)
+            uint32_t _size123;
+            ::apache::thrift::protocol::TType _ktype124;
+            ::apache::thrift::protocol::TType _vtype125;
+            xfer += iprot->readMapBegin(_ktype124, _vtype125, _size123);
+            uint32_t _i127;
+            for (_i127 = 0; _i127 < _size123; ++_i127)
             {
-              std::string _key97;
-              xfer += iprot->readString(_key97);
-              std::string& _val98 = this->loginProperties[_key97];
-              xfer += iprot->readString(_val98);
+              std::string _key128;
+              xfer += iprot->readString(_key128);
+              std::string& _val129 = this->loginProperties[_key128];
+              xfer += iprot->readString(_val129);
             }
             xfer += iprot->readMapEnd();
           }
@@ -98,11 +98,11 @@ uint32_t AccumuloProxy_login_args::write(::apache::thrift::protocol::TProtocol*
   xfer += oprot->writeFieldBegin("loginProperties", ::apache::thrift::protocol::T_MAP, 2);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->loginProperties.size()));
-    std::map<std::string, std::string> ::const_iterator _iter99;
-    for (_iter99 = this->loginProperties.begin(); _iter99 != this->loginProperties.end(); ++_iter99)
+    std::map<std::string, std::string> ::const_iterator _iter130;
+    for (_iter130 = this->loginProperties.begin(); _iter130 != this->loginProperties.end(); ++_iter130)
     {
-      xfer += oprot->writeString(_iter99->first);
-      xfer += oprot->writeString(_iter99->second);
+      xfer += oprot->writeString(_iter130->first);
+      xfer += oprot->writeString(_iter130->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -124,11 +124,11 @@ uint32_t AccumuloProxy_login_pargs::write(::apache::thrift::protocol::TProtocol*
   xfer += oprot->writeFieldBegin("loginProperties", ::apache::thrift::protocol::T_MAP, 2);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->loginProperties)).size()));
-    std::map<std::string, std::string> ::const_iterator _iter100;
-    for (_iter100 = (*(this->loginProperties)).begin(); _iter100 != (*(this->loginProperties)).end(); ++_iter100)
+    std::map<std::string, std::string> ::const_iterator _iter131;
+    for (_iter131 = (*(this->loginProperties)).begin(); _iter131 != (*(this->loginProperties)).end(); ++_iter131)
     {
-      xfer += oprot->writeString(_iter100->first);
-      xfer += oprot->writeString(_iter100->second);
+      xfer += oprot->writeString(_iter131->first);
+      xfer += oprot->writeString(_iter131->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -549,15 +549,15 @@ uint32_t AccumuloProxy_addSplits_args::read(::apache::thrift::protocol::TProtoco
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->splits.clear();
-            uint32_t _size101;
-            ::apache::thrift::protocol::TType _etype104;
-            xfer += iprot->readSetBegin(_etype104, _size101);
-            uint32_t _i105;
-            for (_i105 = 0; _i105 < _size101; ++_i105)
+            uint32_t _size132;
+            ::apache::thrift::protocol::TType _etype135;
+            xfer += iprot->readSetBegin(_etype135, _size132);
+            uint32_t _i136;
+            for (_i136 = 0; _i136 < _size132; ++_i136)
             {
-              std::string _elem106;
-              xfer += iprot->readBinary(_elem106);
-              this->splits.insert(_elem106);
+              std::string _elem137;
+              xfer += iprot->readBinary(_elem137);
+              this->splits.insert(_elem137);
             }
             xfer += iprot->readSetEnd();
           }
@@ -593,10 +593,10 @@ uint32_t AccumuloProxy_addSplits_args::write(::apache::thrift::protocol::TProtoc
   xfer += oprot->writeFieldBegin("splits", ::apache::thrift::protocol::T_SET, 3);
   {
     xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->splits.size()));
-    std::set<std::string> ::const_iterator _iter107;
-    for (_iter107 = this->splits.begin(); _iter107 != this->splits.end(); ++_iter107)
+    std::set<std::string> ::const_iterator _iter138;
+    for (_iter138 = this->splits.begin(); _iter138 != this->splits.end(); ++_iter138)
     {
-      xfer += oprot->writeBinary((*_iter107));
+      xfer += oprot->writeBinary((*_iter138));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -622,10 +622,10 @@ uint32_t AccumuloProxy_addSplits_pargs::write(::apache::thrift::protocol::TProto
   xfer += oprot->writeFieldBegin("splits", ::apache::thrift::protocol::T_SET, 3);
   {
     xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->splits)).size()));
-    std::set<std::string> ::const_iterator _iter108;
-    for (_iter108 = (*(this->splits)).begin(); _iter108 != (*(this->splits)).end(); ++_iter108)
+    std::set<std::string> ::const_iterator _iter139;
+    for (_iter139 = (*(this->splits)).begin(); _iter139 != (*(this->splits)).end(); ++_iter139)
     {
-      xfer += oprot->writeBinary((*_iter108));
+      xfer += oprot->writeBinary((*_iter139));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -820,17 +820,17 @@ uint32_t AccumuloProxy_attachIterator_args::read(::apache::thrift::protocol::TPr
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->scopes.clear();
-            uint32_t _size109;
-            ::apache::thrift::protocol::TType _etype112;
-            xfer += iprot->readSetBegin(_etype112, _size109);
-            uint32_t _i113;
-            for (_i113 = 0; _i113 < _size109; ++_i113)
+            uint32_t _size140;
+            ::apache::thrift::protocol::TType _etype143;
+            xfer += iprot->readSetBegin(_etype143, _size140);
+            uint32_t _i144;
+            for (_i144 = 0; _i144 < _size140; ++_i144)
             {
-              IteratorScope::type _elem114;
-              int32_t ecast115;
-              xfer += iprot->readI32(ecast115);
-              _elem114 = (IteratorScope::type)ecast115;
-              this->scopes.insert(_elem114);
+              IteratorScope::type _elem145;
+              int32_t ecast146;
+              xfer += iprot->readI32(ecast146);
+              _elem145 = (IteratorScope::type)ecast146;
+              this->scopes.insert(_elem145);
             }
             xfer += iprot->readSetEnd();
           }
@@ -870,10 +870,10 @@ uint32_t AccumuloProxy_attachIterator_args::write(::apache::thrift::protocol::TP
   xfer += oprot->writeFieldBegin("scopes", ::apache::thrift::protocol::T_SET, 4);
   {
     xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->scopes.size()));
-    std::set<IteratorScope::type> ::const_iterator _iter116;
-    for (_iter116 = this->scopes.begin(); _iter116 != this->scopes.end(); ++_iter116)
+    std::set<IteratorScope::type> ::const_iterator _iter147;
+    for (_iter147 = this->scopes.begin(); _iter147 != this->scopes.end(); ++_iter147)
     {
-      xfer += oprot->writeI32((int32_t)(*_iter116));
+      xfer += oprot->writeI32((int32_t)(*_iter147));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -903,10 +903,10 @@ uint32_t AccumuloProxy_attachIterator_pargs::write(::apache::thrift::protocol::T
   xfer += oprot->writeFieldBegin("scopes", ::apache::thrift::protocol::T_SET, 4);
   {
     xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>((*(this->scopes)).size()));
-    std::set<IteratorScope::type> ::const_iterator _iter117;
-    for (_iter117 = (*(this->scopes)).begin(); _iter117 != (*(this->scopes)).end(); ++_iter117)
+    std::set<IteratorScope::type> ::const_iterator _iter148;
+    for (_iter148 = (*(this->scopes)).begin(); _iter148 != (*(this->scopes)).end(); ++_iter148)
     {
-      xfer += oprot->writeI32((int32_t)(*_iter117));
+      xfer += oprot->writeI32((int32_t)(*_iter148));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -1101,17 +1101,17 @@ uint32_t AccumuloProxy_checkIteratorConflicts_args::read(::apache::thrift::proto
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->scopes.clear();
-            uint32_t _size118;
-            ::apache::thrift::protocol::TType _etype121;
-            xfer += iprot->readSetBegin(_etype121, _size118);
-            uint32_t _i122;
-            for (_i122 = 0; _i122 < _size118; ++_i122)
+            uint32_t _size149;
+            ::apache::thrift::protocol::TType _etype152;
+            xfer += iprot->readSetBegin(_etype152, _size149);
+            uint32_t _i153;
+            for (_i153 = 0; _i153 < _size149; ++_i153)
             {
-              IteratorScope::type _elem123;
-              int32_t ecast124;
-              xfer += iprot->readI32(ecast124);
-              _elem123 = (IteratorScope::type)ecast124;
-              this->scopes.insert(_elem123);
+              IteratorScope::type _elem154;
+              int32_t ecast155;
+              xfer += iprot->readI32(ecast155);
+              _elem154 = (IteratorScope::type)ecast155;
+              this->scopes.insert(_elem154);
             }
             xfer += iprot->readSetEnd();
           }
@@ -1151,10 +1151,10 @@ uint32_t AccumuloProxy_checkIteratorConflicts_args::write(::apache::thrift::prot
   xfer += oprot->writeFieldBegin("scopes", ::apache::thrift::protocol::T_SET, 4);
   {
     xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->scopes.size()));
-    std::set<IteratorScope::type> ::const_iterator _iter125;
-    for (_iter125 = this->scopes.begin(); _iter125 != this->scopes.end(); ++_iter125)
+    std::set<IteratorScope::type> ::const_iterator _iter156;
+    for (_iter156 = this->scopes.begin(); _iter156 != this->scopes.end(); ++_iter156)
     {
-      xfer += oprot->writeI32((int32_t)(*_iter125));
+      xfer += oprot->writeI32((int32_t)(*_iter156));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -1184,10 +1184,10 @@ uint32_t AccumuloProxy_checkIteratorConflicts_pargs::write(::apache::thrift::pro
   xfer += oprot->writeFieldBegin("scopes", ::apache::thrift::protocol::T_SET, 4);
   {
     xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>((*(this->scopes)).size()));
-    std::set<IteratorScope::type> ::const_iterator _iter126;
-    for (_iter126 = (*(this->scopes)).begin(); _iter126 != (*(this->scopes)).end(); ++_iter126)
+    std::set<IteratorScope::type> ::const_iterator _iter157;
+    for (_iter157 = (*(this->scopes)).begin(); _iter157 != (*(this->scopes)).end(); ++_iter157)
     {
-      xfer += oprot->writeI32((int32_t)(*_iter126));
+      xfer += oprot->writeI32((int32_t)(*_iter157));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -1568,17 +1568,17 @@ uint32_t AccumuloProxy_cloneTable_args::read(::apache::thrift::protocol::TProtoc
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->propertiesToSet.clear();
-            uint32_t _size127;
-            ::apache::thrift::protocol::TType _ktype128;
-            ::apache::thrift::protocol::TType _vtype129;
-            xfer += iprot->readMapBegin(_ktype128, _vtype129, _size127);
-            uint32_t _i131;
-            for (_i131 = 0; _i131 < _size127; ++_i131)
+            uint32_t _size158;
+            ::apache::thrift::protocol::TType _ktype159;
+            ::apache::thrift::protocol::TType _vtype160;
+            xfer += iprot->readMapBegin(_ktype159, _vtype160, _size158);
+            uint32_t _i162;
+            for (_i162 = 0; _i162 < _size158; ++_i162)
             {
-              std::string _key132;
-              xfer += iprot->readString(_key132);
-              std::string& _val133 = this->propertiesToSet[_key132];
-              xfer += iprot->readString(_val133);
+              std::string _key163;
+              xfer += iprot->readString(_key163);
+              std::string& _val164 = this->propertiesToSet[_key163];
+              xfer += iprot->readString(_val164);
             }
             xfer += iprot->readMapEnd();
           }
@@ -1591,15 +1591,15 @@ uint32_t AccumuloProxy_cloneTable_args::read(::apache::thrift::protocol::TProtoc
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->propertiesToExclude.clear();
-            uint32_t _size134;
-            ::apache::thrift::protocol::TType _etype137;
-            xfer += iprot->readSetBegin(_etype137, _size134);
-            uint32_t _i138;
-            for (_i138 = 0; _i138 < _size134; ++_i138)
+            uint32_t _size165;
+            ::apache::thrift::protocol::TType _etype168;
+            xfer += iprot->readSetBegin(_etype168, _size165);
+            uint32_t _i169;
+            for (_i169 = 0; _i169 < _size165; ++_i169)
             {
-              std::string _elem139;
-              xfer += iprot->readString(_elem139);
-              this->propertiesToExclude.insert(_elem139);
+              std::string _elem170;
+              xfer += iprot->readString(_elem170);
+              this->propertiesToExclude.insert(_elem170);
             }
             xfer += iprot->readSetEnd();
           }
@@ -1643,11 +1643,11 @@ uint32_t AccumuloProxy_cloneTable_args::write(::apache::thrift::protocol::TProto
   xfer += oprot->writeFieldBegin("propertiesToSet", ::apache::thrift::protocol::T_MAP, 5);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->propertiesToSet.size()));
-    std::map<std::string, std::string> ::const_iterator _iter140;
-    for (_iter140 = this->propertiesToSet.begin(); _iter140 != this->propertiesToSet.end(); ++_iter140)
+    std::map<std::string, std::string> ::const_iterator _iter171;
+    for (_iter171 = this->propertiesToSet.begin(); _iter171 != this->propertiesToSet.end(); ++_iter171)
     {
-      xfer += oprot->writeString(_iter140->first);
-      xfer += oprot->writeString(_iter140->second);
+      xfer += oprot->writeString(_iter171->first);
+      xfer += oprot->writeString(_iter171->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -1656,10 +1656,10 @@ uint32_t AccumuloProxy_cloneTable_args::write(::apache::thrift::protocol::TProto
   xfer += oprot->writeFieldBegin("propertiesToExclude", ::apache::thrift::protocol::T_SET, 6);
   {
     xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->propertiesToExclude.size()));
-    std::set<std::string> ::const_iterator _iter141;
-    for (_iter141 = this->propertiesToExclude.begin(); _iter141 != this->propertiesToExclude.end(); ++_iter141)
+    std::set<std::string> ::const_iterator _iter172;
+    for (_iter172 = this->propertiesToExclude.begin(); _iter172 != this->propertiesToExclude.end(); ++_iter172)
     {
-      xfer += oprot->writeString((*_iter141));
+      xfer += oprot->writeString((*_iter172));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -1693,11 +1693,11 @@ uint32_t AccumuloProxy_cloneTable_pargs::write(::apache::thrift::protocol::TProt
   xfer += oprot->writeFieldBegin("propertiesToSet", ::apache::thrift::protocol::T_MAP, 5);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->propertiesToSet)).size()));
-    std::map<std::string, std::string> ::const_iterator _iter142;
-    for (_iter142 = (*(this->propertiesToSet)).begin(); _iter142 != (*(this->propertiesToSet)).end(); ++_iter142)
+    std::map<std::string, std::string> ::const_iterator _iter173;
+    for (_iter173 = (*(this->propertiesToSet)).begin(); _iter173 != (*(this->propertiesToSet)).end(); ++_iter173)
     {
-      xfer += oprot->writeString(_iter142->first);
-      xfer += oprot->writeString(_iter142->second);
+      xfer += oprot->writeString(_iter173->first);
+      xfer += oprot->writeString(_iter173->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -1706,10 +1706,10 @@ uint32_t AccumuloProxy_cloneTable_pargs::write(::apache::thrift::protocol::TProt
   xfer += oprot->writeFieldBegin("propertiesToExclude", ::apache::thrift::protocol::T_SET, 6);
   {
     xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->propertiesToExclude)).size()));
-    std::set<std::string> ::const_iterator _iter143;
-    for (_iter143 = (*(this->propertiesToExclude)).begin(); _iter143 != (*(this->propertiesToExclude)).end(); ++_iter143)
+    std::set<std::string> ::const_iterator _iter174;
+    for (_iter174 = (*(this->propertiesToExclude)).begin(); _iter174 != (*(this->propertiesToExclude)).end(); ++_iter174)
     {
-      xfer += oprot->writeString((*_iter143));
+      xfer += oprot->writeString((*_iter174));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -1932,14 +1932,14 @@ uint32_t AccumuloProxy_compactTable_args::read(::apache::thrift::protocol::TProt
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->iterators.clear();
-            uint32_t _size144;
-            ::apache::thrift::protocol::TType _etype147;
-            xfer += iprot->readListBegin(_etype147, _size144);
-            this->iterators.resize(_size144);
-            uint32_t _i148;
-            for (_i148 = 0; _i148 < _size144; ++_i148)
+            uint32_t _size175;
+            ::apache::thrift::protocol::TType _etype178;
+            xfer += iprot->readListBegin(_etype178, _size175);
+            this->iterators.resize(_size175);
+            uint32_t _i179;
+            for (_i179 = 0; _i179 < _size175; ++_i179)
             {
-              xfer += this->iterators[_i148].read(iprot);
+              xfer += this->iterators[_i179].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1999,10 +1999,10 @@ uint32_t AccumuloProxy_compactTable_args::write(::apache::thrift::protocol::TPro
   xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 5);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size()));
-    std::vector<IteratorSetting> ::const_iterator _iter149;
-    for (_iter149 = this->iterators.begin(); _iter149 != this->iterators.end(); ++_iter149)
+    std::vector<IteratorSetting> ::const_iterator _iter180;
+    for (_iter180 = this->iterators.begin(); _iter180 != this->iterators.end(); ++_iter180)
     {
-      xfer += (*_iter149).write(oprot);
+      xfer += (*_iter180).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -2044,10 +2044,10 @@ uint32_t AccumuloProxy_compactTable_pargs::write(::apache::thrift::protocol::TPr
   xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 5);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->iterators)).size()));
-    std::vector<IteratorSetting> ::const_iterator _iter150;
-    for (_iter150 = (*(this->iterators)).begin(); _iter150 != (*(this->iterators)).end(); ++_iter150)
+    std::vector<IteratorSetting> ::const_iterator _iter181;
+    for (_iter181 = (*(this->iterators)).begin(); _iter181 != (*(this->iterators)).end(); ++_iter181)
     {
-      xfer += (*_iter150).write(oprot);
+      xfer += (*_iter181).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -2466,9 +2466,9 @@ uint32_t AccumuloProxy_createTable_args::read(::apache::thrift::protocol::TProto
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast151;
-          xfer += iprot->readI32(ecast151);
-          this->type = (TimeType::type)ecast151;
+          int32_t ecast182;
+          xfer += iprot->readI32(ecast182);
+          this->type = (TimeType::type)ecast182;
           this->__isset.type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3640,7 +3640,7 @@ uint32_t AccumuloProxy_flushTable_presult::read(::apache::thrift::protocol::TPro
   return xfer;
 }
 
-uint32_t AccumuloProxy_getLocalityGroups_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getDiskUsage_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -3669,9 +3669,22 @@ uint32_t AccumuloProxy_getLocalityGroups_args::read(::apache::thrift::protocol::
         }
         break;
       case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->tableName);
-          this->__isset.tableName = true;
+        if (ftype == ::apache::thrift::protocol::T_SET) {
+          {
+            this->tables.clear();
+            uint32_t _size183;
+            ::apache::thrift::protocol::TType _etype186;
+            xfer += iprot->readSetBegin(_etype186, _size183);
+            uint32_t _i187;
+            for (_i187 = 0; _i187 < _size183; ++_i187)
+            {
+              std::string _elem188;
+              xfer += iprot->readString(_elem188);
+              this->tables.insert(_elem188);
+            }
+            xfer += iprot->readSetEnd();
+          }
+          this->__isset.tables = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -3688,16 +3701,24 @@ uint32_t AccumuloProxy_getLocalityGroups_args::read(::apache::thrift::protocol::
   return xfer;
 }
 
-uint32_t AccumuloProxy_getLocalityGroups_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getDiskUsage_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_getLocalityGroups_args");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getDiskUsage_args");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary(this->login);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2);
-  xfer += oprot->writeString(this->tableName);
+  xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_SET, 2);
+  {
+    xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tables.size()));
+    std::set<std::string> ::const_iterator _iter189;
+    for (_iter189 = this->tables.begin(); _iter189 != this->tables.end(); ++_iter189)
+    {
+      xfer += oprot->writeString((*_iter189));
+    }
+    xfer += oprot->writeSetEnd();
+  }
   xfer += oprot->writeFieldEnd();
 
   xfer += oprot->writeFieldStop();
@@ -3705,16 +3726,24 @@ uint32_t AccumuloProxy_getLocalityGroups_args::write(::apache::thrift::protocol:
   return xfer;
 }
 
-uint32_t AccumuloProxy_getLocalityGroups_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getDiskUsage_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_getLocalityGroups_pargs");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getDiskUsage_pargs");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary((*(this->login)));
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2);
-  xfer += oprot->writeString((*(this->tableName)));
+  xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_SET, 2);
+  {
+    xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tables)).size()));
+    std::set<std::string> ::const_iterator _iter190;
+    for (_iter190 = (*(this->tables)).begin(); _iter190 != (*(this->tables)).end(); ++_iter190)
+    {
+      xfer += oprot->writeString((*_iter190));
+    }
+    xfer += oprot->writeSetEnd();
+  }
   xfer += oprot->writeFieldEnd();
 
   xfer += oprot->writeFieldStop();
@@ -3722,7 +3751,7 @@ uint32_t AccumuloProxy_getLocalityGroups_pargs::write(::apache::thrift::protocol
   return xfer;
 }
 
-uint32_t AccumuloProxy_getLocalityGroups_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getDiskUsage_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -3743,35 +3772,19 @@ uint32_t AccumuloProxy_getLocalityGroups_result::read(::apache::thrift::protocol
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_MAP) {
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->success.clear();
-            uint32_t _size152;
-            ::apache::thrift::protocol::TType _ktype153;
-            ::apache::thrift::protocol::TType _vtype154;
-            xfer += iprot->readMapBegin(_ktype153, _vtype154, _size152);
-            uint32_t _i156;
-            for (_i156 = 0; _i156 < _size152; ++_i156)
+            uint32_t _size191;
+            ::apache::thrift::protocol::TType _etype194;
+            xfer += iprot->readListBegin(_etype194, _size191);
+            this->success.resize(_size191);
+            uint32_t _i195;
+            for (_i195 = 0; _i195 < _size191; ++_i195)
             {
-              std::string _key157;
-              xfer += iprot->readString(_key157);
-              std::set<std::string> & _val158 = this->success[_key157];
-              {
-                _val158.clear();
-                uint32_t _size159;
-                ::apache::thrift::protocol::TType _etype162;
-                xfer += iprot->readSetBegin(_etype162, _size159);
-                uint32_t _i163;
-                for (_i163 = 0; _i163 < _size159; ++_i163)
-                {
-                  std::string _elem164;
-                  xfer += iprot->readString(_elem164);
-                  _val158.insert(_elem164);
-                }
-                xfer += iprot->readSetEnd();
-              }
+              xfer += this->success[_i195].read(iprot);
             }
-            xfer += iprot->readMapEnd();
+            xfer += iprot->readListEnd();
           }
           this->__isset.success = true;
         } else {
@@ -3814,31 +3827,22 @@ uint32_t AccumuloProxy_getLocalityGroups_result::read(::apache::thrift::protocol
   return xfer;
 }
 
-uint32_t AccumuloProxy_getLocalityGroups_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getDiskUsage_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("AccumuloProxy_getLocalityGroups_result");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getDiskUsage_result");
 
   if (this->__isset.success) {
-    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
     {
-      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_SET, static_cast<uint32_t>(this->success.size()));
-      std::map<std::string, std::set<std::string> > ::const_iterator _iter165;
-      for (_iter165 = this->success.begin(); _iter165 != this->success.end(); ++_iter165)
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::vector<DiskUsage> ::const_iterator _iter196;
+      for (_iter196 = this->success.begin(); _iter196 != this->success.end(); ++_iter196)
       {
-        xfer += oprot->writeString(_iter165->first);
-        {
-          xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter165->second.size()));
-          std::set<std::string> ::const_iterator _iter166;
-          for (_iter166 = _iter165->second.begin(); _iter166 != _iter165->second.end(); ++_iter166)
-          {
-            xfer += oprot->writeString((*_iter166));
-          }
-          xfer += oprot->writeSetEnd();
-        }
+        xfer += (*_iter196).write(oprot);
       }
-      xfer += oprot->writeMapEnd();
+      xfer += oprot->writeListEnd();
     }
     xfer += oprot->writeFieldEnd();
   } else if (this->__isset.ouch1) {
@@ -3859,7 +3863,7 @@ uint32_t AccumuloProxy_getLocalityGroups_result::write(::apache::thrift::protoco
   return xfer;
 }
 
-uint32_t AccumuloProxy_getLocalityGroups_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getDiskUsage_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -3880,35 +3884,19 @@ uint32_t AccumuloProxy_getLocalityGroups_presult::read(::apache::thrift::protoco
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_MAP) {
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             (*(this->success)).clear();
-            uint32_t _size167;
-            ::apache::thrift::protocol::TType _ktype168;
-            ::apache::thrift::protocol::TType _vtype169;
-            xfer += iprot->readMapBegin(_ktype168, _vtype169, _size167);
-            uint32_t _i171;
-            for (_i171 = 0; _i171 < _size167; ++_i171)
+            uint32_t _size197;
+            ::apache::thrift::protocol::TType _etype200;
+            xfer += iprot->readListBegin(_etype200, _size197);
+            (*(this->success)).resize(_size197);
+            uint32_t _i201;
+            for (_i201 = 0; _i201 < _size197; ++_i201)
             {
-              std::string _key172;
-              xfer += iprot->readString(_key172);
-              std::set<std::string> & _val173 = (*(this->success))[_key172];
-              {
-                _val173.clear();
-                uint32_t _size174;
-                ::apache::thrift::protocol::TType _etype177;
-                xfer += iprot->readSetBegin(_etype177, _size174);
-                uint32_t _i178;
-                for (_i178 = 0; _i178 < _size174; ++_i178)
-                {
-                  std::string _elem179;
-                  xfer += iprot->readString(_elem179);
-                  _val173.insert(_elem179);
-                }
-                xfer += iprot->readSetEnd();
-              }
+              xfer += (*(this->success))[_i201].read(iprot);
             }
-            xfer += iprot->readMapEnd();
+            xfer += iprot->readListEnd();
           }
           this->__isset.success = true;
         } else {
@@ -3951,7 +3939,7 @@ uint32_t AccumuloProxy_getLocalityGroups_presult::read(::apache::thrift::protoco
   return xfer;
 }
 
-uint32_t AccumuloProxy_getIteratorSetting_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getLocalityGroups_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -3987,24 +3975,6 @@ uint32_t AccumuloProxy_getIteratorSetting_args::read(::apache::thrift::protocol:
           xfer += iprot->skip(ftype);
         }
         break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->iteratorName);
-          this->__isset.iteratorName = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast180;
-          xfer += iprot->readI32(ecast180);
-          this->scope = (IteratorScope::type)ecast180;
-          this->__isset.scope = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -4017,9 +3987,9 @@ uint32_t AccumuloProxy_getIteratorSetting_args::read(::apache::thrift::protocol:
   return xfer;
 }
 
-uint32_t AccumuloProxy_getIteratorSetting_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getLocalityGroups_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_getIteratorSetting_args");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getLocalityGroups_args");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary(this->login);
@@ -4029,22 +3999,14 @@ uint32_t AccumuloProxy_getIteratorSetting_args::write(::apache::thrift::protocol
   xfer += oprot->writeString(this->tableName);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("iteratorName", ::apache::thrift::protocol::T_STRING, 3);
-  xfer += oprot->writeString(this->iteratorName);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("scope", ::apache::thrift::protocol::T_I32, 4);
-  xfer += oprot->writeI32((int32_t)this->scope);
-  xfer += oprot->writeFieldEnd();
-
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-uint32_t AccumuloProxy_getIteratorSetting_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getLocalityGroups_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_getIteratorSetting_pargs");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getLocalityGroups_pargs");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary((*(this->login)));
@@ -4054,20 +4016,12 @@ uint32_t AccumuloProxy_getIteratorSetting_pargs::write(::apache::thrift::protoco
   xfer += oprot->writeString((*(this->tableName)));
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("iteratorName", ::apache::thrift::protocol::T_STRING, 3);
-  xfer += oprot->writeString((*(this->iteratorName)));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("scope", ::apache::thrift::protocol::T_I32, 4);
-  xfer += oprot->writeI32((int32_t)(*(this->scope)));
-  xfer += oprot->writeFieldEnd();
-
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-uint32_t AccumuloProxy_getIteratorSetting_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getLocalityGroups_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -4088,8 +4042,36 @@ uint32_t AccumuloProxy_getIteratorSetting_result::read(::apache::thrift::protoco
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->success.read(iprot);
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->success.clear();
+            uint32_t _size202;
+            ::apache::thrift::protocol::TType _ktype203;
+            ::apache::thrift::protocol::TType _vtype204;
+            xfer += iprot->readMapBegin(_ktype203, _vtype204, _size202);
+            uint32_t _i206;
+            for (_i206 = 0; _i206 < _size202; ++_i206)
+            {
+              std::string _key207;
+              xfer += iprot->readString(_key207);
+              std::set<std::string> & _val208 = this->success[_key207];
+              {
+                _val208.clear();
+                uint32_t _size209;
+                ::apache::thrift::protocol::TType _etype212;
+                xfer += iprot->readSetBegin(_etype212, _size209);
+                uint32_t _i213;
+                for (_i213 = 0; _i213 < _size209; ++_i213)
+                {
+                  std::string _elem214;
+                  xfer += iprot->readString(_elem214);
+                  _val208.insert(_elem214);
+                }
+                xfer += iprot->readSetEnd();
+              }
+            }
+            xfer += iprot->readMapEnd();
+          }
           this->__isset.success = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4131,15 +4113,32 @@ uint32_t AccumuloProxy_getIteratorSetting_result::read(::apache::thrift::protoco
   return xfer;
 }
 
-uint32_t AccumuloProxy_getIteratorSetting_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getLocalityGroups_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("AccumuloProxy_getIteratorSetting_result");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getLocalityGroups_result");
 
   if (this->__isset.success) {
-    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
-    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
+    {
+      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_SET, static_cast<uint32_t>(this->success.size()));
+      std::map<std::string, std::set<std::string> > ::const_iterator _iter215;
+      for (_iter215 = this->success.begin(); _iter215 != this->success.end(); ++_iter215)
+      {
+        xfer += oprot->writeString(_iter215->first);
+        {
+          xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter215->second.size()));
+          std::set<std::string> ::const_iterator _iter216;
+          for (_iter216 = _iter215->second.begin(); _iter216 != _iter215->second.end(); ++_iter216)
+          {
+            xfer += oprot->writeString((*_iter216));
+          }
+          xfer += oprot->writeSetEnd();
+        }
+      }
+      xfer += oprot->writeMapEnd();
+    }
     xfer += oprot->writeFieldEnd();
   } else if (this->__isset.ouch1) {
     xfer += oprot->writeFieldBegin("ouch1", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -4159,7 +4158,7 @@ uint32_t AccumuloProxy_getIteratorSetting_result::write(::apache::thrift::protoc
   return xfer;
 }
 
-uint32_t AccumuloProxy_getIteratorSetting_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getLocalityGroups_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -4180,8 +4179,36 @@ uint32_t AccumuloProxy_getIteratorSetting_presult::read(::apache::thrift::protoc
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += (*(this->success)).read(iprot);
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size217;
+            ::apache::thrift::protocol::TType _ktype218;
+            ::apache::thrift::protocol::TType _vtype219;
+            xfer += iprot->readMapBegin(_ktype218, _vtype219, _size217);
+            uint32_t _i221;
+            for (_i221 = 0; _i221 < _size217; ++_i221)
+            {
+              std::string _key222;
+              xfer += iprot->readString(_key222);
+              std::set<std::string> & _val223 = (*(this->success))[_key222];
+              {
+                _val223.clear();
+                uint32_t _size224;
+                ::apache::thrift::protocol::TType _etype227;
+                xfer += iprot->readSetBegin(_etype227, _size224);
+                uint32_t _i228;
+                for (_i228 = 0; _i228 < _size224; ++_i228)
+                {
+                  std::string _elem229;
+                  xfer += iprot->readString(_elem229);
+                  _val223.insert(_elem229);
+                }
+                xfer += iprot->readSetEnd();
+              }
+            }
+            xfer += iprot->readMapEnd();
+          }
           this->__isset.success = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4223,7 +4250,7 @@ uint32_t AccumuloProxy_getIteratorSetting_presult::read(::apache::thrift::protoc
   return xfer;
 }
 
-uint32_t AccumuloProxy_getMaxRow_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getIteratorSetting_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -4260,54 +4287,19 @@ uint32_t AccumuloProxy_getMaxRow_args::read(::apache::thrift::protocol::TProtoco
         }
         break;
       case 3:
-        if (ftype == ::apache::thrift::protocol::T_SET) {
-          {
-            this->auths.clear();
-            uint32_t _size181;
-            ::apache::thrift::protocol::TType _etype184;
-            xfer += iprot->readSetBegin(_etype184, _size181);
-            uint32_t _i185;
-            for (_i185 = 0; _i185 < _size181; ++_i185)
-            {
-              std::string _elem186;
-              xfer += iprot->readBinary(_elem186);
-              this->auths.insert(_elem186);
-            }
-            xfer += iprot->readSetEnd();
-          }
-          this->__isset.auths = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->startRow);
-          this->__isset.startRow = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->startInclusive);
-          this->__isset.startInclusive = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->endRow);
-          this->__isset.endRow = true;
+          xfer += iprot->readString(this->iteratorName);
+          this->__isset.iteratorName = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->endInclusive);
-          this->__isset.endInclusive = true;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast230;
+          xfer += iprot->readI32(ecast230);
+          this->scope = (IteratorScope::type)ecast230;
+          this->__isset.scope = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -4324,9 +4316,9 @@ uint32_t AccumuloProxy_getMaxRow_args::read(::apache::thrift::protocol::TProtoco
   return xfer;
 }
 
-uint32_t AccumuloProxy_getMaxRow_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getIteratorSetting_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_getMaxRow_args");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getIteratorSetting_args");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary(this->login);
@@ -4336,32 +4328,12 @@ uint32_t AccumuloProxy_getMaxRow_args::write(::apache::thrift::protocol::TProtoc
   xfer += oprot->writeString(this->tableName);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("auths", ::apache::thrift::protocol::T_SET, 3);
-  {
-    xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->auths.size()));
-    std::set<std::string> ::const_iterator _iter187;
-    for (_iter187 = this->auths.begin(); _iter187 != this->auths.end(); ++_iter187)
-    {
-      xfer += oprot->writeBinary((*_iter187));
-    }
-    xfer += oprot->writeSetEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 4);
-  xfer += oprot->writeBinary(this->startRow);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("startInclusive", ::apache::thrift::protocol::T_BOOL, 5);
-  xfer += oprot->writeBool(this->startInclusive);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("endRow", ::apache::thrift::protocol::T_STRING, 6);
-  xfer += oprot->writeBinary(this->endRow);
+  xfer += oprot->writeFieldBegin("iteratorName", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->iteratorName);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("endInclusive", ::apache::thrift::protocol::T_BOOL, 7);
-  xfer += oprot->writeBool(this->endInclusive);
+  xfer += oprot->writeFieldBegin("scope", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->scope);
   xfer += oprot->writeFieldEnd();
 
   xfer += oprot->writeFieldStop();
@@ -4369,9 +4341,9 @@ uint32_t AccumuloProxy_getMaxRow_args::write(::apache::thrift::protocol::TProtoc
   return xfer;
 }
 
-uint32_t AccumuloProxy_getMaxRow_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getIteratorSetting_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_getMaxRow_pargs");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getIteratorSetting_pargs");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary((*(this->login)));
@@ -4381,32 +4353,12 @@ uint32_t AccumuloProxy_getMaxRow_pargs::write(::apache::thrift::protocol::TProto
   xfer += oprot->writeString((*(this->tableName)));
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("auths", ::apache::thrift::protocol::T_SET, 3);
-  {
-    xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->auths)).size()));
-    std::set<std::string> ::const_iterator _iter188;
-    for (_iter188 = (*(this->auths)).begin(); _iter188 != (*(this->auths)).end(); ++_iter188)
-    {
-      xfer += oprot->writeBinary((*_iter188));
-    }
-    xfer += oprot->writeSetEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 4);
-  xfer += oprot->writeBinary((*(this->startRow)));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("startInclusive", ::apache::thrift::protocol::T_BOOL, 5);
-  xfer += oprot->writeBool((*(this->startInclusive)));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("endRow", ::apache::thrift::protocol::T_STRING, 6);
-  xfer += oprot->writeBinary((*(this->endRow)));
+  xfer += oprot->writeFieldBegin("iteratorName", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString((*(this->iteratorName)));
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("endInclusive", ::apache::thrift::protocol::T_BOOL, 7);
-  xfer += oprot->writeBool((*(this->endInclusive)));
+  xfer += oprot->writeFieldBegin("scope", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)(*(this->scope)));
   xfer += oprot->writeFieldEnd();
 
   xfer += oprot->writeFieldStop();
@@ -4414,7 +4366,7 @@ uint32_t AccumuloProxy_getMaxRow_pargs::write(::apache::thrift::protocol::TProto
   return xfer;
 }
 
-uint32_t AccumuloProxy_getMaxRow_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getIteratorSetting_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -4435,8 +4387,8 @@ uint32_t AccumuloProxy_getMaxRow_result::read(::apache::thrift::protocol::TProto
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->success);
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
           this->__isset.success = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4478,15 +4430,15 @@ uint32_t AccumuloProxy_getMaxRow_result::read(::apache::thrift::protocol::TProto
   return xfer;
 }
 
-uint32_t AccumuloProxy_getMaxRow_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getIteratorSetting_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("AccumuloProxy_getMaxRow_result");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getIteratorSetting_result");
 
   if (this->__isset.success) {
-    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
-    xfer += oprot->writeBinary(this->success);
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
     xfer += oprot->writeFieldEnd();
   } else if (this->__isset.ouch1) {
     xfer += oprot->writeFieldBegin("ouch1", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -4506,7 +4458,7 @@ uint32_t AccumuloProxy_getMaxRow_result::write(::apache::thrift::protocol::TProt
   return xfer;
 }
 
-uint32_t AccumuloProxy_getMaxRow_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getIteratorSetting_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -4527,8 +4479,8 @@ uint32_t AccumuloProxy_getMaxRow_presult::read(::apache::thrift::protocol::TProt
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary((*(this->success)));
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
           this->__isset.success = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4570,7 +4522,7 @@ uint32_t AccumuloProxy_getMaxRow_presult::read(::apache::thrift::protocol::TProt
   return xfer;
 }
 
-uint32_t AccumuloProxy_getTableProperties_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getMaxRow_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -4606,6 +4558,59 @@ uint32_t AccumuloProxy_getTableProperties_args::read(::apache::thrift::protocol:
           xfer += iprot->skip(ftype);
         }
         break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_SET) {
+          {
+            this->auths.clear();
+            uint32_t _size231;
+            ::apache::thrift::protocol::TType _etype234;
+            xfer += iprot->readSetBegin(_etype234, _size231);
+            uint32_t _i235;
+            for (_i235 = 0; _i235 < _size231; ++_i235)
+            {
+              std::string _elem236;
+              xfer += iprot->readBinary(_elem236);
+              this->auths.insert(_elem236);
+            }
+            xfer += iprot->readSetEnd();
+          }
+          this->__isset.auths = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->startRow);
+          this->__isset.startRow = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->startInclusive);
+          this->__isset.startInclusive = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->endRow);
+          this->__isset.endRow = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->endInclusive);
+          this->__isset.endInclusive = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -4618,9 +4623,9 @@ uint32_t AccumuloProxy_getTableProperties_args::read(::apache::thrift::protocol:
   return xfer;
 }
 
-uint32_t AccumuloProxy_getTableProperties_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getMaxRow_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_getTableProperties_args");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getMaxRow_args");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary(this->login);
@@ -4630,14 +4635,42 @@ uint32_t AccumuloProxy_getTableProperties_args::write(::apache::thrift::protocol
   xfer += oprot->writeString(this->tableName);
   xfer += oprot->writeFieldEnd();
 
+  xfer += oprot->writeFieldBegin("auths", ::apache::thrift::protocol::T_SET, 3);
+  {
+    xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->auths.size()));
+    std::set<std::string> ::const_iterator _iter237;
+    for (_iter237 = this->auths.begin(); _iter237 != this->auths.end(); ++_iter237)
+    {
+      xfer += oprot->writeBinary((*_iter237));
+    }
+    xfer += oprot->writeSetEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 4);
+  xfer += oprot->writeBinary(this->startRow);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("startInclusive", ::apache::thrift::protocol::T_BOOL, 5);
+  xfer += oprot->writeBool(this->startInclusive);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("endRow", ::apache::thrift::protocol::T_STRING, 6);
+  xfer += oprot->writeBinary(this->endRow);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("endInclusive", ::apache::thrift::protocol::T_BOOL, 7);
+  xfer += oprot->writeBool(this->endInclusive);
+  xfer += oprot->writeFieldEnd();
+
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-uint32_t AccumuloProxy_getTableProperties_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getMaxRow_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_getTableProperties_pargs");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getMaxRow_pargs");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary((*(this->login)));
@@ -4647,12 +4680,40 @@ uint32_t AccumuloProxy_getTableProperties_pargs::write(::apache::thrift::protoco
   xfer += oprot->writeString((*(this->tableName)));
   xfer += oprot->writeFieldEnd();
 
+  xfer += oprot->writeFieldBegin("auths", ::apache::thrift::protocol::T_SET, 3);
+  {
+    xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->auths)).size()));
+    std::set<std::string> ::const_iterator _iter238;
+    for (_iter238 = (*(this->auths)).begin(); _iter238 != (*(this->auths)).end(); ++_iter238)
+    {
+      xfer += oprot->writeBinary((*_iter238));
+    }
+    xfer += oprot->writeSetEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 4);
+  xfer += oprot->writeBinary((*(this->startRow)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("startInclusive", ::apache::thrift::protocol::T_BOOL, 5);
+  xfer += oprot->writeBool((*(this->startInclusive)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("endRow", ::apache::thrift::protocol::T_STRING, 6);
+  xfer += oprot->writeBinary((*(this->endRow)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("endInclusive", ::apache::thrift::protocol::T_BOOL, 7);
+  xfer += oprot->writeBool((*(this->endInclusive)));
+  xfer += oprot->writeFieldEnd();
+
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-uint32_t AccumuloProxy_getTableProperties_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getMaxRow_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -4673,23 +4734,8 @@ uint32_t AccumuloProxy_getTableProperties_result::read(::apache::thrift::protoco
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_MAP) {
-          {
-            this->success.clear();
-            uint32_t _size189;
-            ::apache::thrift::protocol::TType _ktype190;
-            ::apache::thrift::protocol::TType _vtype191;
-            xfer += iprot->readMapBegin(_ktype190, _vtype191, _size189);
-            uint32_t _i193;
-            for (_i193 = 0; _i193 < _size189; ++_i193)
-            {
-              std::string _key194;
-              xfer += iprot->readString(_key194);
-              std::string& _val195 = this->success[_key194];
-              xfer += iprot->readString(_val195);
-            }
-            xfer += iprot->readMapEnd();
-          }
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->success);
           this->__isset.success = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4731,24 +4777,15 @@ uint32_t AccumuloProxy_getTableProperties_result::read(::apache::thrift::protoco
   return xfer;
 }
 
-uint32_t AccumuloProxy_getTableProperties_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getMaxRow_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("AccumuloProxy_getTableProperties_result");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getMaxRow_result");
 
   if (this->__isset.success) {
-    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
-    {
-      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
-      std::map<std::string, std::string> ::const_iterator _iter196;
-      for (_iter196 = this->success.begin(); _iter196 != this->success.end(); ++_iter196)
-      {
-        xfer += oprot->writeString(_iter196->first);
-        xfer += oprot->writeString(_iter196->second);
-      }
-      xfer += oprot->writeMapEnd();
-    }
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeBinary(this->success);
     xfer += oprot->writeFieldEnd();
   } else if (this->__isset.ouch1) {
     xfer += oprot->writeFieldBegin("ouch1", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -4768,7 +4805,7 @@ uint32_t AccumuloProxy_getTableProperties_result::write(::apache::thrift::protoc
   return xfer;
 }
 
-uint32_t AccumuloProxy_getTableProperties_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getMaxRow_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -4789,23 +4826,8 @@ uint32_t AccumuloProxy_getTableProperties_presult::read(::apache::thrift::protoc
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_MAP) {
-          {
-            (*(this->success)).clear();
-            uint32_t _size197;
-            ::apache::thrift::protocol::TType _ktype198;
-            ::apache::thrift::protocol::TType _vtype199;
-            xfer += iprot->readMapBegin(_ktype198, _vtype199, _size197);
-            uint32_t _i201;
-            for (_i201 = 0; _i201 < _size197; ++_i201)
-            {
-              std::string _key202;
-              xfer += iprot->readString(_key202);
-              std::string& _val203 = (*(this->success))[_key202];
-              xfer += iprot->readString(_val203);
-            }
-            xfer += iprot->readMapEnd();
-          }
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary((*(this->success)));
           this->__isset.success = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4847,7 +4869,7 @@ uint32_t AccumuloProxy_getTableProperties_presult::read(::apache::thrift::protoc
   return xfer;
 }
 
-uint32_t AccumuloProxy_importDirectory_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getTableProperties_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -4883,30 +4905,6 @@ uint32_t AccumuloProxy_importDirectory_args::read(::apache::thrift::protocol::TP
           xfer += iprot->skip(ftype);
         }
         break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->importDir);
-          this->__isset.importDir = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->failureDir);
-          this->__isset.failureDir = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->setTime);
-          this->__isset.setTime = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -4919,9 +4917,9 @@ uint32_t AccumuloProxy_importDirectory_args::read(::apache::thrift::protocol::TP
   return xfer;
 }
 
-uint32_t AccumuloProxy_importDirectory_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getTableProperties_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_importDirectory_args");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getTableProperties_args");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary(this->login);
@@ -4931,26 +4929,14 @@ uint32_t AccumuloProxy_importDirectory_args::write(::apache::thrift::protocol::T
   xfer += oprot->writeString(this->tableName);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("importDir", ::apache::thrift::protocol::T_STRING, 3);
-  xfer += oprot->writeString(this->importDir);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("failureDir", ::apache::thrift::protocol::T_STRING, 4);
-  xfer += oprot->writeString(this->failureDir);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("setTime", ::apache::thrift::protocol::T_BOOL, 5);
-  xfer += oprot->writeBool(this->setTime);
-  xfer += oprot->writeFieldEnd();
-
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-uint32_t AccumuloProxy_importDirectory_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getTableProperties_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_importDirectory_pargs");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getTableProperties_pargs");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary((*(this->login)));
@@ -4960,24 +4946,12 @@ uint32_t AccumuloProxy_importDirectory_pargs::write(::apache::thrift::protocol::
   xfer += oprot->writeString((*(this->tableName)));
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("importDir", ::apache::thrift::protocol::T_STRING, 3);
-  xfer += oprot->writeString((*(this->importDir)));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("failureDir", ::apache::thrift::protocol::T_STRING, 4);
-  xfer += oprot->writeString((*(this->failureDir)));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("setTime", ::apache::thrift::protocol::T_BOOL, 5);
-  xfer += oprot->writeBool((*(this->setTime)));
-  xfer += oprot->writeFieldEnd();
-
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-uint32_t AccumuloProxy_importDirectory_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getTableProperties_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -4997,6 +4971,29 @@ uint32_t AccumuloProxy_importDirectory_result::read(::apache::thrift::protocol::
     }
     switch (fid)
     {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->success.clear();
+            uint32_t _size239;
+            ::apache::thrift::protocol::TType _ktype240;
+            ::apache::thrift::protocol::TType _vtype241;
+            xfer += iprot->readMapBegin(_ktype240, _vtype241, _size239);
+            uint32_t _i243;
+            for (_i243 = 0; _i243 < _size239; ++_i243)
+            {
+              std::string _key244;
+              xfer += iprot->readString(_key244);
+              std::string& _val245 = this->success[_key244];
+              xfer += iprot->readString(_val245);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       case 1:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
           xfer += this->ouch1.read(iprot);
@@ -5007,16 +5004,16 @@ uint32_t AccumuloProxy_importDirectory_result::read(::apache::thrift::protocol::
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ouch3.read(iprot);
-          this->__isset.ouch3 = true;
+          xfer += this->ouch2.read(iprot);
+          this->__isset.ouch2 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ouch4.read(iprot);
-          this->__isset.ouch4 = true;
+          xfer += this->ouch3.read(iprot);
+          this->__isset.ouch3 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -5033,23 +5030,36 @@ uint32_t AccumuloProxy_importDirectory_result::read(::apache::thrift::protocol::
   return xfer;
 }
 
-uint32_t AccumuloProxy_importDirectory_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_getTableProperties_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("AccumuloProxy_importDirectory_result");
+  xfer += oprot->writeStructBegin("AccumuloProxy_getTableProperties_result");
 
-  if (this->__isset.ouch1) {
-    xfer += oprot->writeFieldBegin("ouch1", ::apache::thrift::protocol::T_STRUCT, 1);
-    xfer += this->ouch1.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  } else if (this->__isset.ouch3) {
-    xfer += oprot->writeFieldBegin("ouch3", ::apache::thrift::protocol::T_STRUCT, 2);
-    xfer += this->ouch3.write(oprot);
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
+    {
+      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
+      std::map<std::string, std::string> ::const_iterator _iter246;
+      for (_iter246 = this->success.begin(); _iter246 != this->success.end(); ++_iter246)
+      {
+        xfer += oprot->writeString(_iter246->first);
+        xfer += oprot->writeString(_iter246->second);
+      }
+      xfer += oprot->writeMapEnd();
+    }
     xfer += oprot->writeFieldEnd();
-  } else if (this->__isset.ouch4) {
-    xfer += oprot->writeFieldBegin("ouch4", ::apache::thrift::protocol::T_STRUCT, 3);
-    xfer += this->ouch4.write(oprot);
+  } else if (this->__isset.ouch1) {
+    xfer += oprot->writeFieldBegin("ouch1", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ouch1.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ouch2) {
+    xfer += oprot->writeFieldBegin("ouch2", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ouch2.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ouch3) {
+    xfer += oprot->writeFieldBegin("ouch3", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->ouch3.write(oprot);
     xfer += oprot->writeFieldEnd();
   }
   xfer += oprot->writeFieldStop();
@@ -5057,7 +5067,7 @@ uint32_t AccumuloProxy_importDirectory_result::write(::apache::thrift::protocol:
   return xfer;
 }
 
-uint32_t AccumuloProxy_importDirectory_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_getTableProperties_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -5077,6 +5087,29 @@ uint32_t AccumuloProxy_importDirectory_presult::read(::apache::thrift::protocol:
     }
     switch (fid)
     {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size247;
+            ::apache::thrift::protocol::TType _ktype248;
+            ::apache::thrift::protocol::TType _vtype249;
+            xfer += iprot->readMapBegin(_ktype248, _vtype249, _size247);
+            uint32_t _i251;
+            for (_i251 = 0; _i251 < _size247; ++_i251)
+            {
+              std::string _key252;
+              xfer += iprot->readString(_key252);
+              std::string& _val253 = (*(this->success))[_key252];
+              xfer += iprot->readString(_val253);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       case 1:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
           xfer += this->ouch1.read(iprot);
@@ -5087,16 +5120,16 @@ uint32_t AccumuloProxy_importDirectory_presult::read(::apache::thrift::protocol:
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ouch3.read(iprot);
-          this->__isset.ouch3 = true;
+          xfer += this->ouch2.read(iprot);
+          this->__isset.ouch2 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ouch4.read(iprot);
-          this->__isset.ouch4 = true;
+          xfer += this->ouch3.read(iprot);
+          this->__isset.ouch3 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -5113,7 +5146,7 @@ uint32_t AccumuloProxy_importDirectory_presult::read(::apache::thrift::protocol:
   return xfer;
 }
 
-uint32_t AccumuloProxy_importTable_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_importDirectory_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -5157,6 +5190,22 @@ uint32_t AccumuloProxy_importTable_args::read(::apache::thrift::protocol::TProto
           xfer += iprot->skip(ftype);
         }
         break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->failureDir);
+          this->__isset.failureDir = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->setTime);
+          this->__isset.setTime = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -5169,9 +5218,9 @@ uint32_t AccumuloProxy_importTable_args::read(::apache::thrift::protocol::TProto
   return xfer;
 }
 
-uint32_t AccumuloProxy_importTable_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_importDirectory_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_importTable_args");
+  xfer += oprot->writeStructBegin("AccumuloProxy_importDirectory_args");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary(this->login);
@@ -5185,14 +5234,22 @@ uint32_t AccumuloProxy_importTable_args::write(::apache::thrift::protocol::TProt
   xfer += oprot->writeString(this->importDir);
   xfer += oprot->writeFieldEnd();
 
+  xfer += oprot->writeFieldBegin("failureDir", ::apache::thrift::protocol::T_STRING, 4);
+  xfer += oprot->writeString(this->failureDir);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("setTime", ::apache::thrift::protocol::T_BOOL, 5);
+  xfer += oprot->writeBool(this->setTime);
+  xfer += oprot->writeFieldEnd();
+
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-uint32_t AccumuloProxy_importTable_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_importDirectory_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_importTable_pargs");
+  xfer += oprot->writeStructBegin("AccumuloProxy_importDirectory_pargs");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary((*(this->login)));
@@ -5206,12 +5263,20 @@ uint32_t AccumuloProxy_importTable_pargs::write(::apache::thrift::protocol::TPro
   xfer += oprot->writeString((*(this->importDir)));
   xfer += oprot->writeFieldEnd();
 
+  xfer += oprot->writeFieldBegin("failureDir", ::apache::thrift::protocol::T_STRING, 4);
+  xfer += oprot->writeString((*(this->failureDir)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("setTime", ::apache::thrift::protocol::T_BOOL, 5);
+  xfer += oprot->writeBool((*(this->setTime)));
+  xfer += oprot->writeFieldEnd();
+
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-uint32_t AccumuloProxy_importTable_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_importDirectory_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -5241,16 +5306,16 @@ uint32_t AccumuloProxy_importTable_result::read(::apache::thrift::protocol::TPro
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ouch2.read(iprot);
-          this->__isset.ouch2 = true;
+          xfer += this->ouch3.read(iprot);
+          this->__isset.ouch3 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ouch3.read(iprot);
-          this->__isset.ouch3 = true;
+          xfer += this->ouch4.read(iprot);
+          this->__isset.ouch4 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -5267,31 +5332,31 @@ uint32_t AccumuloProxy_importTable_result::read(::apache::thrift::protocol::TPro
   return xfer;
 }
 
-uint32_t AccumuloProxy_importTable_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_importDirectory_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("AccumuloProxy_importTable_result");
+  xfer += oprot->writeStructBegin("AccumuloProxy_importDirectory_result");
 
   if (this->__isset.ouch1) {
     xfer += oprot->writeFieldBegin("ouch1", ::apache::thrift::protocol::T_STRUCT, 1);
     xfer += this->ouch1.write(oprot);
     xfer += oprot->writeFieldEnd();
-  } else if (this->__isset.ouch2) {
-    xfer += oprot->writeFieldBegin("ouch2", ::apache::thrift::protocol::T_STRUCT, 2);
-    xfer += this->ouch2.write(oprot);
-    xfer += oprot->writeFieldEnd();
   } else if (this->__isset.ouch3) {
-    xfer += oprot->writeFieldBegin("ouch3", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += oprot->writeFieldBegin("ouch3", ::apache::thrift::protocol::T_STRUCT, 2);
     xfer += this->ouch3.write(oprot);
     xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ouch4) {
+    xfer += oprot->writeFieldBegin("ouch4", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->ouch4.write(oprot);
+    xfer += oprot->writeFieldEnd();
   }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-uint32_t AccumuloProxy_importTable_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_importDirectory_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -5321,16 +5386,16 @@ uint32_t AccumuloProxy_importTable_presult::read(::apache::thrift::protocol::TPr
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ouch2.read(iprot);
-          this->__isset.ouch2 = true;
+          xfer += this->ouch3.read(iprot);
+          this->__isset.ouch3 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ouch3.read(iprot);
-          this->__isset.ouch3 = true;
+          xfer += this->ouch4.read(iprot);
+          this->__isset.ouch4 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -5347,7 +5412,7 @@ uint32_t AccumuloProxy_importTable_presult::read(::apache::thrift::protocol::TPr
   return xfer;
 }
 
-uint32_t AccumuloProxy_listSplits_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_importTable_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -5384,9 +5449,9 @@ uint32_t AccumuloProxy_listSplits_args::read(::apache::thrift::protocol::TProtoc
         }
         break;
       case 3:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->maxSplits);
-          this->__isset.maxSplits = true;
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->importDir);
+          this->__isset.importDir = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -5403,9 +5468,9 @@ uint32_t AccumuloProxy_listSplits_args::read(::apache::thrift::protocol::TProtoc
   return xfer;
 }
 
-uint32_t AccumuloProxy_listSplits_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_importTable_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_listSplits_args");
+  xfer += oprot->writeStructBegin("AccumuloProxy_importTable_args");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary(this->login);
@@ -5415,8 +5480,8 @@ uint32_t AccumuloProxy_listSplits_args::write(::apache::thrift::protocol::TProto
   xfer += oprot->writeString(this->tableName);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("maxSplits", ::apache::thrift::protocol::T_I32, 3);
-  xfer += oprot->writeI32(this->maxSplits);
+  xfer += oprot->writeFieldBegin("importDir", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->importDir);
   xfer += oprot->writeFieldEnd();
 
   xfer += oprot->writeFieldStop();
@@ -5424,9 +5489,9 @@ uint32_t AccumuloProxy_listSplits_args::write(::apache::thrift::protocol::TProto
   return xfer;
 }
 
-uint32_t AccumuloProxy_listSplits_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_importTable_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_listSplits_pargs");
+  xfer += oprot->writeStructBegin("AccumuloProxy_importTable_pargs");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary((*(this->login)));
@@ -5436,8 +5501,8 @@ uint32_t AccumuloProxy_listSplits_pargs::write(::apache::thrift::protocol::TProt
   xfer += oprot->writeString((*(this->tableName)));
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("maxSplits", ::apache::thrift::protocol::T_I32, 3);
-  xfer += oprot->writeI32((*(this->maxSplits)));
+  xfer += oprot->writeFieldBegin("importDir", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString((*(this->importDir)));
   xfer += oprot->writeFieldEnd();
 
   xfer += oprot->writeFieldStop();
@@ -5445,7 +5510,7 @@ uint32_t AccumuloProxy_listSplits_pargs::write(::apache::thrift::protocol::TProt
   return xfer;
 }
 
-uint32_t AccumuloProxy_listSplits_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_importTable_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -5465,26 +5530,6 @@ uint32_t AccumuloProxy_listSplits_result::read(::apache::thrift::protocol::TProt
     }
     switch (fid)
     {
-      case 0:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->success.clear();
-            uint32_t _size204;
-            ::apache::thrift::protocol::TType _etype207;
-            xfer += iprot->readListBegin(_etype207, _size204);
-            this->success.resize(_size204);
-            uint32_t _i208;
-            for (_i208 = 0; _i208 < _size204; ++_i208)
-            {
-              xfer += iprot->readBinary(this->success[_i208]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.success = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
       case 1:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
           xfer += this->ouch1.read(iprot);
@@ -5521,25 +5566,13 @@ uint32_t AccumuloProxy_listSplits_result::read(::apache::thrift::protocol::TProt
   return xfer;
 }
 
-uint32_t AccumuloProxy_listSplits_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_importTable_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("AccumuloProxy_listSplits_result");
+  xfer += oprot->writeStructBegin("AccumuloProxy_importTable_result");
 
-  if (this->__isset.success) {
-    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
-      std::vector<std::string> ::const_iterator _iter209;
-      for (_iter209 = this->success.begin(); _iter209 != this->success.end(); ++_iter209)
-      {
-        xfer += oprot->writeBinary((*_iter209));
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  } else if (this->__isset.ouch1) {
+  if (this->__isset.ouch1) {
     xfer += oprot->writeFieldBegin("ouch1", ::apache::thrift::protocol::T_STRUCT, 1);
     xfer += this->ouch1.write(oprot);
     xfer += oprot->writeFieldEnd();
@@ -5557,7 +5590,7 @@ uint32_t AccumuloProxy_listSplits_result::write(::apache::thrift::protocol::TPro
   return xfer;
 }
 
-uint32_t AccumuloProxy_listSplits_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_importTable_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -5577,26 +5610,6 @@ uint32_t AccumuloProxy_listSplits_presult::read(::apache::thrift::protocol::TPro
     }
     switch (fid)
     {
-      case 0:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            (*(this->success)).clear();
-            uint32_t _size210;
-            ::apache::thrift::protocol::TType _etype213;
-            xfer += iprot->readListBegin(_etype213, _size210);
-            (*(this->success)).resize(_size210);
-            uint32_t _i214;
-            for (_i214 = 0; _i214 < _size210; ++_i214)
-            {
-              xfer += iprot->readBinary((*(this->success))[_i214]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.success = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
       case 1:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
           xfer += this->ouch1.read(iprot);
@@ -5633,7 +5646,7 @@ uint32_t AccumuloProxy_listSplits_presult::read(::apache::thrift::protocol::TPro
   return xfer;
 }
 
-uint32_t AccumuloProxy_listTables_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AccumuloProxy_listSplits_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -5661,6 +5674,22 @@ uint32_t AccumuloProxy_listTables_args::read(::apache::thrift::protocol::TProtoc
           xfer += iprot->skip(ftype);
         }
         break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->tableName);
+          this->__isset.tableName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->maxSplits);
+          this->__isset.maxSplits = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -5673,33 +5702,49 @@ uint32_t AccumuloProxy_listTables_args::read(::apache::thrift::protocol::TProtoc
   return xfer;
 }
 
-uint32_t AccumuloProxy_listTables_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_listSplits_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_listTables_args");
+  xfer += oprot->writeStructBegin("AccumuloProxy_listSplits_args");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary(this->login);
   xfer += oprot->writeFieldEnd();
 
+  xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->tableName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("maxSplits", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32(this->maxSplits);
+  xfer += oprot->writeFieldEnd();
+
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-uint32_t AccumuloProxy_listTables_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AccumuloProxy_listSplits_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
-  xfer += oprot->writeStructBegin("AccumuloProxy_listTables_pargs");
+  xfer += oprot->writeStructBegin("AccumuloProxy_listSplits_pargs");
 
   xfer += oprot->writeFieldBegin("login", ::apache::thrift::protocol::T_STRING, 1);
   xfer += oprot->writeBinary((*(this->login)));
   xfer += oprot->writeFieldEnd();
 
+  xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString((*(this->tableName)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("maxSplits", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32((*(this->maxSplits)));
+  xfer += oprot->writeFieldEnd();
+
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-uint32_t AccumuloProxy_listTables_result::read(::apache::thrift::protocol::TPr

<TRUNCATED>

Mime
View raw message