Return-Path: X-Original-To: apmail-accumulo-commits-archive@www.apache.org Delivered-To: apmail-accumulo-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id E062319E40 for ; Mon, 4 Apr 2016 18:30:32 +0000 (UTC) Received: (qmail 70469 invoked by uid 500); 4 Apr 2016 18:30:32 -0000 Delivered-To: apmail-accumulo-commits-archive@accumulo.apache.org Received: (qmail 70374 invoked by uid 500); 4 Apr 2016 18:30:32 -0000 Mailing-List: contact commits-help@accumulo.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@accumulo.apache.org Delivered-To: mailing list commits@accumulo.apache.org Received: (qmail 70132 invoked by uid 99); 4 Apr 2016 18:30:32 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 04 Apr 2016 18:30:32 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 42D90DFBED; Mon, 4 Apr 2016 18:30:32 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: kturner@apache.org To: commits@accumulo.apache.org Date: Mon, 04 Apr 2016 18:30:38 -0000 Message-Id: <61660d37618b49638cc2fd1873eaadf6@git.apache.org> In-Reply-To: <679361e6f7cb48ba911f2927c45ea188@git.apache.org> References: <679361e6f7cb48ba911f2927c45ea188@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [8/9] accumulo git commit: ACCUMULO-4147 Add Accumulo Namespace Operations to Proxy 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(this->loginProperties.size())); - std::map ::const_iterator _iter196; - for (_iter196 = this->loginProperties.begin(); _iter196 != this->loginProperties.end(); ++_iter196) + std::map ::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((*(this->loginProperties)).size())); - std::map ::const_iterator _iter197; - for (_iter197 = (*(this->loginProperties)).begin(); _iter197 != (*(this->loginProperties)).end(); ++_iter197) + std::map ::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(this->splits.size())); - std::set ::const_iterator _iter204; - for (_iter204 = this->splits.begin(); _iter204 != this->splits.end(); ++_iter204) + std::set ::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((*(this->splits)).size())); - std::set ::const_iterator _iter205; - for (_iter205 = (*(this->splits)).begin(); _iter205 != (*(this->splits)).end(); ++_iter205) + std::set ::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(this->scopes.size())); - std::set ::const_iterator _iter213; - for (_iter213 = this->scopes.begin(); _iter213 != this->scopes.end(); ++_iter213) + std::set ::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((*(this->scopes)).size())); - std::set ::const_iterator _iter214; - for (_iter214 = (*(this->scopes)).begin(); _iter214 != (*(this->scopes)).end(); ++_iter214) + std::set ::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(this->scopes.size())); - std::set ::const_iterator _iter222; - for (_iter222 = this->scopes.begin(); _iter222 != this->scopes.end(); ++_iter222) + std::set ::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((*(this->scopes)).size())); - std::set ::const_iterator _iter223; - for (_iter223 = (*(this->scopes)).begin(); _iter223 != (*(this->scopes)).end(); ++_iter223) + std::set ::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(this->propertiesToSet.size())); - std::map ::const_iterator _iter237; - for (_iter237 = this->propertiesToSet.begin(); _iter237 != this->propertiesToSet.end(); ++_iter237) + std::map ::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(this->propertiesToExclude.size())); - std::set ::const_iterator _iter238; - for (_iter238 = this->propertiesToExclude.begin(); _iter238 != this->propertiesToExclude.end(); ++_iter238) + std::set ::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((*(this->propertiesToSet)).size())); - std::map ::const_iterator _iter239; - for (_iter239 = (*(this->propertiesToSet)).begin(); _iter239 != (*(this->propertiesToSet)).end(); ++_iter239) + std::map ::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((*(this->propertiesToExclude)).size())); - std::set ::const_iterator _iter240; - for (_iter240 = (*(this->propertiesToExclude)).begin(); _iter240 != (*(this->propertiesToExclude)).end(); ++_iter240) + std::set ::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(this->iterators.size())); - std::vector ::const_iterator _iter246; - for (_iter246 = this->iterators.begin(); _iter246 != this->iterators.end(); ++_iter246) + std::vector ::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((*(this->iterators)).size())); - std::vector ::const_iterator _iter247; - for (_iter247 = (*(this->iterators)).begin(); _iter247 != (*(this->iterators)).end(); ++_iter247) + std::vector ::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(this->tables.size())); - std::set ::const_iterator _iter255; - for (_iter255 = this->tables.begin(); _iter255 != this->tables.end(); ++_iter255) + std::set ::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((*(this->tables)).size())); - std::set ::const_iterator _iter256; - for (_iter256 = (*(this->tables)).begin(); _iter256 != (*(this->tables)).end(); ++_iter256) + std::set ::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(this->success.size())); - std::vector ::const_iterator _iter262; - for (_iter262 = this->success.begin(); _iter262 != this->success.end(); ++_iter262) + std::vector ::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 & _val274 = this->success[_key273]; + std::string _key279; + xfer += iprot->readString(_key279); + std::set & _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(this->success.size())); - std::map > ::const_iterator _iter281; - for (_iter281 = this->success.begin(); _iter281 != this->success.end(); ++_iter281) + std::map > ::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(_iter281->second.size())); - std::set ::const_iterator _iter282; - for (_iter282 = _iter281->second.begin(); _iter282 != _iter281->second.end(); ++_iter282) + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter287->second.size())); + std::set ::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 & _val289 = (*(this->success))[_key288]; + std::string _key294; + xfer += iprot->readString(_key294); + std::set & _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(this->auths.size())); - std::set ::const_iterator _iter303; - for (_iter303 = this->auths.begin(); _iter303 != this->auths.end(); ++_iter303) + std::set ::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((*(this->auths)).size())); - std::set ::const_iterator _iter304; - for (_iter304 = (*(this->auths)).begin(); _iter304 != (*(this->auths)).end(); ++_iter304) + std::set ::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(this->success.size())); - std::map ::const_iterator _iter312; - for (_iter312 = this->success.begin(); _iter312 != this->success.end(); ++_iter312) + std::map ::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(this->success.size())); - std::vector ::const_iterator _iter325; - for (_iter325 = this->success.begin(); _iter325 != this->success.end(); ++_iter325) + std::vector ::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(this->success.size())); - std::set ::const_iterator _iter337; - for (_iter337 = this->success.begin(); _iter337 != this->success.end(); ++_iter337) + std::set ::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 & _val350 = this->success[_key349]; + std::string _key355; + xfer += iprot->readString(_key355); + std::set & _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(this->success.size())); - std::map > ::const_iterator _iter358; - for (_iter358 = this->success.begin(); _iter358 != this->success.end(); ++_iter358) + std::map > ::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(_iter358->second.size())); - std::set ::const_iterator _iter359; - for (_iter359 = _iter358->second.begin(); _iter359 != _iter358->second.end(); ++_iter359) + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I32, static_cast(_iter364->second.size())); + std::set ::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 & _val366 = (*(this->success))[_key365]; + std::string _key371; + xfer += iprot->readString(_key371); + std::set & _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(this->success.size())); - std::map ::const_iterator _iter381; - for (_iter381 = this->success.begin(); _iter381 != this->success.end(); ++_iter381) + std::map ::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(this->scopes.size())); - std::set ::const_iterator _iter396; - for (_iter396 = this->scopes.begin(); _iter396 != this->scopes.end(); ++_iter396) + std::set ::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((*(this->scopes)).size())); - std::set ::const_iterator _iter397; - for (_iter397 = (*(this->scopes)).begin(); _iter397 != (*(this->scopes)).end(); ++_iter397) + std::set ::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 & _val404 = this->groups[_key403]; + std::string _key409; + xfer += iprot->readString(_key409); + std::set & _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(this->groups.size())); - std::map > ::const_iterator _iter411; - for (_iter411 = this->groups.begin(); _iter411 != this->groups.end(); ++_iter411) + std::map > ::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(_iter411->second.size())); - std::set ::const_iterator _iter412; - for (_iter412 = _iter411->second.begin(); _iter412 != _iter411->second.end(); ++_iter412) + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter417->second.size())); + std::set ::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((*(this->groups)).size())); - std::map > ::const_iterator _iter413; - for (_iter413 = (*(this->groups)).begin(); _iter413 != (*(this->groups)).end(); ++_iter413) + std::map > ::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(_iter413->second.size())); - std::set ::const_iterator _iter414; - for (_iter414 = _iter413->second.begin(); _iter414 != _iter413->second.end(); ++_iter414) + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(_iter419->second.size())); + std::set ::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(this->success.size())); - std::set ::const_iterator _iter421; - for (_iter421 = this->success.begin(); _iter421 != this->success.end(); ++_iter421) + std::set ::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(this->success.size())); - std::map ::const_iterator _iter435; - for (_iter435 = this->success.begin(); _iter435 != this->success.end(); ++_iter435) + std::map ::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(this->success.size())); - std::vector ::const_iterator _iter448; - for (_iter448 = this->success.begin(); _iter448 != this->success.end(); ++_iter448) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter459; - for (_iter459 = this->success.begin(); _iter459 != this->success.end(); ++_iter459) + std::vector ::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(this->success.size())); - std::map ::const_iterator _iter472; - for (_iter472 = this->success.begin(); _iter472 != this->success.end(); ++_iter472) + std::map ::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(this->success.size())); - std::map ::const_iterator _iter487; - for (_iter487 = this->success.begin(); _iter487 != this->success.end(); ++_iter487) + std::map ::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(this->success.size())); - std::vector ::const_iterator _iter500; - for (_iter500 = this->success.begin(); _iter500 != this->success.end(); ++_iter500) + std::vector ::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(this->properties.size())); - std::map ::const_iterator _iter513; - for (_iter513 = this->properties.begin(); _iter513 != this->properties.end(); ++_iter513) + std::map ::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((*(this->properties)).size())); - std::map ::const_iterator _iter514; - for (_iter514 = (*(this->properties)).begin(); _iter514 != (*(this->properties)).end(); ++_iter514) + std::map ::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(this->authorizations.size())); - std::set ::const_iterator _iter521; - for (_iter521 = this->authorizations.begin(); _iter521 != this->authorizations.end(); ++_iter521) + std::set ::const_iterator _iter527; + for (_iter527 = this->authorizations.begin(); _iter527 != this->authorizations.end(); ++_iter527) { - xfer += oprot->writeBinary((*_iter521)); + xfer += oprot->writeBinary((*_iter527)); } xfer += oprot-