accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ktur...@apache.org
Subject [8/9] accumulo git commit: ACCUMULO-4147 Add Accumulo Namespace Operations to Proxy
Date Mon, 04 Apr 2016 18:30:38 GMT
http://git-wip-us.apache.org/repos/asf/accumulo/blob/8839fe51/proxy/src/main/cpp/AccumuloProxy.cpp
----------------------------------------------------------------------
diff --git a/proxy/src/main/cpp/AccumuloProxy.cpp b/proxy/src/main/cpp/AccumuloProxy.cpp
index d74ad95..d0add35 100644
--- a/proxy/src/main/cpp/AccumuloProxy.cpp
+++ b/proxy/src/main/cpp/AccumuloProxy.cpp
@@ -62,17 +62,17 @@ uint32_t AccumuloProxy_login_args::read(::apache::thrift::protocol::TProtocol* i
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->loginProperties.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)
+            uint32_t _size195;
+            ::apache::thrift::protocol::TType _ktype196;
+            ::apache::thrift::protocol::TType _vtype197;
+            xfer += iprot->readMapBegin(_ktype196, _vtype197, _size195);
+            uint32_t _i199;
+            for (_i199 = 0; _i199 < _size195; ++_i199)
             {
-              std::string _key194;
-              xfer += iprot->readString(_key194);
-              std::string& _val195 = this->loginProperties[_key194];
-              xfer += iprot->readString(_val195);
+              std::string _key200;
+              xfer += iprot->readString(_key200);
+              std::string& _val201 = this->loginProperties[_key200];
+              xfer += iprot->readString(_val201);
             }
             xfer += iprot->readMapEnd();
           }
@@ -105,11 +105,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 _iter196;
-    for (_iter196 = this->loginProperties.begin(); _iter196 != this->loginProperties.end(); ++_iter196)
+    std::map<std::string, std::string> ::const_iterator _iter202;
+    for (_iter202 = this->loginProperties.begin(); _iter202 != this->loginProperties.end(); ++_iter202)
     {
-      xfer += oprot->writeString(_iter196->first);
-      xfer += oprot->writeString(_iter196->second);
+      xfer += oprot->writeString(_iter202->first);
+      xfer += oprot->writeString(_iter202->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -137,11 +137,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 _iter197;
-    for (_iter197 = (*(this->loginProperties)).begin(); _iter197 != (*(this->loginProperties)).end(); ++_iter197)
+    std::map<std::string, std::string> ::const_iterator _iter203;
+    for (_iter203 = (*(this->loginProperties)).begin(); _iter203 != (*(this->loginProperties)).end(); ++_iter203)
     {
-      xfer += oprot->writeString(_iter197->first);
-      xfer += oprot->writeString(_iter197->second);
+      xfer += oprot->writeString(_iter203->first);
+      xfer += oprot->writeString(_iter203->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -605,15 +605,15 @@ uint32_t AccumuloProxy_addSplits_args::read(::apache::thrift::protocol::TProtoco
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->splits.clear();
-            uint32_t _size198;
-            ::apache::thrift::protocol::TType _etype201;
-            xfer += iprot->readSetBegin(_etype201, _size198);
-            uint32_t _i202;
-            for (_i202 = 0; _i202 < _size198; ++_i202)
+            uint32_t _size204;
+            ::apache::thrift::protocol::TType _etype207;
+            xfer += iprot->readSetBegin(_etype207, _size204);
+            uint32_t _i208;
+            for (_i208 = 0; _i208 < _size204; ++_i208)
             {
-              std::string _elem203;
-              xfer += iprot->readBinary(_elem203);
-              this->splits.insert(_elem203);
+              std::string _elem209;
+              xfer += iprot->readBinary(_elem209);
+              this->splits.insert(_elem209);
             }
             xfer += iprot->readSetEnd();
           }
@@ -650,10 +650,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 _iter204;
-    for (_iter204 = this->splits.begin(); _iter204 != this->splits.end(); ++_iter204)
+    std::set<std::string> ::const_iterator _iter210;
+    for (_iter210 = this->splits.begin(); _iter210 != this->splits.end(); ++_iter210)
     {
-      xfer += oprot->writeBinary((*_iter204));
+      xfer += oprot->writeBinary((*_iter210));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -685,10 +685,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 _iter205;
-    for (_iter205 = (*(this->splits)).begin(); _iter205 != (*(this->splits)).end(); ++_iter205)
+    std::set<std::string> ::const_iterator _iter211;
+    for (_iter211 = (*(this->splits)).begin(); _iter211 != (*(this->splits)).end(); ++_iter211)
     {
-      xfer += oprot->writeBinary((*_iter205));
+      xfer += oprot->writeBinary((*_iter211));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -901,17 +901,17 @@ uint32_t AccumuloProxy_attachIterator_args::read(::apache::thrift::protocol::TPr
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->scopes.clear();
-            uint32_t _size206;
-            ::apache::thrift::protocol::TType _etype209;
-            xfer += iprot->readSetBegin(_etype209, _size206);
-            uint32_t _i210;
-            for (_i210 = 0; _i210 < _size206; ++_i210)
+            uint32_t _size212;
+            ::apache::thrift::protocol::TType _etype215;
+            xfer += iprot->readSetBegin(_etype215, _size212);
+            uint32_t _i216;
+            for (_i216 = 0; _i216 < _size212; ++_i216)
             {
-              IteratorScope::type _elem211;
-              int32_t ecast212;
-              xfer += iprot->readI32(ecast212);
-              _elem211 = (IteratorScope::type)ecast212;
-              this->scopes.insert(_elem211);
+              IteratorScope::type _elem217;
+              int32_t ecast218;
+              xfer += iprot->readI32(ecast218);
+              _elem217 = (IteratorScope::type)ecast218;
+              this->scopes.insert(_elem217);
             }
             xfer += iprot->readSetEnd();
           }
@@ -952,10 +952,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 _iter213;
-    for (_iter213 = this->scopes.begin(); _iter213 != this->scopes.end(); ++_iter213)
+    std::set<IteratorScope::type> ::const_iterator _iter219;
+    for (_iter219 = this->scopes.begin(); _iter219 != this->scopes.end(); ++_iter219)
     {
-      xfer += oprot->writeI32((int32_t)(*_iter213));
+      xfer += oprot->writeI32((int32_t)(*_iter219));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -991,10 +991,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 _iter214;
-    for (_iter214 = (*(this->scopes)).begin(); _iter214 != (*(this->scopes)).end(); ++_iter214)
+    std::set<IteratorScope::type> ::const_iterator _iter220;
+    for (_iter220 = (*(this->scopes)).begin(); _iter220 != (*(this->scopes)).end(); ++_iter220)
     {
-      xfer += oprot->writeI32((int32_t)(*_iter214));
+      xfer += oprot->writeI32((int32_t)(*_iter220));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -1207,17 +1207,17 @@ uint32_t AccumuloProxy_checkIteratorConflicts_args::read(::apache::thrift::proto
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->scopes.clear();
-            uint32_t _size215;
-            ::apache::thrift::protocol::TType _etype218;
-            xfer += iprot->readSetBegin(_etype218, _size215);
-            uint32_t _i219;
-            for (_i219 = 0; _i219 < _size215; ++_i219)
+            uint32_t _size221;
+            ::apache::thrift::protocol::TType _etype224;
+            xfer += iprot->readSetBegin(_etype224, _size221);
+            uint32_t _i225;
+            for (_i225 = 0; _i225 < _size221; ++_i225)
             {
-              IteratorScope::type _elem220;
-              int32_t ecast221;
-              xfer += iprot->readI32(ecast221);
-              _elem220 = (IteratorScope::type)ecast221;
-              this->scopes.insert(_elem220);
+              IteratorScope::type _elem226;
+              int32_t ecast227;
+              xfer += iprot->readI32(ecast227);
+              _elem226 = (IteratorScope::type)ecast227;
+              this->scopes.insert(_elem226);
             }
             xfer += iprot->readSetEnd();
           }
@@ -1258,10 +1258,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 _iter222;
-    for (_iter222 = this->scopes.begin(); _iter222 != this->scopes.end(); ++_iter222)
+    std::set<IteratorScope::type> ::const_iterator _iter228;
+    for (_iter228 = this->scopes.begin(); _iter228 != this->scopes.end(); ++_iter228)
     {
-      xfer += oprot->writeI32((int32_t)(*_iter222));
+      xfer += oprot->writeI32((int32_t)(*_iter228));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -1297,10 +1297,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 _iter223;
-    for (_iter223 = (*(this->scopes)).begin(); _iter223 != (*(this->scopes)).end(); ++_iter223)
+    std::set<IteratorScope::type> ::const_iterator _iter229;
+    for (_iter229 = (*(this->scopes)).begin(); _iter229 != (*(this->scopes)).end(); ++_iter229)
     {
-      xfer += oprot->writeI32((int32_t)(*_iter223));
+      xfer += oprot->writeI32((int32_t)(*_iter229));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -1724,17 +1724,17 @@ uint32_t AccumuloProxy_cloneTable_args::read(::apache::thrift::protocol::TProtoc
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->propertiesToSet.clear();
-            uint32_t _size224;
-            ::apache::thrift::protocol::TType _ktype225;
-            ::apache::thrift::protocol::TType _vtype226;
-            xfer += iprot->readMapBegin(_ktype225, _vtype226, _size224);
-            uint32_t _i228;
-            for (_i228 = 0; _i228 < _size224; ++_i228)
+            uint32_t _size230;
+            ::apache::thrift::protocol::TType _ktype231;
+            ::apache::thrift::protocol::TType _vtype232;
+            xfer += iprot->readMapBegin(_ktype231, _vtype232, _size230);
+            uint32_t _i234;
+            for (_i234 = 0; _i234 < _size230; ++_i234)
             {
-              std::string _key229;
-              xfer += iprot->readString(_key229);
-              std::string& _val230 = this->propertiesToSet[_key229];
-              xfer += iprot->readString(_val230);
+              std::string _key235;
+              xfer += iprot->readString(_key235);
+              std::string& _val236 = this->propertiesToSet[_key235];
+              xfer += iprot->readString(_val236);
             }
             xfer += iprot->readMapEnd();
           }
@@ -1747,15 +1747,15 @@ uint32_t AccumuloProxy_cloneTable_args::read(::apache::thrift::protocol::TProtoc
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->propertiesToExclude.clear();
-            uint32_t _size231;
-            ::apache::thrift::protocol::TType _etype234;
-            xfer += iprot->readSetBegin(_etype234, _size231);
-            uint32_t _i235;
-            for (_i235 = 0; _i235 < _size231; ++_i235)
+            uint32_t _size237;
+            ::apache::thrift::protocol::TType _etype240;
+            xfer += iprot->readSetBegin(_etype240, _size237);
+            uint32_t _i241;
+            for (_i241 = 0; _i241 < _size237; ++_i241)
             {
-              std::string _elem236;
-              xfer += iprot->readString(_elem236);
-              this->propertiesToExclude.insert(_elem236);
+              std::string _elem242;
+              xfer += iprot->readString(_elem242);
+              this->propertiesToExclude.insert(_elem242);
             }
             xfer += iprot->readSetEnd();
           }
@@ -1800,11 +1800,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 _iter237;
-    for (_iter237 = this->propertiesToSet.begin(); _iter237 != this->propertiesToSet.end(); ++_iter237)
+    std::map<std::string, std::string> ::const_iterator _iter243;
+    for (_iter243 = this->propertiesToSet.begin(); _iter243 != this->propertiesToSet.end(); ++_iter243)
     {
-      xfer += oprot->writeString(_iter237->first);
-      xfer += oprot->writeString(_iter237->second);
+      xfer += oprot->writeString(_iter243->first);
+      xfer += oprot->writeString(_iter243->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -1813,10 +1813,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 _iter238;
-    for (_iter238 = this->propertiesToExclude.begin(); _iter238 != this->propertiesToExclude.end(); ++_iter238)
+    std::set<std::string> ::const_iterator _iter244;
+    for (_iter244 = this->propertiesToExclude.begin(); _iter244 != this->propertiesToExclude.end(); ++_iter244)
     {
-      xfer += oprot->writeString((*_iter238));
+      xfer += oprot->writeString((*_iter244));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -1856,11 +1856,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 _iter239;
-    for (_iter239 = (*(this->propertiesToSet)).begin(); _iter239 != (*(this->propertiesToSet)).end(); ++_iter239)
+    std::map<std::string, std::string> ::const_iterator _iter245;
+    for (_iter245 = (*(this->propertiesToSet)).begin(); _iter245 != (*(this->propertiesToSet)).end(); ++_iter245)
     {
-      xfer += oprot->writeString(_iter239->first);
-      xfer += oprot->writeString(_iter239->second);
+      xfer += oprot->writeString(_iter245->first);
+      xfer += oprot->writeString(_iter245->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -1869,10 +1869,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 _iter240;
-    for (_iter240 = (*(this->propertiesToExclude)).begin(); _iter240 != (*(this->propertiesToExclude)).end(); ++_iter240)
+    std::set<std::string> ::const_iterator _iter246;
+    for (_iter246 = (*(this->propertiesToExclude)).begin(); _iter246 != (*(this->propertiesToExclude)).end(); ++_iter246)
     {
-      xfer += oprot->writeString((*_iter240));
+      xfer += oprot->writeString((*_iter246));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -2113,14 +2113,14 @@ uint32_t AccumuloProxy_compactTable_args::read(::apache::thrift::protocol::TProt
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->iterators.clear();
-            uint32_t _size241;
-            ::apache::thrift::protocol::TType _etype244;
-            xfer += iprot->readListBegin(_etype244, _size241);
-            this->iterators.resize(_size241);
-            uint32_t _i245;
-            for (_i245 = 0; _i245 < _size241; ++_i245)
+            uint32_t _size247;
+            ::apache::thrift::protocol::TType _etype250;
+            xfer += iprot->readListBegin(_etype250, _size247);
+            this->iterators.resize(_size247);
+            uint32_t _i251;
+            for (_i251 = 0; _i251 < _size247; ++_i251)
             {
-              xfer += this->iterators[_i245].read(iprot);
+              xfer += this->iterators[_i251].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -2189,10 +2189,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 _iter246;
-    for (_iter246 = this->iterators.begin(); _iter246 != this->iterators.end(); ++_iter246)
+    std::vector<IteratorSetting> ::const_iterator _iter252;
+    for (_iter252 = this->iterators.begin(); _iter252 != this->iterators.end(); ++_iter252)
     {
-      xfer += (*_iter246).write(oprot);
+      xfer += (*_iter252).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -2244,10 +2244,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 _iter247;
-    for (_iter247 = (*(this->iterators)).begin(); _iter247 != (*(this->iterators)).end(); ++_iter247)
+    std::vector<IteratorSetting> ::const_iterator _iter253;
+    for (_iter253 = (*(this->iterators)).begin(); _iter253 != (*(this->iterators)).end(); ++_iter253)
     {
-      xfer += (*_iter247).write(oprot);
+      xfer += (*_iter253).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -2713,9 +2713,9 @@ uint32_t AccumuloProxy_createTable_args::read(::apache::thrift::protocol::TProto
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast248;
-          xfer += iprot->readI32(ecast248);
-          this->type = (TimeType::type)ecast248;
+          int32_t ecast254;
+          xfer += iprot->readI32(ecast254);
+          this->type = (TimeType::type)ecast254;
           this->__isset.type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4044,15 +4044,15 @@ uint32_t AccumuloProxy_getDiskUsage_args::read(::apache::thrift::protocol::TProt
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->tables.clear();
-            uint32_t _size249;
-            ::apache::thrift::protocol::TType _etype252;
-            xfer += iprot->readSetBegin(_etype252, _size249);
-            uint32_t _i253;
-            for (_i253 = 0; _i253 < _size249; ++_i253)
+            uint32_t _size255;
+            ::apache::thrift::protocol::TType _etype258;
+            xfer += iprot->readSetBegin(_etype258, _size255);
+            uint32_t _i259;
+            for (_i259 = 0; _i259 < _size255; ++_i259)
             {
-              std::string _elem254;
-              xfer += iprot->readString(_elem254);
-              this->tables.insert(_elem254);
+              std::string _elem260;
+              xfer += iprot->readString(_elem260);
+              this->tables.insert(_elem260);
             }
             xfer += iprot->readSetEnd();
           }
@@ -4085,10 +4085,10 @@ uint32_t AccumuloProxy_getDiskUsage_args::write(::apache::thrift::protocol::TPro
   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 _iter255;
-    for (_iter255 = this->tables.begin(); _iter255 != this->tables.end(); ++_iter255)
+    std::set<std::string> ::const_iterator _iter261;
+    for (_iter261 = this->tables.begin(); _iter261 != this->tables.end(); ++_iter261)
     {
-      xfer += oprot->writeString((*_iter255));
+      xfer += oprot->writeString((*_iter261));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -4116,10 +4116,10 @@ uint32_t AccumuloProxy_getDiskUsage_pargs::write(::apache::thrift::protocol::TPr
   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 _iter256;
-    for (_iter256 = (*(this->tables)).begin(); _iter256 != (*(this->tables)).end(); ++_iter256)
+    std::set<std::string> ::const_iterator _iter262;
+    for (_iter262 = (*(this->tables)).begin(); _iter262 != (*(this->tables)).end(); ++_iter262)
     {
-      xfer += oprot->writeString((*_iter256));
+      xfer += oprot->writeString((*_iter262));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -4160,14 +4160,14 @@ uint32_t AccumuloProxy_getDiskUsage_result::read(::apache::thrift::protocol::TPr
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->success.clear();
-            uint32_t _size257;
-            ::apache::thrift::protocol::TType _etype260;
-            xfer += iprot->readListBegin(_etype260, _size257);
-            this->success.resize(_size257);
-            uint32_t _i261;
-            for (_i261 = 0; _i261 < _size257; ++_i261)
+            uint32_t _size263;
+            ::apache::thrift::protocol::TType _etype266;
+            xfer += iprot->readListBegin(_etype266, _size263);
+            this->success.resize(_size263);
+            uint32_t _i267;
+            for (_i267 = 0; _i267 < _size263; ++_i267)
             {
-              xfer += this->success[_i261].read(iprot);
+              xfer += this->success[_i267].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -4222,10 +4222,10 @@ uint32_t AccumuloProxy_getDiskUsage_result::write(::apache::thrift::protocol::TP
     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
-      std::vector<DiskUsage> ::const_iterator _iter262;
-      for (_iter262 = this->success.begin(); _iter262 != this->success.end(); ++_iter262)
+      std::vector<DiskUsage> ::const_iterator _iter268;
+      for (_iter268 = this->success.begin(); _iter268 != this->success.end(); ++_iter268)
       {
-        xfer += (*_iter262).write(oprot);
+        xfer += (*_iter268).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -4278,14 +4278,14 @@ uint32_t AccumuloProxy_getDiskUsage_presult::read(::apache::thrift::protocol::TP
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             (*(this->success)).clear();
-            uint32_t _size263;
-            ::apache::thrift::protocol::TType _etype266;
-            xfer += iprot->readListBegin(_etype266, _size263);
-            (*(this->success)).resize(_size263);
-            uint32_t _i267;
-            for (_i267 = 0; _i267 < _size263; ++_i267)
+            uint32_t _size269;
+            ::apache::thrift::protocol::TType _etype272;
+            xfer += iprot->readListBegin(_etype272, _size269);
+            (*(this->success)).resize(_size269);
+            uint32_t _i273;
+            for (_i273 = 0; _i273 < _size269; ++_i273)
             {
-              xfer += (*(this->success))[_i267].read(iprot);
+              xfer += (*(this->success))[_i273].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -4455,27 +4455,27 @@ uint32_t AccumuloProxy_getLocalityGroups_result::read(::apache::thrift::protocol
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->success.clear();
-            uint32_t _size268;
-            ::apache::thrift::protocol::TType _ktype269;
-            ::apache::thrift::protocol::TType _vtype270;
-            xfer += iprot->readMapBegin(_ktype269, _vtype270, _size268);
-            uint32_t _i272;
-            for (_i272 = 0; _i272 < _size268; ++_i272)
+            uint32_t _size274;
+            ::apache::thrift::protocol::TType _ktype275;
+            ::apache::thrift::protocol::TType _vtype276;
+            xfer += iprot->readMapBegin(_ktype275, _vtype276, _size274);
+            uint32_t _i278;
+            for (_i278 = 0; _i278 < _size274; ++_i278)
             {
-              std::string _key273;
-              xfer += iprot->readString(_key273);
-              std::set<std::string> & _val274 = this->success[_key273];
+              std::string _key279;
+              xfer += iprot->readString(_key279);
+              std::set<std::string> & _val280 = this->success[_key279];
               {
-                _val274.clear();
-                uint32_t _size275;
-                ::apache::thrift::protocol::TType _etype278;
-                xfer += iprot->readSetBegin(_etype278, _size275);
-                uint32_t _i279;
-                for (_i279 = 0; _i279 < _size275; ++_i279)
+                _val280.clear();
+                uint32_t _size281;
+                ::apache::thrift::protocol::TType _etype284;
+                xfer += iprot->readSetBegin(_etype284, _size281);
+                uint32_t _i285;
+                for (_i285 = 0; _i285 < _size281; ++_i285)
                 {
-                  std::string _elem280;
-                  xfer += iprot->readString(_elem280);
-                  _val274.insert(_elem280);
+                  std::string _elem286;
+                  xfer += iprot->readString(_elem286);
+                  _val280.insert(_elem286);
                 }
                 xfer += iprot->readSetEnd();
               }
@@ -4533,16 +4533,16 @@ uint32_t AccumuloProxy_getLocalityGroups_result::write(::apache::thrift::protoco
     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 _iter281;
-      for (_iter281 = this->success.begin(); _iter281 != this->success.end(); ++_iter281)
+      std::map<std::string, std::set<std::string> > ::const_iterator _iter287;
+      for (_iter287 = this->success.begin(); _iter287 != this->success.end(); ++_iter287)
       {
-        xfer += oprot->writeString(_iter281->first);
+        xfer += oprot->writeString(_iter287->first);
         {
-          xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter281->second.size()));
-          std::set<std::string> ::const_iterator _iter282;
-          for (_iter282 = _iter281->second.begin(); _iter282 != _iter281->second.end(); ++_iter282)
+          xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter287->second.size()));
+          std::set<std::string> ::const_iterator _iter288;
+          for (_iter288 = _iter287->second.begin(); _iter288 != _iter287->second.end(); ++_iter288)
           {
-            xfer += oprot->writeString((*_iter282));
+            xfer += oprot->writeString((*_iter288));
           }
           xfer += oprot->writeSetEnd();
         }
@@ -4598,27 +4598,27 @@ uint32_t AccumuloProxy_getLocalityGroups_presult::read(::apache::thrift::protoco
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             (*(this->success)).clear();
-            uint32_t _size283;
-            ::apache::thrift::protocol::TType _ktype284;
-            ::apache::thrift::protocol::TType _vtype285;
-            xfer += iprot->readMapBegin(_ktype284, _vtype285, _size283);
-            uint32_t _i287;
-            for (_i287 = 0; _i287 < _size283; ++_i287)
+            uint32_t _size289;
+            ::apache::thrift::protocol::TType _ktype290;
+            ::apache::thrift::protocol::TType _vtype291;
+            xfer += iprot->readMapBegin(_ktype290, _vtype291, _size289);
+            uint32_t _i293;
+            for (_i293 = 0; _i293 < _size289; ++_i293)
             {
-              std::string _key288;
-              xfer += iprot->readString(_key288);
-              std::set<std::string> & _val289 = (*(this->success))[_key288];
+              std::string _key294;
+              xfer += iprot->readString(_key294);
+              std::set<std::string> & _val295 = (*(this->success))[_key294];
               {
-                _val289.clear();
-                uint32_t _size290;
-                ::apache::thrift::protocol::TType _etype293;
-                xfer += iprot->readSetBegin(_etype293, _size290);
-                uint32_t _i294;
-                for (_i294 = 0; _i294 < _size290; ++_i294)
+                _val295.clear();
+                uint32_t _size296;
+                ::apache::thrift::protocol::TType _etype299;
+                xfer += iprot->readSetBegin(_etype299, _size296);
+                uint32_t _i300;
+                for (_i300 = 0; _i300 < _size296; ++_i300)
                 {
-                  std::string _elem295;
-                  xfer += iprot->readString(_elem295);
-                  _val289.insert(_elem295);
+                  std::string _elem301;
+                  xfer += iprot->readString(_elem301);
+                  _val295.insert(_elem301);
                 }
                 xfer += iprot->readSetEnd();
               }
@@ -4718,9 +4718,9 @@ uint32_t AccumuloProxy_getIteratorSetting_args::read(::apache::thrift::protocol:
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast296;
-          xfer += iprot->readI32(ecast296);
-          this->scope = (IteratorScope::type)ecast296;
+          int32_t ecast302;
+          xfer += iprot->readI32(ecast302);
+          this->scope = (IteratorScope::type)ecast302;
           this->__isset.scope = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -5009,15 +5009,15 @@ uint32_t AccumuloProxy_getMaxRow_args::read(::apache::thrift::protocol::TProtoco
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->auths.clear();
-            uint32_t _size297;
-            ::apache::thrift::protocol::TType _etype300;
-            xfer += iprot->readSetBegin(_etype300, _size297);
-            uint32_t _i301;
-            for (_i301 = 0; _i301 < _size297; ++_i301)
+            uint32_t _size303;
+            ::apache::thrift::protocol::TType _etype306;
+            xfer += iprot->readSetBegin(_etype306, _size303);
+            uint32_t _i307;
+            for (_i307 = 0; _i307 < _size303; ++_i307)
             {
-              std::string _elem302;
-              xfer += iprot->readBinary(_elem302);
-              this->auths.insert(_elem302);
+              std::string _elem308;
+              xfer += iprot->readBinary(_elem308);
+              this->auths.insert(_elem308);
             }
             xfer += iprot->readSetEnd();
           }
@@ -5086,10 +5086,10 @@ uint32_t AccumuloProxy_getMaxRow_args::write(::apache::thrift::protocol::TProtoc
   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 _iter303;
-    for (_iter303 = this->auths.begin(); _iter303 != this->auths.end(); ++_iter303)
+    std::set<std::string> ::const_iterator _iter309;
+    for (_iter309 = this->auths.begin(); _iter309 != this->auths.end(); ++_iter309)
     {
-      xfer += oprot->writeBinary((*_iter303));
+      xfer += oprot->writeBinary((*_iter309));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -5137,10 +5137,10 @@ uint32_t AccumuloProxy_getMaxRow_pargs::write(::apache::thrift::protocol::TProto
   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 _iter304;
-    for (_iter304 = (*(this->auths)).begin(); _iter304 != (*(this->auths)).end(); ++_iter304)
+    std::set<std::string> ::const_iterator _iter310;
+    for (_iter310 = (*(this->auths)).begin(); _iter310 != (*(this->auths)).end(); ++_iter310)
     {
-      xfer += oprot->writeBinary((*_iter304));
+      xfer += oprot->writeBinary((*_iter310));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -5460,17 +5460,17 @@ uint32_t AccumuloProxy_getTableProperties_result::read(::apache::thrift::protoco
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->success.clear();
-            uint32_t _size305;
-            ::apache::thrift::protocol::TType _ktype306;
-            ::apache::thrift::protocol::TType _vtype307;
-            xfer += iprot->readMapBegin(_ktype306, _vtype307, _size305);
-            uint32_t _i309;
-            for (_i309 = 0; _i309 < _size305; ++_i309)
+            uint32_t _size311;
+            ::apache::thrift::protocol::TType _ktype312;
+            ::apache::thrift::protocol::TType _vtype313;
+            xfer += iprot->readMapBegin(_ktype312, _vtype313, _size311);
+            uint32_t _i315;
+            for (_i315 = 0; _i315 < _size311; ++_i315)
             {
-              std::string _key310;
-              xfer += iprot->readString(_key310);
-              std::string& _val311 = this->success[_key310];
-              xfer += iprot->readString(_val311);
+              std::string _key316;
+              xfer += iprot->readString(_key316);
+              std::string& _val317 = this->success[_key316];
+              xfer += iprot->readString(_val317);
             }
             xfer += iprot->readMapEnd();
           }
@@ -5525,11 +5525,11 @@ uint32_t AccumuloProxy_getTableProperties_result::write(::apache::thrift::protoc
     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 _iter312;
-      for (_iter312 = this->success.begin(); _iter312 != this->success.end(); ++_iter312)
+      std::map<std::string, std::string> ::const_iterator _iter318;
+      for (_iter318 = this->success.begin(); _iter318 != this->success.end(); ++_iter318)
       {
-        xfer += oprot->writeString(_iter312->first);
-        xfer += oprot->writeString(_iter312->second);
+        xfer += oprot->writeString(_iter318->first);
+        xfer += oprot->writeString(_iter318->second);
       }
       xfer += oprot->writeMapEnd();
     }
@@ -5582,17 +5582,17 @@ uint32_t AccumuloProxy_getTableProperties_presult::read(::apache::thrift::protoc
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             (*(this->success)).clear();
-            uint32_t _size313;
-            ::apache::thrift::protocol::TType _ktype314;
-            ::apache::thrift::protocol::TType _vtype315;
-            xfer += iprot->readMapBegin(_ktype314, _vtype315, _size313);
-            uint32_t _i317;
-            for (_i317 = 0; _i317 < _size313; ++_i317)
+            uint32_t _size319;
+            ::apache::thrift::protocol::TType _ktype320;
+            ::apache::thrift::protocol::TType _vtype321;
+            xfer += iprot->readMapBegin(_ktype320, _vtype321, _size319);
+            uint32_t _i323;
+            for (_i323 = 0; _i323 < _size319; ++_i323)
             {
-              std::string _key318;
-              xfer += iprot->readString(_key318);
-              std::string& _val319 = (*(this->success))[_key318];
-              xfer += iprot->readString(_val319);
+              std::string _key324;
+              xfer += iprot->readString(_key324);
+              std::string& _val325 = (*(this->success))[_key324];
+              xfer += iprot->readString(_val325);
             }
             xfer += iprot->readMapEnd();
           }
@@ -6328,14 +6328,14 @@ uint32_t AccumuloProxy_listSplits_result::read(::apache::thrift::protocol::TProt
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->success.clear();
-            uint32_t _size320;
-            ::apache::thrift::protocol::TType _etype323;
-            xfer += iprot->readListBegin(_etype323, _size320);
-            this->success.resize(_size320);
-            uint32_t _i324;
-            for (_i324 = 0; _i324 < _size320; ++_i324)
+            uint32_t _size326;
+            ::apache::thrift::protocol::TType _etype329;
+            xfer += iprot->readListBegin(_etype329, _size326);
+            this->success.resize(_size326);
+            uint32_t _i330;
+            for (_i330 = 0; _i330 < _size326; ++_i330)
             {
-              xfer += iprot->readBinary(this->success[_i324]);
+              xfer += iprot->readBinary(this->success[_i330]);
             }
             xfer += iprot->readListEnd();
           }
@@ -6390,10 +6390,10 @@ uint32_t AccumuloProxy_listSplits_result::write(::apache::thrift::protocol::TPro
     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 _iter325;
-      for (_iter325 = this->success.begin(); _iter325 != this->success.end(); ++_iter325)
+      std::vector<std::string> ::const_iterator _iter331;
+      for (_iter331 = this->success.begin(); _iter331 != this->success.end(); ++_iter331)
       {
-        xfer += oprot->writeBinary((*_iter325));
+        xfer += oprot->writeBinary((*_iter331));
       }
       xfer += oprot->writeListEnd();
     }
@@ -6446,14 +6446,14 @@ uint32_t AccumuloProxy_listSplits_presult::read(::apache::thrift::protocol::TPro
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             (*(this->success)).clear();
-            uint32_t _size326;
-            ::apache::thrift::protocol::TType _etype329;
-            xfer += iprot->readListBegin(_etype329, _size326);
-            (*(this->success)).resize(_size326);
-            uint32_t _i330;
-            for (_i330 = 0; _i330 < _size326; ++_i330)
+            uint32_t _size332;
+            ::apache::thrift::protocol::TType _etype335;
+            xfer += iprot->readListBegin(_etype335, _size332);
+            (*(this->success)).resize(_size332);
+            uint32_t _i336;
+            for (_i336 = 0; _i336 < _size332; ++_i336)
             {
-              xfer += iprot->readBinary((*(this->success))[_i330]);
+              xfer += iprot->readBinary((*(this->success))[_i336]);
             }
             xfer += iprot->readListEnd();
           }
@@ -6607,15 +6607,15 @@ uint32_t AccumuloProxy_listTables_result::read(::apache::thrift::protocol::TProt
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->success.clear();
-            uint32_t _size331;
-            ::apache::thrift::protocol::TType _etype334;
-            xfer += iprot->readSetBegin(_etype334, _size331);
-            uint32_t _i335;
-            for (_i335 = 0; _i335 < _size331; ++_i335)
+            uint32_t _size337;
+            ::apache::thrift::protocol::TType _etype340;
+            xfer += iprot->readSetBegin(_etype340, _size337);
+            uint32_t _i341;
+            for (_i341 = 0; _i341 < _size337; ++_i341)
             {
-              std::string _elem336;
-              xfer += iprot->readString(_elem336);
-              this->success.insert(_elem336);
+              std::string _elem342;
+              xfer += iprot->readString(_elem342);
+              this->success.insert(_elem342);
             }
             xfer += iprot->readSetEnd();
           }
@@ -6646,10 +6646,10 @@ uint32_t AccumuloProxy_listTables_result::write(::apache::thrift::protocol::TPro
     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_SET, 0);
     {
       xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
-      std::set<std::string> ::const_iterator _iter337;
-      for (_iter337 = this->success.begin(); _iter337 != this->success.end(); ++_iter337)
+      std::set<std::string> ::const_iterator _iter343;
+      for (_iter343 = this->success.begin(); _iter343 != this->success.end(); ++_iter343)
       {
-        xfer += oprot->writeString((*_iter337));
+        xfer += oprot->writeString((*_iter343));
       }
       xfer += oprot->writeSetEnd();
     }
@@ -6690,15 +6690,15 @@ uint32_t AccumuloProxy_listTables_presult::read(::apache::thrift::protocol::TPro
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             (*(this->success)).clear();
-            uint32_t _size338;
-            ::apache::thrift::protocol::TType _etype341;
-            xfer += iprot->readSetBegin(_etype341, _size338);
-            uint32_t _i342;
-            for (_i342 = 0; _i342 < _size338; ++_i342)
+            uint32_t _size344;
+            ::apache::thrift::protocol::TType _etype347;
+            xfer += iprot->readSetBegin(_etype347, _size344);
+            uint32_t _i348;
+            for (_i348 = 0; _i348 < _size344; ++_i348)
             {
-              std::string _elem343;
-              xfer += iprot->readString(_elem343);
-              (*(this->success)).insert(_elem343);
+              std::string _elem349;
+              xfer += iprot->readString(_elem349);
+              (*(this->success)).insert(_elem349);
             }
             xfer += iprot->readSetEnd();
           }
@@ -6844,29 +6844,29 @@ uint32_t AccumuloProxy_listIterators_result::read(::apache::thrift::protocol::TP
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->success.clear();
-            uint32_t _size344;
-            ::apache::thrift::protocol::TType _ktype345;
-            ::apache::thrift::protocol::TType _vtype346;
-            xfer += iprot->readMapBegin(_ktype345, _vtype346, _size344);
-            uint32_t _i348;
-            for (_i348 = 0; _i348 < _size344; ++_i348)
+            uint32_t _size350;
+            ::apache::thrift::protocol::TType _ktype351;
+            ::apache::thrift::protocol::TType _vtype352;
+            xfer += iprot->readMapBegin(_ktype351, _vtype352, _size350);
+            uint32_t _i354;
+            for (_i354 = 0; _i354 < _size350; ++_i354)
             {
-              std::string _key349;
-              xfer += iprot->readString(_key349);
-              std::set<IteratorScope::type> & _val350 = this->success[_key349];
+              std::string _key355;
+              xfer += iprot->readString(_key355);
+              std::set<IteratorScope::type> & _val356 = this->success[_key355];
               {
-                _val350.clear();
-                uint32_t _size351;
-                ::apache::thrift::protocol::TType _etype354;
-                xfer += iprot->readSetBegin(_etype354, _size351);
-                uint32_t _i355;
-                for (_i355 = 0; _i355 < _size351; ++_i355)
+                _val356.clear();
+                uint32_t _size357;
+                ::apache::thrift::protocol::TType _etype360;
+                xfer += iprot->readSetBegin(_etype360, _size357);
+                uint32_t _i361;
+                for (_i361 = 0; _i361 < _size357; ++_i361)
                 {
-                  IteratorScope::type _elem356;
-                  int32_t ecast357;
-                  xfer += iprot->readI32(ecast357);
-                  _elem356 = (IteratorScope::type)ecast357;
-                  _val350.insert(_elem356);
+                  IteratorScope::type _elem362;
+                  int32_t ecast363;
+                  xfer += iprot->readI32(ecast363);
+                  _elem362 = (IteratorScope::type)ecast363;
+                  _val356.insert(_elem362);
                 }
                 xfer += iprot->readSetEnd();
               }
@@ -6924,16 +6924,16 @@ uint32_t AccumuloProxy_listIterators_result::write(::apache::thrift::protocol::T
     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<IteratorScope::type> > ::const_iterator _iter358;
-      for (_iter358 = this->success.begin(); _iter358 != this->success.end(); ++_iter358)
+      std::map<std::string, std::set<IteratorScope::type> > ::const_iterator _iter364;
+      for (_iter364 = this->success.begin(); _iter364 != this->success.end(); ++_iter364)
       {
-        xfer += oprot->writeString(_iter358->first);
+        xfer += oprot->writeString(_iter364->first);
         {
-          xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(_iter358->second.size()));
-          std::set<IteratorScope::type> ::const_iterator _iter359;
-          for (_iter359 = _iter358->second.begin(); _iter359 != _iter358->second.end(); ++_iter359)
+          xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(_iter364->second.size()));
+          std::set<IteratorScope::type> ::const_iterator _iter365;
+          for (_iter365 = _iter364->second.begin(); _iter365 != _iter364->second.end(); ++_iter365)
           {
-            xfer += oprot->writeI32((int32_t)(*_iter359));
+            xfer += oprot->writeI32((int32_t)(*_iter365));
           }
           xfer += oprot->writeSetEnd();
         }
@@ -6989,29 +6989,29 @@ uint32_t AccumuloProxy_listIterators_presult::read(::apache::thrift::protocol::T
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             (*(this->success)).clear();
-            uint32_t _size360;
-            ::apache::thrift::protocol::TType _ktype361;
-            ::apache::thrift::protocol::TType _vtype362;
-            xfer += iprot->readMapBegin(_ktype361, _vtype362, _size360);
-            uint32_t _i364;
-            for (_i364 = 0; _i364 < _size360; ++_i364)
+            uint32_t _size366;
+            ::apache::thrift::protocol::TType _ktype367;
+            ::apache::thrift::protocol::TType _vtype368;
+            xfer += iprot->readMapBegin(_ktype367, _vtype368, _size366);
+            uint32_t _i370;
+            for (_i370 = 0; _i370 < _size366; ++_i370)
             {
-              std::string _key365;
-              xfer += iprot->readString(_key365);
-              std::set<IteratorScope::type> & _val366 = (*(this->success))[_key365];
+              std::string _key371;
+              xfer += iprot->readString(_key371);
+              std::set<IteratorScope::type> & _val372 = (*(this->success))[_key371];
               {
-                _val366.clear();
-                uint32_t _size367;
-                ::apache::thrift::protocol::TType _etype370;
-                xfer += iprot->readSetBegin(_etype370, _size367);
-                uint32_t _i371;
-                for (_i371 = 0; _i371 < _size367; ++_i371)
+                _val372.clear();
+                uint32_t _size373;
+                ::apache::thrift::protocol::TType _etype376;
+                xfer += iprot->readSetBegin(_etype376, _size373);
+                uint32_t _i377;
+                for (_i377 = 0; _i377 < _size373; ++_i377)
                 {
-                  IteratorScope::type _elem372;
-                  int32_t ecast373;
-                  xfer += iprot->readI32(ecast373);
-                  _elem372 = (IteratorScope::type)ecast373;
-                  _val366.insert(_elem372);
+                  IteratorScope::type _elem378;
+                  int32_t ecast379;
+                  xfer += iprot->readI32(ecast379);
+                  _elem378 = (IteratorScope::type)ecast379;
+                  _val372.insert(_elem378);
                 }
                 xfer += iprot->readSetEnd();
               }
@@ -7184,17 +7184,17 @@ uint32_t AccumuloProxy_listConstraints_result::read(::apache::thrift::protocol::
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->success.clear();
-            uint32_t _size374;
-            ::apache::thrift::protocol::TType _ktype375;
-            ::apache::thrift::protocol::TType _vtype376;
-            xfer += iprot->readMapBegin(_ktype375, _vtype376, _size374);
-            uint32_t _i378;
-            for (_i378 = 0; _i378 < _size374; ++_i378)
+            uint32_t _size380;
+            ::apache::thrift::protocol::TType _ktype381;
+            ::apache::thrift::protocol::TType _vtype382;
+            xfer += iprot->readMapBegin(_ktype381, _vtype382, _size380);
+            uint32_t _i384;
+            for (_i384 = 0; _i384 < _size380; ++_i384)
             {
-              std::string _key379;
-              xfer += iprot->readString(_key379);
-              int32_t& _val380 = this->success[_key379];
-              xfer += iprot->readI32(_val380);
+              std::string _key385;
+              xfer += iprot->readString(_key385);
+              int32_t& _val386 = this->success[_key385];
+              xfer += iprot->readI32(_val386);
             }
             xfer += iprot->readMapEnd();
           }
@@ -7249,11 +7249,11 @@ uint32_t AccumuloProxy_listConstraints_result::write(::apache::thrift::protocol:
     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
     {
       xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->success.size()));
-      std::map<std::string, int32_t> ::const_iterator _iter381;
-      for (_iter381 = this->success.begin(); _iter381 != this->success.end(); ++_iter381)
+      std::map<std::string, int32_t> ::const_iterator _iter387;
+      for (_iter387 = this->success.begin(); _iter387 != this->success.end(); ++_iter387)
       {
-        xfer += oprot->writeString(_iter381->first);
-        xfer += oprot->writeI32(_iter381->second);
+        xfer += oprot->writeString(_iter387->first);
+        xfer += oprot->writeI32(_iter387->second);
       }
       xfer += oprot->writeMapEnd();
     }
@@ -7306,17 +7306,17 @@ uint32_t AccumuloProxy_listConstraints_presult::read(::apache::thrift::protocol:
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             (*(this->success)).clear();
-            uint32_t _size382;
-            ::apache::thrift::protocol::TType _ktype383;
-            ::apache::thrift::protocol::TType _vtype384;
-            xfer += iprot->readMapBegin(_ktype383, _vtype384, _size382);
-            uint32_t _i386;
-            for (_i386 = 0; _i386 < _size382; ++_i386)
+            uint32_t _size388;
+            ::apache::thrift::protocol::TType _ktype389;
+            ::apache::thrift::protocol::TType _vtype390;
+            xfer += iprot->readMapBegin(_ktype389, _vtype390, _size388);
+            uint32_t _i392;
+            for (_i392 = 0; _i392 < _size388; ++_i392)
             {
-              std::string _key387;
-              xfer += iprot->readString(_key387);
-              int32_t& _val388 = (*(this->success))[_key387];
-              xfer += iprot->readI32(_val388);
+              std::string _key393;
+              xfer += iprot->readString(_key393);
+              int32_t& _val394 = (*(this->success))[_key393];
+              xfer += iprot->readI32(_val394);
             }
             xfer += iprot->readMapEnd();
           }
@@ -8467,17 +8467,17 @@ uint32_t AccumuloProxy_removeIterator_args::read(::apache::thrift::protocol::TPr
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->scopes.clear();
-            uint32_t _size389;
-            ::apache::thrift::protocol::TType _etype392;
-            xfer += iprot->readSetBegin(_etype392, _size389);
-            uint32_t _i393;
-            for (_i393 = 0; _i393 < _size389; ++_i393)
+            uint32_t _size395;
+            ::apache::thrift::protocol::TType _etype398;
+            xfer += iprot->readSetBegin(_etype398, _size395);
+            uint32_t _i399;
+            for (_i399 = 0; _i399 < _size395; ++_i399)
             {
-              IteratorScope::type _elem394;
-              int32_t ecast395;
-              xfer += iprot->readI32(ecast395);
-              _elem394 = (IteratorScope::type)ecast395;
-              this->scopes.insert(_elem394);
+              IteratorScope::type _elem400;
+              int32_t ecast401;
+              xfer += iprot->readI32(ecast401);
+              _elem400 = (IteratorScope::type)ecast401;
+              this->scopes.insert(_elem400);
             }
             xfer += iprot->readSetEnd();
           }
@@ -8518,10 +8518,10 @@ uint32_t AccumuloProxy_removeIterator_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 _iter396;
-    for (_iter396 = this->scopes.begin(); _iter396 != this->scopes.end(); ++_iter396)
+    std::set<IteratorScope::type> ::const_iterator _iter402;
+    for (_iter402 = this->scopes.begin(); _iter402 != this->scopes.end(); ++_iter402)
     {
-      xfer += oprot->writeI32((int32_t)(*_iter396));
+      xfer += oprot->writeI32((int32_t)(*_iter402));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -8557,10 +8557,10 @@ uint32_t AccumuloProxy_removeIterator_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 _iter397;
-    for (_iter397 = (*(this->scopes)).begin(); _iter397 != (*(this->scopes)).end(); ++_iter397)
+    std::set<IteratorScope::type> ::const_iterator _iter403;
+    for (_iter403 = (*(this->scopes)).begin(); _iter403 != (*(this->scopes)).end(); ++_iter403)
     {
-      xfer += oprot->writeI32((int32_t)(*_iter397));
+      xfer += oprot->writeI32((int32_t)(*_iter403));
     }
     xfer += oprot->writeSetEnd();
   }
@@ -9303,27 +9303,27 @@ uint32_t AccumuloProxy_setLocalityGroups_args::read(::apache::thrift::protocol::
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->groups.clear();
-            uint32_t _size398;
-            ::apache::thrift::protocol::TType _ktype399;
-            ::apache::thrift::protocol::TType _vtype400;
-            xfer += iprot->readMapBegin(_ktype399, _vtype400, _size398);
-            uint32_t _i402;
-            for (_i402 = 0; _i402 < _size398; ++_i402)
+            uint32_t _size404;
+            ::apache::thrift::protocol::TType _ktype405;
+            ::apache::thrift::protocol::TType _vtype406;
+            xfer += iprot->readMapBegin(_ktype405, _vtype406, _size404);
+            uint32_t _i408;
+            for (_i408 = 0; _i408 < _size404; ++_i408)
             {
-              std::string _key403;
-              xfer += iprot->readString(_key403);
-              std::set<std::string> & _val404 = this->groups[_key403];
+              std::string _key409;
+              xfer += iprot->readString(_key409);
+              std::set<std::string> & _val410 = this->groups[_key409];
               {
-                _val404.clear();
-                uint32_t _size405;
-                ::apache::thrift::protocol::TType _etype408;
-                xfer += iprot->readSetBegin(_etype408, _size405);
-                uint32_t _i409;
-                for (_i409 = 0; _i409 < _size405; ++_i409)
+                _val410.clear();
+                uint32_t _size411;
+                ::apache::thrift::protocol::TType _etype414;
+                xfer += iprot->readSetBegin(_etype414, _size411);
+                uint32_t _i415;
+                for (_i415 = 0; _i415 < _size411; ++_i415)
                 {
-                  std::string _elem410;
-                  xfer += iprot->readString(_elem410);
-                  _val404.insert(_elem410);
+                  std::string _elem416;
+                  xfer += iprot->readString(_elem416);
+                  _val410.insert(_elem416);
                 }
                 xfer += iprot->readSetEnd();
               }
@@ -9363,16 +9363,16 @@ uint32_t AccumuloProxy_setLocalityGroups_args::write(::apache::thrift::protocol:
   xfer += oprot->writeFieldBegin("groups", ::apache::thrift::protocol::T_MAP, 3);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_SET, static_cast<uint32_t>(this->groups.size()));
-    std::map<std::string, std::set<std::string> > ::const_iterator _iter411;
-    for (_iter411 = this->groups.begin(); _iter411 != this->groups.end(); ++_iter411)
+    std::map<std::string, std::set<std::string> > ::const_iterator _iter417;
+    for (_iter417 = this->groups.begin(); _iter417 != this->groups.end(); ++_iter417)
     {
-      xfer += oprot->writeString(_iter411->first);
+      xfer += oprot->writeString(_iter417->first);
       {
-        xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter411->second.size()));
-        std::set<std::string> ::const_iterator _iter412;
-        for (_iter412 = _iter411->second.begin(); _iter412 != _iter411->second.end(); ++_iter412)
+        xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter417->second.size()));
+        std::set<std::string> ::const_iterator _iter418;
+        for (_iter418 = _iter417->second.begin(); _iter418 != _iter417->second.end(); ++_iter418)
         {
-          xfer += oprot->writeString((*_iter412));
+          xfer += oprot->writeString((*_iter418));
         }
         xfer += oprot->writeSetEnd();
       }
@@ -9407,16 +9407,16 @@ uint32_t AccumuloProxy_setLocalityGroups_pargs::write(::apache::thrift::protocol
   xfer += oprot->writeFieldBegin("groups", ::apache::thrift::protocol::T_MAP, 3);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_SET, static_cast<uint32_t>((*(this->groups)).size()));
-    std::map<std::string, std::set<std::string> > ::const_iterator _iter413;
-    for (_iter413 = (*(this->groups)).begin(); _iter413 != (*(this->groups)).end(); ++_iter413)
+    std::map<std::string, std::set<std::string> > ::const_iterator _iter419;
+    for (_iter419 = (*(this->groups)).begin(); _iter419 != (*(this->groups)).end(); ++_iter419)
     {
-      xfer += oprot->writeString(_iter413->first);
+      xfer += oprot->writeString(_iter419->first);
       {
-        xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter413->second.size()));
-        std::set<std::string> ::const_iterator _iter414;
-        for (_iter414 = _iter413->second.begin(); _iter414 != _iter413->second.end(); ++_iter414)
+        xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter419->second.size()));
+        std::set<std::string> ::const_iterator _iter420;
+        for (_iter420 = _iter419->second.begin(); _iter420 != _iter419->second.end(); ++_iter420)
         {
-          xfer += oprot->writeString((*_iter414));
+          xfer += oprot->writeString((*_iter420));
         }
         xfer += oprot->writeSetEnd();
       }
@@ -10010,15 +10010,15 @@ uint32_t AccumuloProxy_splitRangeByTablets_result::read(::apache::thrift::protoc
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->success.clear();
-            uint32_t _size415;
-            ::apache::thrift::protocol::TType _etype418;
-            xfer += iprot->readSetBegin(_etype418, _size415);
-            uint32_t _i419;
-            for (_i419 = 0; _i419 < _size415; ++_i419)
+            uint32_t _size421;
+            ::apache::thrift::protocol::TType _etype424;
+            xfer += iprot->readSetBegin(_etype424, _size421);
+            uint32_t _i425;
+            for (_i425 = 0; _i425 < _size421; ++_i425)
             {
-              Range _elem420;
-              xfer += _elem420.read(iprot);
-              this->success.insert(_elem420);
+              Range _elem426;
+              xfer += _elem426.read(iprot);
+              this->success.insert(_elem426);
             }
             xfer += iprot->readSetEnd();
           }
@@ -10073,10 +10073,10 @@ uint32_t AccumuloProxy_splitRangeByTablets_result::write(::apache::thrift::proto
     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_SET, 0);
     {
       xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
-      std::set<Range> ::const_iterator _iter421;
-      for (_iter421 = this->success.begin(); _iter421 != this->success.end(); ++_iter421)
+      std::set<Range> ::const_iterator _iter427;
+      for (_iter427 = this->success.begin(); _iter427 != this->success.end(); ++_iter427)
       {
-        xfer += (*_iter421).write(oprot);
+        xfer += (*_iter427).write(oprot);
       }
       xfer += oprot->writeSetEnd();
     }
@@ -10129,15 +10129,15 @@ uint32_t AccumuloProxy_splitRangeByTablets_presult::read(::apache::thrift::proto
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             (*(this->success)).clear();
-            uint32_t _size422;
-            ::apache::thrift::protocol::TType _etype425;
-            xfer += iprot->readSetBegin(_etype425, _size422);
-            uint32_t _i426;
-            for (_i426 = 0; _i426 < _size422; ++_i426)
+            uint32_t _size428;
+            ::apache::thrift::protocol::TType _etype431;
+            xfer += iprot->readSetBegin(_etype431, _size428);
+            uint32_t _i432;
+            for (_i432 = 0; _i432 < _size428; ++_i432)
             {
-              Range _elem427;
-              xfer += _elem427.read(iprot);
-              (*(this->success)).insert(_elem427);
+              Range _elem433;
+              xfer += _elem433.read(iprot);
+              (*(this->success)).insert(_elem433);
             }
             xfer += iprot->readSetEnd();
           }
@@ -10494,17 +10494,17 @@ uint32_t AccumuloProxy_tableIdMap_result::read(::apache::thrift::protocol::TProt
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->success.clear();
-            uint32_t _size428;
-            ::apache::thrift::protocol::TType _ktype429;
-            ::apache::thrift::protocol::TType _vtype430;
-            xfer += iprot->readMapBegin(_ktype429, _vtype430, _size428);
-            uint32_t _i432;
-            for (_i432 = 0; _i432 < _size428; ++_i432)
+            uint32_t _size434;
+            ::apache::thrift::protocol::TType _ktype435;
+            ::apache::thrift::protocol::TType _vtype436;
+            xfer += iprot->readMapBegin(_ktype435, _vtype436, _size434);
+            uint32_t _i438;
+            for (_i438 = 0; _i438 < _size434; ++_i438)
             {
-              std::string _key433;
-              xfer += iprot->readString(_key433);
-              std::string& _val434 = this->success[_key433];
-              xfer += iprot->readString(_val434);
+              std::string _key439;
+              xfer += iprot->readString(_key439);
+              std::string& _val440 = this->success[_key439];
+              xfer += iprot->readString(_val440);
             }
             xfer += iprot->readMapEnd();
           }
@@ -10535,11 +10535,11 @@ uint32_t AccumuloProxy_tableIdMap_result::write(::apache::thrift::protocol::TPro
     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 _iter435;
-      for (_iter435 = this->success.begin(); _iter435 != this->success.end(); ++_iter435)
+      std::map<std::string, std::string> ::const_iterator _iter441;
+      for (_iter441 = this->success.begin(); _iter441 != this->success.end(); ++_iter441)
       {
-        xfer += oprot->writeString(_iter435->first);
-        xfer += oprot->writeString(_iter435->second);
+        xfer += oprot->writeString(_iter441->first);
+        xfer += oprot->writeString(_iter441->second);
       }
       xfer += oprot->writeMapEnd();
     }
@@ -10580,17 +10580,17 @@ uint32_t AccumuloProxy_tableIdMap_presult::read(::apache::thrift::protocol::TPro
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             (*(this->success)).clear();
-            uint32_t _size436;
-            ::apache::thrift::protocol::TType _ktype437;
-            ::apache::thrift::protocol::TType _vtype438;
-            xfer += iprot->readMapBegin(_ktype437, _vtype438, _size436);
-            uint32_t _i440;
-            for (_i440 = 0; _i440 < _size436; ++_i440)
+            uint32_t _size442;
+            ::apache::thrift::protocol::TType _ktype443;
+            ::apache::thrift::protocol::TType _vtype444;
+            xfer += iprot->readMapBegin(_ktype443, _vtype444, _size442);
+            uint32_t _i446;
+            for (_i446 = 0; _i446 < _size442; ++_i446)
             {
-              std::string _key441;
-              xfer += iprot->readString(_key441);
-              std::string& _val442 = (*(this->success))[_key441];
-              xfer += iprot->readString(_val442);
+              std::string _key447;
+              xfer += iprot->readString(_key447);
+              std::string& _val448 = (*(this->success))[_key447];
+              xfer += iprot->readString(_val448);
             }
             xfer += iprot->readMapEnd();
           }
@@ -11254,14 +11254,14 @@ uint32_t AccumuloProxy_getActiveScans_result::read(::apache::thrift::protocol::T
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->success.clear();
-            uint32_t _size443;
-            ::apache::thrift::protocol::TType _etype446;
-            xfer += iprot->readListBegin(_etype446, _size443);
-            this->success.resize(_size443);
-            uint32_t _i447;
-            for (_i447 = 0; _i447 < _size443; ++_i447)
+            uint32_t _size449;
+            ::apache::thrift::protocol::TType _etype452;
+            xfer += iprot->readListBegin(_etype452, _size449);
+            this->success.resize(_size449);
+            uint32_t _i453;
+            for (_i453 = 0; _i453 < _size449; ++_i453)
             {
-              xfer += this->success[_i447].read(iprot);
+              xfer += this->success[_i453].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -11308,10 +11308,10 @@ uint32_t AccumuloProxy_getActiveScans_result::write(::apache::thrift::protocol::
     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
-      std::vector<ActiveScan> ::const_iterator _iter448;
-      for (_iter448 = this->success.begin(); _iter448 != this->success.end(); ++_iter448)
+      std::vector<ActiveScan> ::const_iterator _iter454;
+      for (_iter454 = this->success.begin(); _iter454 != this->success.end(); ++_iter454)
       {
-        xfer += (*_iter448).write(oprot);
+        xfer += (*_iter454).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -11360,14 +11360,14 @@ uint32_t AccumuloProxy_getActiveScans_presult::read(::apache::thrift::protocol::
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             (*(this->success)).clear();
-            uint32_t _size449;
-            ::apache::thrift::protocol::TType _etype452;
-            xfer += iprot->readListBegin(_etype452, _size449);
-            (*(this->success)).resize(_size449);
-            uint32_t _i453;
-            for (_i453 = 0; _i453 < _size449; ++_i453)
+            uint32_t _size455;
+            ::apache::thrift::protocol::TType _etype458;
+            xfer += iprot->readListBegin(_etype458, _size455);
+            (*(this->success)).resize(_size455);
+            uint32_t _i459;
+            for (_i459 = 0; _i459 < _size455; ++_i459)
             {
-              xfer += (*(this->success))[_i453].read(iprot);
+              xfer += (*(this->success))[_i459].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -11529,14 +11529,14 @@ uint32_t AccumuloProxy_getActiveCompactions_result::read(::apache::thrift::proto
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->success.clear();
-            uint32_t _size454;
-            ::apache::thrift::protocol::TType _etype457;
-            xfer += iprot->readListBegin(_etype457, _size454);
-            this->success.resize(_size454);
-            uint32_t _i458;
-            for (_i458 = 0; _i458 < _size454; ++_i458)
+            uint32_t _size460;
+            ::apache::thrift::protocol::TType _etype463;
+            xfer += iprot->readListBegin(_etype463, _size460);
+            this->success.resize(_size460);
+            uint32_t _i464;
+            for (_i464 = 0; _i464 < _size460; ++_i464)
             {
-              xfer += this->success[_i458].read(iprot);
+              xfer += this->success[_i464].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -11583,10 +11583,10 @@ uint32_t AccumuloProxy_getActiveCompactions_result::write(::apache::thrift::prot
     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
-      std::vector<ActiveCompaction> ::const_iterator _iter459;
-      for (_iter459 = this->success.begin(); _iter459 != this->success.end(); ++_iter459)
+      std::vector<ActiveCompaction> ::const_iterator _iter465;
+      for (_iter465 = this->success.begin(); _iter465 != this->success.end(); ++_iter465)
       {
-        xfer += (*_iter459).write(oprot);
+        xfer += (*_iter465).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -11635,14 +11635,14 @@ uint32_t AccumuloProxy_getActiveCompactions_presult::read(::apache::thrift::prot
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             (*(this->success)).clear();
-            uint32_t _size460;
-            ::apache::thrift::protocol::TType _etype463;
-            xfer += iprot->readListBegin(_etype463, _size460);
-            (*(this->success)).resize(_size460);
-            uint32_t _i464;
-            for (_i464 = 0; _i464 < _size460; ++_i464)
+            uint32_t _size466;
+            ::apache::thrift::protocol::TType _etype469;
+            xfer += iprot->readListBegin(_etype469, _size466);
+            (*(this->success)).resize(_size466);
+            uint32_t _i470;
+            for (_i470 = 0; _i470 < _size466; ++_i470)
             {
-              xfer += (*(this->success))[_i464].read(iprot);
+              xfer += (*(this->success))[_i470].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -11788,17 +11788,17 @@ uint32_t AccumuloProxy_getSiteConfiguration_result::read(::apache::thrift::proto
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->success.clear();
-            uint32_t _size465;
-            ::apache::thrift::protocol::TType _ktype466;
-            ::apache::thrift::protocol::TType _vtype467;
-            xfer += iprot->readMapBegin(_ktype466, _vtype467, _size465);
-            uint32_t _i469;
-            for (_i469 = 0; _i469 < _size465; ++_i469)
+            uint32_t _size471;
+            ::apache::thrift::protocol::TType _ktype472;
+            ::apache::thrift::protocol::TType _vtype473;
+            xfer += iprot->readMapBegin(_ktype472, _vtype473, _size471);
+            uint32_t _i475;
+            for (_i475 = 0; _i475 < _size471; ++_i475)
             {
-              std::string _key470;
-              xfer += iprot->readString(_key470);
-              std::string& _val471 = this->success[_key470];
-              xfer += iprot->readString(_val471);
+              std::string _key476;
+              xfer += iprot->readString(_key476);
+              std::string& _val477 = this->success[_key476];
+              xfer += iprot->readString(_val477);
             }
             xfer += iprot->readMapEnd();
           }
@@ -11845,11 +11845,11 @@ uint32_t AccumuloProxy_getSiteConfiguration_result::write(::apache::thrift::prot
     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 _iter472;
-      for (_iter472 = this->success.begin(); _iter472 != this->success.end(); ++_iter472)
+      std::map<std::string, std::string> ::const_iterator _iter478;
+      for (_iter478 = this->success.begin(); _iter478 != this->success.end(); ++_iter478)
       {
-        xfer += oprot->writeString(_iter472->first);
-        xfer += oprot->writeString(_iter472->second);
+        xfer += oprot->writeString(_iter478->first);
+        xfer += oprot->writeString(_iter478->second);
       }
       xfer += oprot->writeMapEnd();
     }
@@ -11898,17 +11898,17 @@ uint32_t AccumuloProxy_getSiteConfiguration_presult::read(::apache::thrift::prot
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             (*(this->success)).clear();
-            uint32_t _size473;
-            ::apache::thrift::protocol::TType _ktype474;
-            ::apache::thrift::protocol::TType _vtype475;
-            xfer += iprot->readMapBegin(_ktype474, _vtype475, _size473);
-            uint32_t _i477;
-            for (_i477 = 0; _i477 < _size473; ++_i477)
+            uint32_t _size479;
+            ::apache::thrift::protocol::TType _ktype480;
+            ::apache::thrift::protocol::TType _vtype481;
+            xfer += iprot->readMapBegin(_ktype480, _vtype481, _size479);
+            uint32_t _i483;
+            for (_i483 = 0; _i483 < _size479; ++_i483)
             {
-              std::string _key478;
-              xfer += iprot->readString(_key478);
-              std::string& _val479 = (*(this->success))[_key478];
-              xfer += iprot->readString(_val479);
+              std::string _key484;
+              xfer += iprot->readString(_key484);
+              std::string& _val485 = (*(this->success))[_key484];
+              xfer += iprot->readString(_val485);
             }
             xfer += iprot->readMapEnd();
           }
@@ -12054,17 +12054,17 @@ uint32_t AccumuloProxy_getSystemConfiguration_result::read(::apache::thrift::pro
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->success.clear();
-            uint32_t _size480;
-            ::apache::thrift::protocol::TType _ktype481;
-            ::apache::thrift::protocol::TType _vtype482;
-            xfer += iprot->readMapBegin(_ktype481, _vtype482, _size480);
-            uint32_t _i484;
-            for (_i484 = 0; _i484 < _size480; ++_i484)
+            uint32_t _size486;
+            ::apache::thrift::protocol::TType _ktype487;
+            ::apache::thrift::protocol::TType _vtype488;
+            xfer += iprot->readMapBegin(_ktype487, _vtype488, _size486);
+            uint32_t _i490;
+            for (_i490 = 0; _i490 < _size486; ++_i490)
             {
-              std::string _key485;
-              xfer += iprot->readString(_key485);
-              std::string& _val486 = this->success[_key485];
-              xfer += iprot->readString(_val486);
+              std::string _key491;
+              xfer += iprot->readString(_key491);
+              std::string& _val492 = this->success[_key491];
+              xfer += iprot->readString(_val492);
             }
             xfer += iprot->readMapEnd();
           }
@@ -12111,11 +12111,11 @@ uint32_t AccumuloProxy_getSystemConfiguration_result::write(::apache::thrift::pr
     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 _iter487;
-      for (_iter487 = this->success.begin(); _iter487 != this->success.end(); ++_iter487)
+      std::map<std::string, std::string> ::const_iterator _iter493;
+      for (_iter493 = this->success.begin(); _iter493 != this->success.end(); ++_iter493)
       {
-        xfer += oprot->writeString(_iter487->first);
-        xfer += oprot->writeString(_iter487->second);
+        xfer += oprot->writeString(_iter493->first);
+        xfer += oprot->writeString(_iter493->second);
       }
       xfer += oprot->writeMapEnd();
     }
@@ -12164,17 +12164,17 @@ uint32_t AccumuloProxy_getSystemConfiguration_presult::read(::apache::thrift::pr
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             (*(this->success)).clear();
-            uint32_t _size488;
-            ::apache::thrift::protocol::TType _ktype489;
-            ::apache::thrift::protocol::TType _vtype490;
-            xfer += iprot->readMapBegin(_ktype489, _vtype490, _size488);
-            uint32_t _i492;
-            for (_i492 = 0; _i492 < _size488; ++_i492)
+            uint32_t _size494;
+            ::apache::thrift::protocol::TType _ktype495;
+            ::apache::thrift::protocol::TType _vtype496;
+            xfer += iprot->readMapBegin(_ktype495, _vtype496, _size494);
+            uint32_t _i498;
+            for (_i498 = 0; _i498 < _size494; ++_i498)
             {
-              std::string _key493;
-              xfer += iprot->readString(_key493);
-              std::string& _val494 = (*(this->success))[_key493];
-              xfer += iprot->readString(_val494);
+              std::string _key499;
+              xfer += iprot->readString(_key499);
+              std::string& _val500 = (*(this->success))[_key499];
+              xfer += iprot->readString(_val500);
             }
             xfer += iprot->readMapEnd();
           }
@@ -12320,14 +12320,14 @@ uint32_t AccumuloProxy_getTabletServers_result::read(::apache::thrift::protocol:
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->success.clear();
-            uint32_t _size495;
-            ::apache::thrift::protocol::TType _etype498;
-            xfer += iprot->readListBegin(_etype498, _size495);
-            this->success.resize(_size495);
-            uint32_t _i499;
-            for (_i499 = 0; _i499 < _size495; ++_i499)
+            uint32_t _size501;
+            ::apache::thrift::protocol::TType _etype504;
+            xfer += iprot->readListBegin(_etype504, _size501);
+            this->success.resize(_size501);
+            uint32_t _i505;
+            for (_i505 = 0; _i505 < _size501; ++_i505)
             {
-              xfer += iprot->readString(this->success[_i499]);
+              xfer += iprot->readString(this->success[_i505]);
             }
             xfer += iprot->readListEnd();
           }
@@ -12358,10 +12358,10 @@ uint32_t AccumuloProxy_getTabletServers_result::write(::apache::thrift::protocol
     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 _iter500;
-      for (_iter500 = this->success.begin(); _iter500 != this->success.end(); ++_iter500)
+      std::vector<std::string> ::const_iterator _iter506;
+      for (_iter506 = this->success.begin(); _iter506 != this->success.end(); ++_iter506)
       {
-        xfer += oprot->writeString((*_iter500));
+        xfer += oprot->writeString((*_iter506));
       }
       xfer += oprot->writeListEnd();
     }
@@ -12402,14 +12402,14 @@ uint32_t AccumuloProxy_getTabletServers_presult::read(::apache::thrift::protocol
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             (*(this->success)).clear();
-            uint32_t _size501;
-            ::apache::thrift::protocol::TType _etype504;
-            xfer += iprot->readListBegin(_etype504, _size501);
-            (*(this->success)).resize(_size501);
-            uint32_t _i505;
-            for (_i505 = 0; _i505 < _size501; ++_i505)
+            uint32_t _size507;
+            ::apache::thrift::protocol::TType _etype510;
+            xfer += iprot->readListBegin(_etype510, _size507);
+            (*(this->success)).resize(_size507);
+            uint32_t _i511;
+            for (_i511 = 0; _i511 < _size507; ++_i511)
             {
-              xfer += iprot->readString((*(this->success))[_i505]);
+              xfer += iprot->readString((*(this->success))[_i511]);
             }
             xfer += iprot->readListEnd();
           }
@@ -13197,17 +13197,17 @@ uint32_t AccumuloProxy_authenticateUser_args::read(::apache::thrift::protocol::T
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->properties.clear();
-            uint32_t _size506;
-            ::apache::thrift::protocol::TType _ktype507;
-            ::apache::thrift::protocol::TType _vtype508;
-            xfer += iprot->readMapBegin(_ktype507, _vtype508, _size506);
-            uint32_t _i510;
-            for (_i510 = 0; _i510 < _size506; ++_i510)
+            uint32_t _size512;
+            ::apache::thrift::protocol::TType _ktype513;
+            ::apache::thrift::protocol::TType _vtype514;
+            xfer += iprot->readMapBegin(_ktype513, _vtype514, _size512);
+            uint32_t _i516;
+            for (_i516 = 0; _i516 < _size512; ++_i516)
             {
-              std::string _key511;
-              xfer += iprot->readString(_key511);
-              std::string& _val512 = this->properties[_key511];
-              xfer += iprot->readString(_val512);
+              std::string _key517;
+              xfer += iprot->readString(_key517);
+              std::string& _val518 = this->properties[_key517];
+              xfer += iprot->readString(_val518);
             }
             xfer += iprot->readMapEnd();
           }
@@ -13244,11 +13244,11 @@ uint32_t AccumuloProxy_authenticateUser_args::write(::apache::thrift::protocol::
   xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 3);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size()));
-    std::map<std::string, std::string> ::const_iterator _iter513;
-    for (_iter513 = this->properties.begin(); _iter513 != this->properties.end(); ++_iter513)
+    std::map<std::string, std::string> ::const_iterator _iter519;
+    for (_iter519 = this->properties.begin(); _iter519 != this->properties.end(); ++_iter519)
     {
-      xfer += oprot->writeString(_iter513->first);
-      xfer += oprot->writeString(_iter513->second);
+      xfer += oprot->writeString(_iter519->first);
+      xfer += oprot->writeString(_iter519->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -13280,11 +13280,11 @@ uint32_t AccumuloProxy_authenticateUser_pargs::write(::apache::thrift::protocol:
   xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 3);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->properties)).size()));
-    std::map<std::string, std::string> ::const_iterator _iter514;
-    for (_iter514 = (*(this->properties)).begin(); _iter514 != (*(this->properties)).end(); ++_iter514)
+    std::map<std::string, std::string> ::const_iterator _iter520;
+    for (_iter520 = (*(this->properties)).begin(); _iter520 != (*(this->properties)).end(); ++_iter520)
     {
-      xfer += oprot->writeString(_iter514->first);
-      xfer += oprot->writeString(_iter514->second);
+      xfer += oprot->writeString(_iter520->first);
+      xfer += oprot->writeString(_iter520->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -13489,15 +13489,15 @@ uint32_t AccumuloProxy_changeUserAuthorizations_args::read(::apache::thrift::pro
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->authorizations.clear();
-            uint32_t _size515;
-            ::apache::thrift::protocol::TType _etype518;
-            xfer += iprot->readSetBegin(_etype518, _size515);
-            uint32_t _i519;
-            for (_i519 = 0; _i519 < _size515; ++_i519)
+            uint32_t _size521;
+            ::apache::thrift::protocol::TType _etype524;
+            xfer += iprot->readSetBegin(_etype524, _size521);
+            uint32_t _i525;
+            for (_i525 = 0; _i525 < _size521; ++_i525)
             {
-              std::string _elem520;
-              xfer += iprot->readBinary(_elem520);
-              this->authorizations.insert(_elem520);
+              std::string _elem526;
+              xfer += iprot->readBinary(_elem526);
+              this->authorizations.insert(_elem526);
             }
             xfer += iprot->readSetEnd();
           }
@@ -13534,10 +13534,10 @@ uint32_t AccumuloProxy_changeUserAuthorizations_args::write(::apache::thrift::pr
   xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 3);
   {
     xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size()));
-    std::set<std::string> ::const_iterator _iter521;
-    for (_iter521 = this->authorizations.begin(); _iter521 != this->authorizations.end(); ++_iter521)
+    std::set<std::string> ::const_iterator _iter527;
+    for (_iter527 = this->authorizations.begin(); _iter527 != this->authorizations.end(); ++_iter527)
     {
-      xfer += oprot->writeBinary((*_iter521));
+      xfer += oprot->writeBinary((*_iter527));
     }
     xfer += oprot-

<TRUNCATED>

Mime
View raw message