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 8F4A610641 for ; Tue, 4 Feb 2014 22:58:53 +0000 (UTC) Received: (qmail 46629 invoked by uid 500); 4 Feb 2014 22:58:40 -0000 Delivered-To: apmail-accumulo-commits-archive@accumulo.apache.org Received: (qmail 46351 invoked by uid 500); 4 Feb 2014 22:58:29 -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 45777 invoked by uid 99); 4 Feb 2014 22:58:17 -0000 Received: from tyr.zones.apache.org (HELO tyr.zones.apache.org) (140.211.11.114) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 04 Feb 2014 22:58:17 +0000 Received: by tyr.zones.apache.org (Postfix, from userid 65534) id D67C8824E4A; Tue, 4 Feb 2014 22:58:16 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: elserj@apache.org To: commits@accumulo.apache.org Date: Tue, 04 Feb 2014 22:58:26 -0000 Message-Id: <1242c9e0638f48f6b504c875b5729e6a@git.apache.org> In-Reply-To: <11c7d6aaa8464efd9a88aef14e4ce0c3@git.apache.org> References: <11c7d6aaa8464efd9a88aef14e4ce0c3@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [11/29] ACCUMULO-2197 provide generated proxy libraries, with modified generate-thrift script which tacks on headers http://git-wip-us.apache.org/repos/asf/accumulo/blob/3d436e7b/proxy/src/main/cpp/AccumuloProxy.h ---------------------------------------------------------------------- diff --git a/proxy/src/main/cpp/AccumuloProxy.h b/proxy/src/main/cpp/AccumuloProxy.h new file mode 100644 index 0000000..d747d3a --- /dev/null +++ b/proxy/src/main/cpp/AccumuloProxy.h @@ -0,0 +1,11664 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * Autogenerated by Thrift Compiler (0.9.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef AccumuloProxy_H +#define AccumuloProxy_H + +#include +#include "proxy_types.h" + +namespace accumulo { + +class AccumuloProxyIf { + public: + virtual ~AccumuloProxyIf() {} + virtual void login(std::string& _return, const std::string& principal, const std::map & loginProperties) = 0; + virtual int32_t addConstraint(const std::string& login, const std::string& tableName, const std::string& constraintClassName) = 0; + virtual void addSplits(const std::string& login, const std::string& tableName, const std::set & splits) = 0; + virtual void attachIterator(const std::string& login, const std::string& tableName, const IteratorSetting& setting, const std::set & scopes) = 0; + virtual void checkIteratorConflicts(const std::string& login, const std::string& tableName, const IteratorSetting& setting, const std::set & scopes) = 0; + virtual void clearLocatorCache(const std::string& login, const std::string& tableName) = 0; + virtual void cloneTable(const std::string& login, const std::string& tableName, const std::string& newTableName, const bool flush, const std::map & propertiesToSet, const std::set & propertiesToExclude) = 0; + virtual void compactTable(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow, const std::vector & iterators, const bool flush, const bool wait) = 0; + virtual void cancelCompaction(const std::string& login, const std::string& tableName) = 0; + virtual void createTable(const std::string& login, const std::string& tableName, const bool versioningIter, const TimeType::type type) = 0; + virtual void deleteTable(const std::string& login, const std::string& tableName) = 0; + virtual void deleteRows(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow) = 0; + virtual void exportTable(const std::string& login, const std::string& tableName, const std::string& exportDir) = 0; + virtual void flushTable(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow, const bool wait) = 0; + virtual void getLocalityGroups(std::map > & _return, const std::string& login, const std::string& tableName) = 0; + virtual void getIteratorSetting(IteratorSetting& _return, const std::string& login, const std::string& tableName, const std::string& iteratorName, const IteratorScope::type scope) = 0; + virtual void getMaxRow(std::string& _return, const std::string& login, const std::string& tableName, const std::set & auths, const std::string& startRow, const bool startInclusive, const std::string& endRow, const bool endInclusive) = 0; + virtual void getTableProperties(std::map & _return, const std::string& login, const std::string& tableName) = 0; + virtual void importDirectory(const std::string& login, const std::string& tableName, const std::string& importDir, const std::string& failureDir, const bool setTime) = 0; + virtual void importTable(const std::string& login, const std::string& tableName, const std::string& importDir) = 0; + virtual void listSplits(std::vector & _return, const std::string& login, const std::string& tableName, const int32_t maxSplits) = 0; + virtual void listTables(std::set & _return, const std::string& login) = 0; + virtual void listIterators(std::map > & _return, const std::string& login, const std::string& tableName) = 0; + virtual void listConstraints(std::map & _return, const std::string& login, const std::string& tableName) = 0; + virtual void mergeTablets(const std::string& login, const std::string& tableName, const std::string& startRow, const std::string& endRow) = 0; + virtual void offlineTable(const std::string& login, const std::string& tableName) = 0; + virtual void onlineTable(const std::string& login, const std::string& tableName) = 0; + virtual void removeConstraint(const std::string& login, const std::string& tableName, const int32_t constraint) = 0; + virtual void removeIterator(const std::string& login, const std::string& tableName, const std::string& iterName, const std::set & scopes) = 0; + virtual void removeTableProperty(const std::string& login, const std::string& tableName, const std::string& property) = 0; + virtual void renameTable(const std::string& login, const std::string& oldTableName, const std::string& newTableName) = 0; + virtual void setLocalityGroups(const std::string& login, const std::string& tableName, const std::map > & groups) = 0; + virtual void setTableProperty(const std::string& login, const std::string& tableName, const std::string& property, const std::string& value) = 0; + virtual void splitRangeByTablets(std::set & _return, const std::string& login, const std::string& tableName, const Range& range, const int32_t maxSplits) = 0; + virtual bool tableExists(const std::string& login, const std::string& tableName) = 0; + virtual void tableIdMap(std::map & _return, const std::string& login) = 0; + virtual bool testTableClassLoad(const std::string& login, const std::string& tableName, const std::string& className, const std::string& asTypeName) = 0; + virtual void pingTabletServer(const std::string& login, const std::string& tserver) = 0; + virtual void getActiveScans(std::vector & _return, const std::string& login, const std::string& tserver) = 0; + virtual void getActiveCompactions(std::vector & _return, const std::string& login, const std::string& tserver) = 0; + virtual void getSiteConfiguration(std::map & _return, const std::string& login) = 0; + virtual void getSystemConfiguration(std::map & _return, const std::string& login) = 0; + virtual void getTabletServers(std::vector & _return, const std::string& login) = 0; + virtual void removeProperty(const std::string& login, const std::string& property) = 0; + virtual void setProperty(const std::string& login, const std::string& property, const std::string& value) = 0; + virtual bool testClassLoad(const std::string& login, const std::string& className, const std::string& asTypeName) = 0; + virtual bool authenticateUser(const std::string& login, const std::string& user, const std::map & properties) = 0; + virtual void changeUserAuthorizations(const std::string& login, const std::string& user, const std::set & authorizations) = 0; + virtual void changeLocalUserPassword(const std::string& login, const std::string& user, const std::string& password) = 0; + virtual void createLocalUser(const std::string& login, const std::string& user, const std::string& password) = 0; + virtual void dropLocalUser(const std::string& login, const std::string& user) = 0; + virtual void getUserAuthorizations(std::vector & _return, const std::string& login, const std::string& user) = 0; + virtual void grantSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm) = 0; + virtual void grantTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm) = 0; + virtual bool hasSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm) = 0; + virtual bool hasTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm) = 0; + virtual void listLocalUsers(std::set & _return, const std::string& login) = 0; + virtual void revokeSystemPermission(const std::string& login, const std::string& user, const SystemPermission::type perm) = 0; + virtual void revokeTablePermission(const std::string& login, const std::string& user, const std::string& table, const TablePermission::type perm) = 0; + virtual void createBatchScanner(std::string& _return, const std::string& login, const std::string& tableName, const BatchScanOptions& options) = 0; + virtual void createScanner(std::string& _return, const std::string& login, const std::string& tableName, const ScanOptions& options) = 0; + virtual bool hasNext(const std::string& scanner) = 0; + virtual void nextEntry(KeyValueAndPeek& _return, const std::string& scanner) = 0; + virtual void nextK(ScanResult& _return, const std::string& scanner, const int32_t k) = 0; + virtual void closeScanner(const std::string& scanner) = 0; + virtual void updateAndFlush(const std::string& login, const std::string& tableName, const std::map > & cells) = 0; + virtual void createWriter(std::string& _return, const std::string& login, const std::string& tableName, const WriterOptions& opts) = 0; + virtual void update(const std::string& writer, const std::map > & cells) = 0; + virtual void flush(const std::string& writer) = 0; + virtual void closeWriter(const std::string& writer) = 0; + virtual void getRowRange(Range& _return, const std::string& row) = 0; + virtual void getFollowing(Key& _return, const Key& key, const PartialKey::type part) = 0; +}; + +class AccumuloProxyIfFactory { + public: + typedef AccumuloProxyIf Handler; + + virtual ~AccumuloProxyIfFactory() {} + + virtual AccumuloProxyIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(AccumuloProxyIf* /* handler */) = 0; +}; + +class AccumuloProxyIfSingletonFactory : virtual public AccumuloProxyIfFactory { + public: + AccumuloProxyIfSingletonFactory(const boost::shared_ptr& iface) : iface_(iface) {} + virtual ~AccumuloProxyIfSingletonFactory() {} + + virtual AccumuloProxyIf* getHandler(const ::apache::thrift::TConnectionInfo&) { + return iface_.get(); + } + virtual void releaseHandler(AccumuloProxyIf* /* handler */) {} + + protected: + boost::shared_ptr iface_; +}; + +class AccumuloProxyNull : virtual public AccumuloProxyIf { + public: + virtual ~AccumuloProxyNull() {} + void login(std::string& /* _return */, const std::string& /* principal */, const std::map & /* loginProperties */) { + return; + } + int32_t addConstraint(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* constraintClassName */) { + int32_t _return = 0; + return _return; + } + void addSplits(const std::string& /* login */, const std::string& /* tableName */, const std::set & /* splits */) { + return; + } + void attachIterator(const std::string& /* login */, const std::string& /* tableName */, const IteratorSetting& /* setting */, const std::set & /* scopes */) { + return; + } + void checkIteratorConflicts(const std::string& /* login */, const std::string& /* tableName */, const IteratorSetting& /* setting */, const std::set & /* scopes */) { + return; + } + void clearLocatorCache(const std::string& /* login */, const std::string& /* tableName */) { + return; + } + void cloneTable(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* newTableName */, const bool /* flush */, const std::map & /* propertiesToSet */, const std::set & /* propertiesToExclude */) { + return; + } + void compactTable(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* startRow */, const std::string& /* endRow */, const std::vector & /* iterators */, const bool /* flush */, const bool /* wait */) { + return; + } + void cancelCompaction(const std::string& /* login */, const std::string& /* tableName */) { + return; + } + void createTable(const std::string& /* login */, const std::string& /* tableName */, const bool /* versioningIter */, const TimeType::type /* type */) { + return; + } + void deleteTable(const std::string& /* login */, const std::string& /* tableName */) { + return; + } + void deleteRows(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* startRow */, const std::string& /* endRow */) { + return; + } + void exportTable(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* exportDir */) { + return; + } + void flushTable(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* startRow */, const std::string& /* endRow */, const bool /* wait */) { + return; + } + void getLocalityGroups(std::map > & /* _return */, const std::string& /* login */, const std::string& /* tableName */) { + return; + } + void getIteratorSetting(IteratorSetting& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const std::string& /* iteratorName */, const IteratorScope::type /* scope */) { + return; + } + void getMaxRow(std::string& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const std::set & /* auths */, const std::string& /* startRow */, const bool /* startInclusive */, const std::string& /* endRow */, const bool /* endInclusive */) { + return; + } + void getTableProperties(std::map & /* _return */, const std::string& /* login */, const std::string& /* tableName */) { + return; + } + void importDirectory(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* importDir */, const std::string& /* failureDir */, const bool /* setTime */) { + return; + } + void importTable(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* importDir */) { + return; + } + void listSplits(std::vector & /* _return */, const std::string& /* login */, const std::string& /* tableName */, const int32_t /* maxSplits */) { + return; + } + void listTables(std::set & /* _return */, const std::string& /* login */) { + return; + } + void listIterators(std::map > & /* _return */, const std::string& /* login */, const std::string& /* tableName */) { + return; + } + void listConstraints(std::map & /* _return */, const std::string& /* login */, const std::string& /* tableName */) { + return; + } + void mergeTablets(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* startRow */, const std::string& /* endRow */) { + return; + } + void offlineTable(const std::string& /* login */, const std::string& /* tableName */) { + return; + } + void onlineTable(const std::string& /* login */, const std::string& /* tableName */) { + return; + } + void removeConstraint(const std::string& /* login */, const std::string& /* tableName */, const int32_t /* constraint */) { + return; + } + void removeIterator(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* iterName */, const std::set & /* scopes */) { + return; + } + void removeTableProperty(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* property */) { + return; + } + void renameTable(const std::string& /* login */, const std::string& /* oldTableName */, const std::string& /* newTableName */) { + return; + } + void setLocalityGroups(const std::string& /* login */, const std::string& /* tableName */, const std::map > & /* groups */) { + return; + } + void setTableProperty(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* property */, const std::string& /* value */) { + return; + } + void splitRangeByTablets(std::set & /* _return */, const std::string& /* login */, const std::string& /* tableName */, const Range& /* range */, const int32_t /* maxSplits */) { + return; + } + bool tableExists(const std::string& /* login */, const std::string& /* tableName */) { + bool _return = false; + return _return; + } + void tableIdMap(std::map & /* _return */, const std::string& /* login */) { + return; + } + bool testTableClassLoad(const std::string& /* login */, const std::string& /* tableName */, const std::string& /* className */, const std::string& /* asTypeName */) { + bool _return = false; + return _return; + } + void pingTabletServer(const std::string& /* login */, const std::string& /* tserver */) { + return; + } + void getActiveScans(std::vector & /* _return */, const std::string& /* login */, const std::string& /* tserver */) { + return; + } + void getActiveCompactions(std::vector & /* _return */, const std::string& /* login */, const std::string& /* tserver */) { + return; + } + void getSiteConfiguration(std::map & /* _return */, const std::string& /* login */) { + return; + } + void getSystemConfiguration(std::map & /* _return */, const std::string& /* login */) { + return; + } + void getTabletServers(std::vector & /* _return */, const std::string& /* login */) { + return; + } + void removeProperty(const std::string& /* login */, const std::string& /* property */) { + return; + } + void setProperty(const std::string& /* login */, const std::string& /* property */, const std::string& /* value */) { + return; + } + bool testClassLoad(const std::string& /* login */, const std::string& /* className */, const std::string& /* asTypeName */) { + bool _return = false; + return _return; + } + bool authenticateUser(const std::string& /* login */, const std::string& /* user */, const std::map & /* properties */) { + bool _return = false; + return _return; + } + void changeUserAuthorizations(const std::string& /* login */, const std::string& /* user */, const std::set & /* authorizations */) { + return; + } + void changeLocalUserPassword(const std::string& /* login */, const std::string& /* user */, const std::string& /* password */) { + return; + } + void createLocalUser(const std::string& /* login */, const std::string& /* user */, const std::string& /* password */) { + return; + } + void dropLocalUser(const std::string& /* login */, const std::string& /* user */) { + return; + } + void getUserAuthorizations(std::vector & /* _return */, const std::string& /* login */, const std::string& /* user */) { + return; + } + void grantSystemPermission(const std::string& /* login */, const std::string& /* user */, const SystemPermission::type /* perm */) { + return; + } + void grantTablePermission(const std::string& /* login */, const std::string& /* user */, const std::string& /* table */, const TablePermission::type /* perm */) { + return; + } + bool hasSystemPermission(const std::string& /* login */, const std::string& /* user */, const SystemPermission::type /* perm */) { + bool _return = false; + return _return; + } + bool hasTablePermission(const std::string& /* login */, const std::string& /* user */, const std::string& /* table */, const TablePermission::type /* perm */) { + bool _return = false; + return _return; + } + void listLocalUsers(std::set & /* _return */, const std::string& /* login */) { + return; + } + void revokeSystemPermission(const std::string& /* login */, const std::string& /* user */, const SystemPermission::type /* perm */) { + return; + } + void revokeTablePermission(const std::string& /* login */, const std::string& /* user */, const std::string& /* table */, const TablePermission::type /* perm */) { + return; + } + void createBatchScanner(std::string& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const BatchScanOptions& /* options */) { + return; + } + void createScanner(std::string& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const ScanOptions& /* options */) { + return; + } + bool hasNext(const std::string& /* scanner */) { + bool _return = false; + return _return; + } + void nextEntry(KeyValueAndPeek& /* _return */, const std::string& /* scanner */) { + return; + } + void nextK(ScanResult& /* _return */, const std::string& /* scanner */, const int32_t /* k */) { + return; + } + void closeScanner(const std::string& /* scanner */) { + return; + } + void updateAndFlush(const std::string& /* login */, const std::string& /* tableName */, const std::map > & /* cells */) { + return; + } + void createWriter(std::string& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const WriterOptions& /* opts */) { + return; + } + void update(const std::string& /* writer */, const std::map > & /* cells */) { + return; + } + void flush(const std::string& /* writer */) { + return; + } + void closeWriter(const std::string& /* writer */) { + return; + } + void getRowRange(Range& /* _return */, const std::string& /* row */) { + return; + } + void getFollowing(Key& /* _return */, const Key& /* key */, const PartialKey::type /* part */) { + return; + } +}; + +typedef struct _AccumuloProxy_login_args__isset { + _AccumuloProxy_login_args__isset() : principal(false), loginProperties(false) {} + bool principal; + bool loginProperties; +} _AccumuloProxy_login_args__isset; + +class AccumuloProxy_login_args { + public: + + AccumuloProxy_login_args() : principal() { + } + + virtual ~AccumuloProxy_login_args() throw() {} + + std::string principal; + std::map loginProperties; + + _AccumuloProxy_login_args__isset __isset; + + void __set_principal(const std::string& val) { + principal = val; + } + + void __set_loginProperties(const std::map & val) { + loginProperties = val; + } + + bool operator == (const AccumuloProxy_login_args & rhs) const + { + if (!(principal == rhs.principal)) + return false; + if (!(loginProperties == rhs.loginProperties)) + return false; + return true; + } + bool operator != (const AccumuloProxy_login_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_login_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_login_pargs { + public: + + + virtual ~AccumuloProxy_login_pargs() throw() {} + + const std::string* principal; + const std::map * loginProperties; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_login_result__isset { + _AccumuloProxy_login_result__isset() : success(false), ouch2(false) {} + bool success; + bool ouch2; +} _AccumuloProxy_login_result__isset; + +class AccumuloProxy_login_result { + public: + + AccumuloProxy_login_result() : success() { + } + + virtual ~AccumuloProxy_login_result() throw() {} + + std::string success; + AccumuloSecurityException ouch2; + + _AccumuloProxy_login_result__isset __isset; + + void __set_success(const std::string& val) { + success = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + bool operator == (const AccumuloProxy_login_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + return true; + } + bool operator != (const AccumuloProxy_login_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_login_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_login_presult__isset { + _AccumuloProxy_login_presult__isset() : success(false), ouch2(false) {} + bool success; + bool ouch2; +} _AccumuloProxy_login_presult__isset; + +class AccumuloProxy_login_presult { + public: + + + virtual ~AccumuloProxy_login_presult() throw() {} + + std::string* success; + AccumuloSecurityException ouch2; + + _AccumuloProxy_login_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_addConstraint_args__isset { + _AccumuloProxy_addConstraint_args__isset() : login(false), tableName(false), constraintClassName(false) {} + bool login; + bool tableName; + bool constraintClassName; +} _AccumuloProxy_addConstraint_args__isset; + +class AccumuloProxy_addConstraint_args { + public: + + AccumuloProxy_addConstraint_args() : login(), tableName(), constraintClassName() { + } + + virtual ~AccumuloProxy_addConstraint_args() throw() {} + + std::string login; + std::string tableName; + std::string constraintClassName; + + _AccumuloProxy_addConstraint_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_constraintClassName(const std::string& val) { + constraintClassName = val; + } + + bool operator == (const AccumuloProxy_addConstraint_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(constraintClassName == rhs.constraintClassName)) + return false; + return true; + } + bool operator != (const AccumuloProxy_addConstraint_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_addConstraint_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_addConstraint_pargs { + public: + + + virtual ~AccumuloProxy_addConstraint_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const std::string* constraintClassName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_addConstraint_result__isset { + _AccumuloProxy_addConstraint_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success; + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_addConstraint_result__isset; + +class AccumuloProxy_addConstraint_result { + public: + + AccumuloProxy_addConstraint_result() : success(0) { + } + + virtual ~AccumuloProxy_addConstraint_result() throw() {} + + int32_t success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_addConstraint_result__isset __isset; + + void __set_success(const int32_t val) { + success = val; + } + + void __set_ouch1(const AccumuloException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_addConstraint_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_addConstraint_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_addConstraint_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_addConstraint_presult__isset { + _AccumuloProxy_addConstraint_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success; + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_addConstraint_presult__isset; + +class AccumuloProxy_addConstraint_presult { + public: + + + virtual ~AccumuloProxy_addConstraint_presult() throw() {} + + int32_t* success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_addConstraint_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_addSplits_args__isset { + _AccumuloProxy_addSplits_args__isset() : login(false), tableName(false), splits(false) {} + bool login; + bool tableName; + bool splits; +} _AccumuloProxy_addSplits_args__isset; + +class AccumuloProxy_addSplits_args { + public: + + AccumuloProxy_addSplits_args() : login(), tableName() { + } + + virtual ~AccumuloProxy_addSplits_args() throw() {} + + std::string login; + std::string tableName; + std::set splits; + + _AccumuloProxy_addSplits_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_splits(const std::set & val) { + splits = val; + } + + bool operator == (const AccumuloProxy_addSplits_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(splits == rhs.splits)) + return false; + return true; + } + bool operator != (const AccumuloProxy_addSplits_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_addSplits_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_addSplits_pargs { + public: + + + virtual ~AccumuloProxy_addSplits_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const std::set * splits; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_addSplits_result__isset { + _AccumuloProxy_addSplits_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_addSplits_result__isset; + +class AccumuloProxy_addSplits_result { + public: + + AccumuloProxy_addSplits_result() { + } + + virtual ~AccumuloProxy_addSplits_result() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_addSplits_result__isset __isset; + + void __set_ouch1(const AccumuloException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_addSplits_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_addSplits_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_addSplits_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_addSplits_presult__isset { + _AccumuloProxy_addSplits_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_addSplits_presult__isset; + +class AccumuloProxy_addSplits_presult { + public: + + + virtual ~AccumuloProxy_addSplits_presult() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_addSplits_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_attachIterator_args__isset { + _AccumuloProxy_attachIterator_args__isset() : login(false), tableName(false), setting(false), scopes(false) {} + bool login; + bool tableName; + bool setting; + bool scopes; +} _AccumuloProxy_attachIterator_args__isset; + +class AccumuloProxy_attachIterator_args { + public: + + AccumuloProxy_attachIterator_args() : login(), tableName() { + } + + virtual ~AccumuloProxy_attachIterator_args() throw() {} + + std::string login; + std::string tableName; + IteratorSetting setting; + std::set scopes; + + _AccumuloProxy_attachIterator_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_setting(const IteratorSetting& val) { + setting = val; + } + + void __set_scopes(const std::set & val) { + scopes = val; + } + + bool operator == (const AccumuloProxy_attachIterator_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(setting == rhs.setting)) + return false; + if (!(scopes == rhs.scopes)) + return false; + return true; + } + bool operator != (const AccumuloProxy_attachIterator_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_attachIterator_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_attachIterator_pargs { + public: + + + virtual ~AccumuloProxy_attachIterator_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const IteratorSetting* setting; + const std::set * scopes; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_attachIterator_result__isset { + _AccumuloProxy_attachIterator_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_attachIterator_result__isset; + +class AccumuloProxy_attachIterator_result { + public: + + AccumuloProxy_attachIterator_result() { + } + + virtual ~AccumuloProxy_attachIterator_result() throw() {} + + AccumuloSecurityException ouch1; + AccumuloException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_attachIterator_result__isset __isset; + + void __set_ouch1(const AccumuloSecurityException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_attachIterator_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_attachIterator_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_attachIterator_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_attachIterator_presult__isset { + _AccumuloProxy_attachIterator_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_attachIterator_presult__isset; + +class AccumuloProxy_attachIterator_presult { + public: + + + virtual ~AccumuloProxy_attachIterator_presult() throw() {} + + AccumuloSecurityException ouch1; + AccumuloException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_attachIterator_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_checkIteratorConflicts_args__isset { + _AccumuloProxy_checkIteratorConflicts_args__isset() : login(false), tableName(false), setting(false), scopes(false) {} + bool login; + bool tableName; + bool setting; + bool scopes; +} _AccumuloProxy_checkIteratorConflicts_args__isset; + +class AccumuloProxy_checkIteratorConflicts_args { + public: + + AccumuloProxy_checkIteratorConflicts_args() : login(), tableName() { + } + + virtual ~AccumuloProxy_checkIteratorConflicts_args() throw() {} + + std::string login; + std::string tableName; + IteratorSetting setting; + std::set scopes; + + _AccumuloProxy_checkIteratorConflicts_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_setting(const IteratorSetting& val) { + setting = val; + } + + void __set_scopes(const std::set & val) { + scopes = val; + } + + bool operator == (const AccumuloProxy_checkIteratorConflicts_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(setting == rhs.setting)) + return false; + if (!(scopes == rhs.scopes)) + return false; + return true; + } + bool operator != (const AccumuloProxy_checkIteratorConflicts_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_checkIteratorConflicts_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_checkIteratorConflicts_pargs { + public: + + + virtual ~AccumuloProxy_checkIteratorConflicts_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const IteratorSetting* setting; + const std::set * scopes; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_checkIteratorConflicts_result__isset { + _AccumuloProxy_checkIteratorConflicts_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_checkIteratorConflicts_result__isset; + +class AccumuloProxy_checkIteratorConflicts_result { + public: + + AccumuloProxy_checkIteratorConflicts_result() { + } + + virtual ~AccumuloProxy_checkIteratorConflicts_result() throw() {} + + AccumuloSecurityException ouch1; + AccumuloException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_checkIteratorConflicts_result__isset __isset; + + void __set_ouch1(const AccumuloSecurityException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_checkIteratorConflicts_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_checkIteratorConflicts_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_checkIteratorConflicts_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_checkIteratorConflicts_presult__isset { + _AccumuloProxy_checkIteratorConflicts_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_checkIteratorConflicts_presult__isset; + +class AccumuloProxy_checkIteratorConflicts_presult { + public: + + + virtual ~AccumuloProxy_checkIteratorConflicts_presult() throw() {} + + AccumuloSecurityException ouch1; + AccumuloException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_checkIteratorConflicts_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_clearLocatorCache_args__isset { + _AccumuloProxy_clearLocatorCache_args__isset() : login(false), tableName(false) {} + bool login; + bool tableName; +} _AccumuloProxy_clearLocatorCache_args__isset; + +class AccumuloProxy_clearLocatorCache_args { + public: + + AccumuloProxy_clearLocatorCache_args() : login(), tableName() { + } + + virtual ~AccumuloProxy_clearLocatorCache_args() throw() {} + + std::string login; + std::string tableName; + + _AccumuloProxy_clearLocatorCache_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + bool operator == (const AccumuloProxy_clearLocatorCache_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + return true; + } + bool operator != (const AccumuloProxy_clearLocatorCache_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_clearLocatorCache_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_clearLocatorCache_pargs { + public: + + + virtual ~AccumuloProxy_clearLocatorCache_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_clearLocatorCache_result__isset { + _AccumuloProxy_clearLocatorCache_result__isset() : ouch1(false) {} + bool ouch1; +} _AccumuloProxy_clearLocatorCache_result__isset; + +class AccumuloProxy_clearLocatorCache_result { + public: + + AccumuloProxy_clearLocatorCache_result() { + } + + virtual ~AccumuloProxy_clearLocatorCache_result() throw() {} + + TableNotFoundException ouch1; + + _AccumuloProxy_clearLocatorCache_result__isset __isset; + + void __set_ouch1(const TableNotFoundException& val) { + ouch1 = val; + } + + bool operator == (const AccumuloProxy_clearLocatorCache_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + return true; + } + bool operator != (const AccumuloProxy_clearLocatorCache_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_clearLocatorCache_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_clearLocatorCache_presult__isset { + _AccumuloProxy_clearLocatorCache_presult__isset() : ouch1(false) {} + bool ouch1; +} _AccumuloProxy_clearLocatorCache_presult__isset; + +class AccumuloProxy_clearLocatorCache_presult { + public: + + + virtual ~AccumuloProxy_clearLocatorCache_presult() throw() {} + + TableNotFoundException ouch1; + + _AccumuloProxy_clearLocatorCache_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_cloneTable_args__isset { + _AccumuloProxy_cloneTable_args__isset() : login(false), tableName(false), newTableName(false), flush(false), propertiesToSet(false), propertiesToExclude(false) {} + bool login; + bool tableName; + bool newTableName; + bool flush; + bool propertiesToSet; + bool propertiesToExclude; +} _AccumuloProxy_cloneTable_args__isset; + +class AccumuloProxy_cloneTable_args { + public: + + AccumuloProxy_cloneTable_args() : login(), tableName(), newTableName(), flush(0) { + } + + virtual ~AccumuloProxy_cloneTable_args() throw() {} + + std::string login; + std::string tableName; + std::string newTableName; + bool flush; + std::map propertiesToSet; + std::set propertiesToExclude; + + _AccumuloProxy_cloneTable_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_newTableName(const std::string& val) { + newTableName = val; + } + + void __set_flush(const bool val) { + flush = val; + } + + void __set_propertiesToSet(const std::map & val) { + propertiesToSet = val; + } + + void __set_propertiesToExclude(const std::set & val) { + propertiesToExclude = val; + } + + bool operator == (const AccumuloProxy_cloneTable_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(newTableName == rhs.newTableName)) + return false; + if (!(flush == rhs.flush)) + return false; + if (!(propertiesToSet == rhs.propertiesToSet)) + return false; + if (!(propertiesToExclude == rhs.propertiesToExclude)) + return false; + return true; + } + bool operator != (const AccumuloProxy_cloneTable_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_cloneTable_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_cloneTable_pargs { + public: + + + virtual ~AccumuloProxy_cloneTable_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const std::string* newTableName; + const bool* flush; + const std::map * propertiesToSet; + const std::set * propertiesToExclude; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_cloneTable_result__isset { + _AccumuloProxy_cloneTable_result__isset() : ouch1(false), ouch2(false), ouch3(false), ouch4(false) {} + bool ouch1; + bool ouch2; + bool ouch3; + bool ouch4; +} _AccumuloProxy_cloneTable_result__isset; + +class AccumuloProxy_cloneTable_result { + public: + + AccumuloProxy_cloneTable_result() { + } + + virtual ~AccumuloProxy_cloneTable_result() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + TableExistsException ouch4; + + _AccumuloProxy_cloneTable_result__isset __isset; + + void __set_ouch1(const AccumuloException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + void __set_ouch4(const TableExistsException& val) { + ouch4 = val; + } + + bool operator == (const AccumuloProxy_cloneTable_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + if (!(ouch4 == rhs.ouch4)) + return false; + return true; + } + bool operator != (const AccumuloProxy_cloneTable_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_cloneTable_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_cloneTable_presult__isset { + _AccumuloProxy_cloneTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false), ouch4(false) {} + bool ouch1; + bool ouch2; + bool ouch3; + bool ouch4; +} _AccumuloProxy_cloneTable_presult__isset; + +class AccumuloProxy_cloneTable_presult { + public: + + + virtual ~AccumuloProxy_cloneTable_presult() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + TableExistsException ouch4; + + _AccumuloProxy_cloneTable_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_compactTable_args__isset { + _AccumuloProxy_compactTable_args__isset() : login(false), tableName(false), startRow(false), endRow(false), iterators(false), flush(false), wait(false) {} + bool login; + bool tableName; + bool startRow; + bool endRow; + bool iterators; + bool flush; + bool wait; +} _AccumuloProxy_compactTable_args__isset; + +class AccumuloProxy_compactTable_args { + public: + + AccumuloProxy_compactTable_args() : login(), tableName(), startRow(), endRow(), flush(0), wait(0) { + } + + virtual ~AccumuloProxy_compactTable_args() throw() {} + + std::string login; + std::string tableName; + std::string startRow; + std::string endRow; + std::vector iterators; + bool flush; + bool wait; + + _AccumuloProxy_compactTable_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_startRow(const std::string& val) { + startRow = val; + } + + void __set_endRow(const std::string& val) { + endRow = val; + } + + void __set_iterators(const std::vector & val) { + iterators = val; + } + + void __set_flush(const bool val) { + flush = val; + } + + void __set_wait(const bool val) { + wait = val; + } + + bool operator == (const AccumuloProxy_compactTable_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(startRow == rhs.startRow)) + return false; + if (!(endRow == rhs.endRow)) + return false; + if (!(iterators == rhs.iterators)) + return false; + if (!(flush == rhs.flush)) + return false; + if (!(wait == rhs.wait)) + return false; + return true; + } + bool operator != (const AccumuloProxy_compactTable_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_compactTable_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_compactTable_pargs { + public: + + + virtual ~AccumuloProxy_compactTable_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const std::string* startRow; + const std::string* endRow; + const std::vector * iterators; + const bool* flush; + const bool* wait; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_compactTable_result__isset { + _AccumuloProxy_compactTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_compactTable_result__isset; + +class AccumuloProxy_compactTable_result { + public: + + AccumuloProxy_compactTable_result() { + } + + virtual ~AccumuloProxy_compactTable_result() throw() {} + + AccumuloSecurityException ouch1; + TableNotFoundException ouch2; + AccumuloException ouch3; + + _AccumuloProxy_compactTable_result__isset __isset; + + void __set_ouch1(const AccumuloSecurityException& val) { + ouch1 = val; + } + + void __set_ouch2(const TableNotFoundException& val) { + ouch2 = val; + } + + void __set_ouch3(const AccumuloException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_compactTable_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_compactTable_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_compactTable_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_compactTable_presult__isset { + _AccumuloProxy_compactTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_compactTable_presult__isset; + +class AccumuloProxy_compactTable_presult { + public: + + + virtual ~AccumuloProxy_compactTable_presult() throw() {} + + AccumuloSecurityException ouch1; + TableNotFoundException ouch2; + AccumuloException ouch3; + + _AccumuloProxy_compactTable_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_cancelCompaction_args__isset { + _AccumuloProxy_cancelCompaction_args__isset() : login(false), tableName(false) {} + bool login; + bool tableName; +} _AccumuloProxy_cancelCompaction_args__isset; + +class AccumuloProxy_cancelCompaction_args { + public: + + AccumuloProxy_cancelCompaction_args() : login(), tableName() { + } + + virtual ~AccumuloProxy_cancelCompaction_args() throw() {} + + std::string login; + std::string tableName; + + _AccumuloProxy_cancelCompaction_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + bool operator == (const AccumuloProxy_cancelCompaction_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + return true; + } + bool operator != (const AccumuloProxy_cancelCompaction_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_cancelCompaction_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_cancelCompaction_pargs { + public: + + + virtual ~AccumuloProxy_cancelCompaction_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_cancelCompaction_result__isset { + _AccumuloProxy_cancelCompaction_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_cancelCompaction_result__isset; + +class AccumuloProxy_cancelCompaction_result { + public: + + AccumuloProxy_cancelCompaction_result() { + } + + virtual ~AccumuloProxy_cancelCompaction_result() throw() {} + + AccumuloSecurityException ouch1; + TableNotFoundException ouch2; + AccumuloException ouch3; + + _AccumuloProxy_cancelCompaction_result__isset __isset; + + void __set_ouch1(const AccumuloSecurityException& val) { + ouch1 = val; + } + + void __set_ouch2(const TableNotFoundException& val) { + ouch2 = val; + } + + void __set_ouch3(const AccumuloException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_cancelCompaction_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_cancelCompaction_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_cancelCompaction_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_cancelCompaction_presult__isset { + _AccumuloProxy_cancelCompaction_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_cancelCompaction_presult__isset; + +class AccumuloProxy_cancelCompaction_presult { + public: + + + virtual ~AccumuloProxy_cancelCompaction_presult() throw() {} + + AccumuloSecurityException ouch1; + TableNotFoundException ouch2; + AccumuloException ouch3; + + _AccumuloProxy_cancelCompaction_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_createTable_args__isset { + _AccumuloProxy_createTable_args__isset() : login(false), tableName(false), versioningIter(false), type(false) {} + bool login; + bool tableName; + bool versioningIter; + bool type; +} _AccumuloProxy_createTable_args__isset; + +class AccumuloProxy_createTable_args { + public: + + AccumuloProxy_createTable_args() : login(), tableName(), versioningIter(0), type((TimeType::type)0) { + } + + virtual ~AccumuloProxy_createTable_args() throw() {} + + std::string login; + std::string tableName; + bool versioningIter; + TimeType::type type; + + _AccumuloProxy_createTable_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_versioningIter(const bool val) { + versioningIter = val; + } + + void __set_type(const TimeType::type val) { + type = val; + } + + bool operator == (const AccumuloProxy_createTable_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(versioningIter == rhs.versioningIter)) + return false; + if (!(type == rhs.type)) + return false; + return true; + } + bool operator != (const AccumuloProxy_createTable_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_createTable_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_createTable_pargs { + public: + + + virtual ~AccumuloProxy_createTable_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const bool* versioningIter; + const TimeType::type* type; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_createTable_result__isset { + _AccumuloProxy_createTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_createTable_result__isset; + +class AccumuloProxy_createTable_result { + public: + + AccumuloProxy_createTable_result() { + } + + virtual ~AccumuloProxy_createTable_result() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableExistsException ouch3; + + _AccumuloProxy_createTable_result__isset __isset; + + void __set_ouch1(const AccumuloException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableExistsException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_createTable_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_createTable_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_createTable_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_createTable_presult__isset { + _AccumuloProxy_createTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_createTable_presult__isset; + +class AccumuloProxy_createTable_presult { + public: + + + virtual ~AccumuloProxy_createTable_presult() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableExistsException ouch3; + + _AccumuloProxy_createTable_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_deleteTable_args__isset { + _AccumuloProxy_deleteTable_args__isset() : login(false), tableName(false) {} + bool login; + bool tableName; +} _AccumuloProxy_deleteTable_args__isset; + +class AccumuloProxy_deleteTable_args { + public: + + AccumuloProxy_deleteTable_args() : login(), tableName() { + } + + virtual ~AccumuloProxy_deleteTable_args() throw() {} + + std::string login; + std::string tableName; + + _AccumuloProxy_deleteTable_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + bool operator == (const AccumuloProxy_deleteTable_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + return true; + } + bool operator != (const AccumuloProxy_deleteTable_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_deleteTable_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_deleteTable_pargs { + public: + + + virtual ~AccumuloProxy_deleteTable_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_deleteTable_result__isset { + _AccumuloProxy_deleteTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_deleteTable_result__isset; + +class AccumuloProxy_deleteTable_result { + public: + + AccumuloProxy_deleteTable_result() { + } + + virtual ~AccumuloProxy_deleteTable_result() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_deleteTable_result__isset __isset; + + void __set_ouch1(const AccumuloException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_deleteTable_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_deleteTable_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_deleteTable_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_deleteTable_presult__isset { + _AccumuloProxy_deleteTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_deleteTable_presult__isset; + +class AccumuloProxy_deleteTable_presult { + public: + + + virtual ~AccumuloProxy_deleteTable_presult() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_deleteTable_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_deleteRows_args__isset { + _AccumuloProxy_deleteRows_args__isset() : login(false), tableName(false), startRow(false), endRow(false) {} + bool login; + bool tableName; + bool startRow; + bool endRow; +} _AccumuloProxy_deleteRows_args__isset; + +class AccumuloProxy_deleteRows_args { + public: + + AccumuloProxy_deleteRows_args() : login(), tableName(), startRow(), endRow() { + } + + virtual ~AccumuloProxy_deleteRows_args() throw() {} + + std::string login; + std::string tableName; + std::string startRow; + std::string endRow; + + _AccumuloProxy_deleteRows_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_startRow(const std::string& val) { + startRow = val; + } + + void __set_endRow(const std::string& val) { + endRow = val; + } + + bool operator == (const AccumuloProxy_deleteRows_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(startRow == rhs.startRow)) + return false; + if (!(endRow == rhs.endRow)) + return false; + return true; + } + bool operator != (const AccumuloProxy_deleteRows_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_deleteRows_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_deleteRows_pargs { + public: + + + virtual ~AccumuloProxy_deleteRows_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const std::string* startRow; + const std::string* endRow; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_deleteRows_result__isset { + _AccumuloProxy_deleteRows_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_deleteRows_result__isset; + +class AccumuloProxy_deleteRows_result { + public: + + AccumuloProxy_deleteRows_result() { + } + + virtual ~AccumuloProxy_deleteRows_result() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_deleteRows_result__isset __isset; + + void __set_ouch1(const AccumuloException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_deleteRows_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_deleteRows_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_deleteRows_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_deleteRows_presult__isset { + _AccumuloProxy_deleteRows_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_deleteRows_presult__isset; + +class AccumuloProxy_deleteRows_presult { + public: + + + virtual ~AccumuloProxy_deleteRows_presult() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_deleteRows_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_exportTable_args__isset { + _AccumuloProxy_exportTable_args__isset() : login(false), tableName(false), exportDir(false) {} + bool login; + bool tableName; + bool exportDir; +} _AccumuloProxy_exportTable_args__isset; + +class AccumuloProxy_exportTable_args { + public: + + AccumuloProxy_exportTable_args() : login(), tableName(), exportDir() { + } + + virtual ~AccumuloProxy_exportTable_args() throw() {} + + std::string login; + std::string tableName; + std::string exportDir; + + _AccumuloProxy_exportTable_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_exportDir(const std::string& val) { + exportDir = val; + } + + bool operator == (const AccumuloProxy_exportTable_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(exportDir == rhs.exportDir)) + return false; + return true; + } + bool operator != (const AccumuloProxy_exportTable_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_exportTable_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_exportTable_pargs { + public: + + + virtual ~AccumuloProxy_exportTable_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const std::string* exportDir; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_exportTable_result__isset { + _AccumuloProxy_exportTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_exportTable_result__isset; + +class AccumuloProxy_exportTable_result { + public: + + AccumuloProxy_exportTable_result() { + } + + virtual ~AccumuloProxy_exportTable_result() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_exportTable_result__isset __isset; + + void __set_ouch1(const AccumuloException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_exportTable_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_exportTable_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_exportTable_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_exportTable_presult__isset { + _AccumuloProxy_exportTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_exportTable_presult__isset; + +class AccumuloProxy_exportTable_presult { + public: + + + virtual ~AccumuloProxy_exportTable_presult() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_exportTable_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_flushTable_args__isset { + _AccumuloProxy_flushTable_args__isset() : login(false), tableName(false), startRow(false), endRow(false), wait(false) {} + bool login; + bool tableName; + bool startRow; + bool endRow; + bool wait; +} _AccumuloProxy_flushTable_args__isset; + +class AccumuloProxy_flushTable_args { + public: + + AccumuloProxy_flushTable_args() : login(), tableName(), startRow(), endRow(), wait(0) { + } + + virtual ~AccumuloProxy_flushTable_args() throw() {} + + std::string login; + std::string tableName; + std::string startRow; + std::string endRow; + bool wait; + + _AccumuloProxy_flushTable_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_startRow(const std::string& val) { + startRow = val; + } + + void __set_endRow(const std::string& val) { + endRow = val; + } + + void __set_wait(const bool val) { + wait = val; + } + + bool operator == (const AccumuloProxy_flushTable_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(startRow == rhs.startRow)) + return false; + if (!(endRow == rhs.endRow)) + return false; + if (!(wait == rhs.wait)) + return false; + return true; + } + bool operator != (const AccumuloProxy_flushTable_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_flushTable_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_flushTable_pargs { + public: + + + virtual ~AccumuloProxy_flushTable_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const std::string* startRow; + const std::string* endRow; + const bool* wait; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_flushTable_result__isset { + _AccumuloProxy_flushTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_flushTable_result__isset; + +class AccumuloProxy_flushTable_result { + public: + + AccumuloProxy_flushTable_result() { + } + + virtual ~AccumuloProxy_flushTable_result() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_flushTable_result__isset __isset; + + void __set_ouch1(const AccumuloException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_flushTable_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_flushTable_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_flushTable_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_flushTable_presult__isset { + _AccumuloProxy_flushTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {} + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_flushTable_presult__isset; + +class AccumuloProxy_flushTable_presult { + public: + + + virtual ~AccumuloProxy_flushTable_presult() throw() {} + + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_flushTable_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_getLocalityGroups_args__isset { + _AccumuloProxy_getLocalityGroups_args__isset() : login(false), tableName(false) {} + bool login; + bool tableName; +} _AccumuloProxy_getLocalityGroups_args__isset; + +class AccumuloProxy_getLocalityGroups_args { + public: + + AccumuloProxy_getLocalityGroups_args() : login(), tableName() { + } + + virtual ~AccumuloProxy_getLocalityGroups_args() throw() {} + + std::string login; + std::string tableName; + + _AccumuloProxy_getLocalityGroups_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + bool operator == (const AccumuloProxy_getLocalityGroups_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + return true; + } + bool operator != (const AccumuloProxy_getLocalityGroups_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_getLocalityGroups_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_getLocalityGroups_pargs { + public: + + + virtual ~AccumuloProxy_getLocalityGroups_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_getLocalityGroups_result__isset { + _AccumuloProxy_getLocalityGroups_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success; + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_getLocalityGroups_result__isset; + +class AccumuloProxy_getLocalityGroups_result { + public: + + AccumuloProxy_getLocalityGroups_result() { + } + + virtual ~AccumuloProxy_getLocalityGroups_result() throw() {} + + std::map > success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_getLocalityGroups_result__isset __isset; + + void __set_success(const std::map > & val) { + success = val; + } + + void __set_ouch1(const AccumuloException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_getLocalityGroups_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_getLocalityGroups_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_getLocalityGroups_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_getLocalityGroups_presult__isset { + _AccumuloProxy_getLocalityGroups_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success; + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_getLocalityGroups_presult__isset; + +class AccumuloProxy_getLocalityGroups_presult { + public: + + + virtual ~AccumuloProxy_getLocalityGroups_presult() throw() {} + + std::map > * success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_getLocalityGroups_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_getIteratorSetting_args__isset { + _AccumuloProxy_getIteratorSetting_args__isset() : login(false), tableName(false), iteratorName(false), scope(false) {} + bool login; + bool tableName; + bool iteratorName; + bool scope; +} _AccumuloProxy_getIteratorSetting_args__isset; + +class AccumuloProxy_getIteratorSetting_args { + public: + + AccumuloProxy_getIteratorSetting_args() : login(), tableName(), iteratorName(), scope((IteratorScope::type)0) { + } + + virtual ~AccumuloProxy_getIteratorSetting_args() throw() {} + + std::string login; + std::string tableName; + std::string iteratorName; + IteratorScope::type scope; + + _AccumuloProxy_getIteratorSetting_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_iteratorName(const std::string& val) { + iteratorName = val; + } + + void __set_scope(const IteratorScope::type val) { + scope = val; + } + + bool operator == (const AccumuloProxy_getIteratorSetting_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(iteratorName == rhs.iteratorName)) + return false; + if (!(scope == rhs.scope)) + return false; + return true; + } + bool operator != (const AccumuloProxy_getIteratorSetting_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_getIteratorSetting_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_getIteratorSetting_pargs { + public: + + + virtual ~AccumuloProxy_getIteratorSetting_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const std::string* iteratorName; + const IteratorScope::type* scope; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_getIteratorSetting_result__isset { + _AccumuloProxy_getIteratorSetting_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success; + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_getIteratorSetting_result__isset; + +class AccumuloProxy_getIteratorSetting_result { + public: + + AccumuloProxy_getIteratorSetting_result() { + } + + virtual ~AccumuloProxy_getIteratorSetting_result() throw() {} + + IteratorSetting success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_getIteratorSetting_result__isset __isset; + + void __set_success(const IteratorSetting& val) { + success = val; + } + + void __set_ouch1(const AccumuloException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_getIteratorSetting_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_getIteratorSetting_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_getIteratorSetting_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_getIteratorSetting_presult__isset { + _AccumuloProxy_getIteratorSetting_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success; + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_getIteratorSetting_presult__isset; + +class AccumuloProxy_getIteratorSetting_presult { + public: + + + virtual ~AccumuloProxy_getIteratorSetting_presult() throw() {} + + IteratorSetting* success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_getIteratorSetting_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_getMaxRow_args__isset { + _AccumuloProxy_getMaxRow_args__isset() : login(false), tableName(false), auths(false), startRow(false), startInclusive(false), endRow(false), endInclusive(false) {} + bool login; + bool tableName; + bool auths; + bool startRow; + bool startInclusive; + bool endRow; + bool endInclusive; +} _AccumuloProxy_getMaxRow_args__isset; + +class AccumuloProxy_getMaxRow_args { + public: + + AccumuloProxy_getMaxRow_args() : login(), tableName(), startRow(), startInclusive(0), endRow(), endInclusive(0) { + } + + virtual ~AccumuloProxy_getMaxRow_args() throw() {} + + std::string login; + std::string tableName; + std::set auths; + std::string startRow; + bool startInclusive; + std::string endRow; + bool endInclusive; + + _AccumuloProxy_getMaxRow_args__isset __isset; + + void __set_login(const std::string& val) { + login = val; + } + + void __set_tableName(const std::string& val) { + tableName = val; + } + + void __set_auths(const std::set & val) { + auths = val; + } + + void __set_startRow(const std::string& val) { + startRow = val; + } + + void __set_startInclusive(const bool val) { + startInclusive = val; + } + + void __set_endRow(const std::string& val) { + endRow = val; + } + + void __set_endInclusive(const bool val) { + endInclusive = val; + } + + bool operator == (const AccumuloProxy_getMaxRow_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(auths == rhs.auths)) + return false; + if (!(startRow == rhs.startRow)) + return false; + if (!(startInclusive == rhs.startInclusive)) + return false; + if (!(endRow == rhs.endRow)) + return false; + if (!(endInclusive == rhs.endInclusive)) + return false; + return true; + } + bool operator != (const AccumuloProxy_getMaxRow_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_getMaxRow_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_getMaxRow_pargs { + public: + + + virtual ~AccumuloProxy_getMaxRow_pargs() throw() {} + + const std::string* login; + const std::string* tableName; + const std::set * auths; + const std::string* startRow; + const bool* startInclusive; + const std::string* endRow; + const bool* endInclusive; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_getMaxRow_result__isset { + _AccumuloProxy_getMaxRow_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success; + bool ouch1; + bool ouch2; + bool ouch3; +} _AccumuloProxy_getMaxRow_result__isset; + +class AccumuloProxy_getMaxRow_result { + public: + + AccumuloProxy_getMaxRow_result() : success() { + } + + virtual ~AccumuloProxy_getMaxRow_result() throw() {} + + std::string success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_getMaxRow_result__isset __isset; + + void __set_success(const std::string& val) { + success = val; + } + + void __set_ouch1(const AccumuloException& val) { + ouch1 = val; + } + + void __set_ouch2(const AccumuloSecurityException& val) { + ouch2 = val; + } + + void __set_ouch3(const TableNotFoundException& val) { + ouch3 = val; + } + + bool operator == (const AccumuloProxy_getMaxRow_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_getMaxRow_result &rhs) const { + return !(*this == rhs); + } + + bool operator