http://git-wip-us.apache.org/repos/asf/accumulo/blob/8839fe51/proxy/src/main/cpp/AccumuloProxy.h ---------------------------------------------------------------------- diff --git a/proxy/src/main/cpp/AccumuloProxy.h b/proxy/src/main/cpp/AccumuloProxy.h index a14fda9..429cf55 100644 --- a/proxy/src/main/cpp/AccumuloProxy.h +++ b/proxy/src/main/cpp/AccumuloProxy.h @@ -97,6 +97,9 @@ class AccumuloProxyIf { virtual void listLocalUsers(std::set<std::string> & _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 grantNamespacePermission(const std::string& login, const std::string& user, const std::string& namespaceName, const NamespacePermission::type perm) = 0; + virtual bool hasNamespacePermission(const std::string& login, const std::string& user, const std::string& namespaceName, const NamespacePermission::type perm) = 0; + virtual void revokeNamespacePermission(const std::string& login, const std::string& user, const std::string& namespaceName, const NamespacePermission::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; @@ -114,6 +117,26 @@ class AccumuloProxyIf { virtual void closeConditionalWriter(const std::string& conditionalWriter) = 0; virtual void getRowRange(Range& _return, const std::string& row) = 0; virtual void getFollowing(Key& _return, const Key& key, const PartialKey::type part) = 0; + virtual void systemNamespace(std::string& _return) = 0; + virtual void defaultNamespace(std::string& _return) = 0; + virtual void listNamespaces(std::vector<std::string> & _return, const std::string& login) = 0; + virtual bool namespaceExists(const std::string& login, const std::string& namespaceName) = 0; + virtual void createNamespace(const std::string& login, const std::string& namespaceName) = 0; + virtual void deleteNamespace(const std::string& login, const std::string& namespaceName) = 0; + virtual void renameNamespace(const std::string& login, const std::string& oldNamespaceName, const std::string& newNamespaceName) = 0; + virtual void setNamespaceProperty(const std::string& login, const std::string& namespaceName, const std::string& property, const std::string& value) = 0; + virtual void removeNamespaceProperty(const std::string& login, const std::string& namespaceName, const std::string& property) = 0; + virtual void getNamespaceProperties(std::map<std::string, std::string> & _return, const std::string& login, const std::string& namespaceName) = 0; + virtual void namespaceIdMap(std::map<std::string, std::string> & _return, const std::string& login) = 0; + virtual void attachNamespaceIterator(const std::string& login, const std::string& namespaceName, const IteratorSetting& setting, const std::set<IteratorScope::type> & scopes) = 0; + virtual void removeNamespaceIterator(const std::string& login, const std::string& namespaceName, const std::string& name, const std::set<IteratorScope::type> & scopes) = 0; + virtual void getNamespaceIteratorSetting(IteratorSetting& _return, const std::string& login, const std::string& namespaceName, const std::string& name, const IteratorScope::type scope) = 0; + virtual void listNamespaceIterators(std::map<std::string, std::set<IteratorScope::type> > & _return, const std::string& login, const std::string& namespaceName) = 0; + virtual void checkNamespaceIteratorConflicts(const std::string& login, const std::string& namespaceName, const IteratorSetting& setting, const std::set<IteratorScope::type> & scopes) = 0; + virtual int32_t addNamespaceConstraint(const std::string& login, const std::string& namespaceName, const std::string& constraintClassName) = 0; + virtual void removeNamespaceConstraint(const std::string& login, const std::string& namespaceName, const int32_t id) = 0; + virtual void listNamespaceConstraints(std::map<std::string, int32_t> & _return, const std::string& login, const std::string& namespaceName) = 0; + virtual bool testNamespaceClassLoad(const std::string& login, const std::string& namespaceName, const std::string& className, const std::string& asTypeName) = 0; }; class AccumuloProxyIfFactory { @@ -330,6 +353,16 @@ class AccumuloProxyNull : virtual public AccumuloProxyIf { void revokeTablePermission(const std::string& /* login */, const std::string& /* user */, const std::string& /* table */, const TablePermission::type /* perm */) { return; } + void grantNamespacePermission(const std::string& /* login */, const std::string& /* user */, const std::string& /* namespaceName */, const NamespacePermission::type /* perm */) { + return; + } + bool hasNamespacePermission(const std::string& /* login */, const std::string& /* user */, const std::string& /* namespaceName */, const NamespacePermission::type /* perm */) { + bool _return = false; + return _return; + } + void revokeNamespacePermission(const std::string& /* login */, const std::string& /* user */, const std::string& /* namespaceName */, const NamespacePermission::type /* perm */) { + return; + } void createBatchScanner(std::string& /* _return */, const std::string& /* login */, const std::string& /* tableName */, const BatchScanOptions& /* options */) { return; } @@ -383,6 +416,69 @@ class AccumuloProxyNull : virtual public AccumuloProxyIf { void getFollowing(Key& /* _return */, const Key& /* key */, const PartialKey::type /* part */) { return; } + void systemNamespace(std::string& /* _return */) { + return; + } + void defaultNamespace(std::string& /* _return */) { + return; + } + void listNamespaces(std::vector<std::string> & /* _return */, const std::string& /* login */) { + return; + } + bool namespaceExists(const std::string& /* login */, const std::string& /* namespaceName */) { + bool _return = false; + return _return; + } + void createNamespace(const std::string& /* login */, const std::string& /* namespaceName */) { + return; + } + void deleteNamespace(const std::string& /* login */, const std::string& /* namespaceName */) { + return; + } + void renameNamespace(const std::string& /* login */, const std::string& /* oldNamespaceName */, const std::string& /* newNamespaceName */) { + return; + } + void setNamespaceProperty(const std::string& /* login */, const std::string& /* namespaceName */, const std::string& /* property */, const std::string& /* value */) { + return; + } + void removeNamespaceProperty(const std::string& /* login */, const std::string& /* namespaceName */, const std::string& /* property */) { + return; + } + void getNamespaceProperties(std::map<std::string, std::string> & /* _return */, const std::string& /* login */, const std::string& /* namespaceName */) { + return; + } + void namespaceIdMap(std::map<std::string, std::string> & /* _return */, const std::string& /* login */) { + return; + } + void attachNamespaceIterator(const std::string& /* login */, const std::string& /* namespaceName */, const IteratorSetting& /* setting */, const std::set<IteratorScope::type> & /* scopes */) { + return; + } + void removeNamespaceIterator(const std::string& /* login */, const std::string& /* namespaceName */, const std::string& /* name */, const std::set<IteratorScope::type> & /* scopes */) { + return; + } + void getNamespaceIteratorSetting(IteratorSetting& /* _return */, const std::string& /* login */, const std::string& /* namespaceName */, const std::string& /* name */, const IteratorScope::type /* scope */) { + return; + } + void listNamespaceIterators(std::map<std::string, std::set<IteratorScope::type> > & /* _return */, const std::string& /* login */, const std::string& /* namespaceName */) { + return; + } + void checkNamespaceIteratorConflicts(const std::string& /* login */, const std::string& /* namespaceName */, const IteratorSetting& /* setting */, const std::set<IteratorScope::type> & /* scopes */) { + return; + } + int32_t addNamespaceConstraint(const std::string& /* login */, const std::string& /* namespaceName */, const std::string& /* constraintClassName */) { + int32_t _return = 0; + return _return; + } + void removeNamespaceConstraint(const std::string& /* login */, const std::string& /* namespaceName */, const int32_t /* id */) { + return; + } + void listNamespaceConstraints(std::map<std::string, int32_t> & /* _return */, const std::string& /* login */, const std::string& /* namespaceName */) { + return; + } + bool testNamespaceClassLoad(const std::string& /* login */, const std::string& /* namespaceName */, const std::string& /* className */, const std::string& /* asTypeName */) { + bool _return = false; + return _return; + } }; typedef struct _AccumuloProxy_login_args__isset { @@ -8392,49 +8488,55 @@ class AccumuloProxy_revokeTablePermission_presult { }; -typedef struct _AccumuloProxy_createBatchScanner_args__isset { - _AccumuloProxy_createBatchScanner_args__isset() : login(false), tableName(false), options(false) {} +typedef struct _AccumuloProxy_grantNamespacePermission_args__isset { + _AccumuloProxy_grantNamespacePermission_args__isset() : login(false), user(false), namespaceName(false), perm(false) {} bool login :1; - bool tableName :1; - bool options :1; -} _AccumuloProxy_createBatchScanner_args__isset; + bool user :1; + bool namespaceName :1; + bool perm :1; +} _AccumuloProxy_grantNamespacePermission_args__isset; -class AccumuloProxy_createBatchScanner_args { +class AccumuloProxy_grantNamespacePermission_args { public: - AccumuloProxy_createBatchScanner_args(const AccumuloProxy_createBatchScanner_args&); - AccumuloProxy_createBatchScanner_args& operator=(const AccumuloProxy_createBatchScanner_args&); - AccumuloProxy_createBatchScanner_args() : login(), tableName() { + AccumuloProxy_grantNamespacePermission_args(const AccumuloProxy_grantNamespacePermission_args&); + AccumuloProxy_grantNamespacePermission_args& operator=(const AccumuloProxy_grantNamespacePermission_args&); + AccumuloProxy_grantNamespacePermission_args() : login(), user(), namespaceName(), perm((NamespacePermission::type)0) { } - virtual ~AccumuloProxy_createBatchScanner_args() throw(); + virtual ~AccumuloProxy_grantNamespacePermission_args() throw(); std::string login; - std::string tableName; - BatchScanOptions options; + std::string user; + std::string namespaceName; + NamespacePermission::type perm; - _AccumuloProxy_createBatchScanner_args__isset __isset; + _AccumuloProxy_grantNamespacePermission_args__isset __isset; void __set_login(const std::string& val); - void __set_tableName(const std::string& val); + void __set_user(const std::string& val); - void __set_options(const BatchScanOptions& val); + void __set_namespaceName(const std::string& val); - bool operator == (const AccumuloProxy_createBatchScanner_args & rhs) const + void __set_perm(const NamespacePermission::type val); + + bool operator == (const AccumuloProxy_grantNamespacePermission_args & rhs) const { if (!(login == rhs.login)) return false; - if (!(tableName == rhs.tableName)) + if (!(user == rhs.user)) return false; - if (!(options == rhs.options)) + if (!(namespaceName == rhs.namespaceName)) + return false; + if (!(perm == rhs.perm)) return false; return true; } - bool operator != (const AccumuloProxy_createBatchScanner_args &rhs) const { + bool operator != (const AccumuloProxy_grantNamespacePermission_args &rhs) const { return !(*this == rhs); } - bool operator < (const AccumuloProxy_createBatchScanner_args & ) const; + bool operator < (const AccumuloProxy_grantNamespacePermission_args & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; @@ -8442,141 +8544,132 @@ class AccumuloProxy_createBatchScanner_args { }; -class AccumuloProxy_createBatchScanner_pargs { +class AccumuloProxy_grantNamespacePermission_pargs { public: - virtual ~AccumuloProxy_createBatchScanner_pargs() throw(); + virtual ~AccumuloProxy_grantNamespacePermission_pargs() throw(); const std::string* login; - const std::string* tableName; - const BatchScanOptions* options; + const std::string* user; + const std::string* namespaceName; + const NamespacePermission::type* perm; uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -typedef struct _AccumuloProxy_createBatchScanner_result__isset { - _AccumuloProxy_createBatchScanner_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} - bool success :1; +typedef struct _AccumuloProxy_grantNamespacePermission_result__isset { + _AccumuloProxy_grantNamespacePermission_result__isset() : ouch1(false), ouch2(false) {} bool ouch1 :1; bool ouch2 :1; - bool ouch3 :1; -} _AccumuloProxy_createBatchScanner_result__isset; +} _AccumuloProxy_grantNamespacePermission_result__isset; -class AccumuloProxy_createBatchScanner_result { +class AccumuloProxy_grantNamespacePermission_result { public: - AccumuloProxy_createBatchScanner_result(const AccumuloProxy_createBatchScanner_result&); - AccumuloProxy_createBatchScanner_result& operator=(const AccumuloProxy_createBatchScanner_result&); - AccumuloProxy_createBatchScanner_result() : success() { + AccumuloProxy_grantNamespacePermission_result(const AccumuloProxy_grantNamespacePermission_result&); + AccumuloProxy_grantNamespacePermission_result& operator=(const AccumuloProxy_grantNamespacePermission_result&); + AccumuloProxy_grantNamespacePermission_result() { } - virtual ~AccumuloProxy_createBatchScanner_result() throw(); - std::string success; + virtual ~AccumuloProxy_grantNamespacePermission_result() throw(); AccumuloException ouch1; AccumuloSecurityException ouch2; - TableNotFoundException ouch3; - - _AccumuloProxy_createBatchScanner_result__isset __isset; - void __set_success(const std::string& val); + _AccumuloProxy_grantNamespacePermission_result__isset __isset; void __set_ouch1(const AccumuloException& val); void __set_ouch2(const AccumuloSecurityException& val); - void __set_ouch3(const TableNotFoundException& val); - - bool operator == (const AccumuloProxy_createBatchScanner_result & rhs) const + bool operator == (const AccumuloProxy_grantNamespacePermission_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_createBatchScanner_result &rhs) const { + bool operator != (const AccumuloProxy_grantNamespacePermission_result &rhs) const { return !(*this == rhs); } - bool operator < (const AccumuloProxy_createBatchScanner_result & ) const; + bool operator < (const AccumuloProxy_grantNamespacePermission_result & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -typedef struct _AccumuloProxy_createBatchScanner_presult__isset { - _AccumuloProxy_createBatchScanner_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} - bool success :1; +typedef struct _AccumuloProxy_grantNamespacePermission_presult__isset { + _AccumuloProxy_grantNamespacePermission_presult__isset() : ouch1(false), ouch2(false) {} bool ouch1 :1; bool ouch2 :1; - bool ouch3 :1; -} _AccumuloProxy_createBatchScanner_presult__isset; +} _AccumuloProxy_grantNamespacePermission_presult__isset; -class AccumuloProxy_createBatchScanner_presult { +class AccumuloProxy_grantNamespacePermission_presult { public: - virtual ~AccumuloProxy_createBatchScanner_presult() throw(); - std::string* success; + virtual ~AccumuloProxy_grantNamespacePermission_presult() throw(); AccumuloException ouch1; AccumuloSecurityException ouch2; - TableNotFoundException ouch3; - _AccumuloProxy_createBatchScanner_presult__isset __isset; + _AccumuloProxy_grantNamespacePermission_presult__isset __isset; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); }; -typedef struct _AccumuloProxy_createScanner_args__isset { - _AccumuloProxy_createScanner_args__isset() : login(false), tableName(false), options(false) {} +typedef struct _AccumuloProxy_hasNamespacePermission_args__isset { + _AccumuloProxy_hasNamespacePermission_args__isset() : login(false), user(false), namespaceName(false), perm(false) {} bool login :1; - bool tableName :1; - bool options :1; -} _AccumuloProxy_createScanner_args__isset; + bool user :1; + bool namespaceName :1; + bool perm :1; +} _AccumuloProxy_hasNamespacePermission_args__isset; -class AccumuloProxy_createScanner_args { +class AccumuloProxy_hasNamespacePermission_args { public: - AccumuloProxy_createScanner_args(const AccumuloProxy_createScanner_args&); - AccumuloProxy_createScanner_args& operator=(const AccumuloProxy_createScanner_args&); - AccumuloProxy_createScanner_args() : login(), tableName() { + AccumuloProxy_hasNamespacePermission_args(const AccumuloProxy_hasNamespacePermission_args&); + AccumuloProxy_hasNamespacePermission_args& operator=(const AccumuloProxy_hasNamespacePermission_args&); + AccumuloProxy_hasNamespacePermission_args() : login(), user(), namespaceName(), perm((NamespacePermission::type)0) { } - virtual ~AccumuloProxy_createScanner_args() throw(); + virtual ~AccumuloProxy_hasNamespacePermission_args() throw(); std::string login; - std::string tableName; - ScanOptions options; + std::string user; + std::string namespaceName; + NamespacePermission::type perm; - _AccumuloProxy_createScanner_args__isset __isset; + _AccumuloProxy_hasNamespacePermission_args__isset __isset; void __set_login(const std::string& val); - void __set_tableName(const std::string& val); + void __set_user(const std::string& val); - void __set_options(const ScanOptions& val); + void __set_namespaceName(const std::string& val); - bool operator == (const AccumuloProxy_createScanner_args & rhs) const + void __set_perm(const NamespacePermission::type val); + + bool operator == (const AccumuloProxy_hasNamespacePermission_args & rhs) const { if (!(login == rhs.login)) return false; - if (!(tableName == rhs.tableName)) + if (!(user == rhs.user)) return false; - if (!(options == rhs.options)) + if (!(namespaceName == rhs.namespaceName)) + return false; + if (!(perm == rhs.perm)) return false; return true; } - bool operator != (const AccumuloProxy_createScanner_args &rhs) const { + bool operator != (const AccumuloProxy_hasNamespacePermission_args &rhs) const { return !(*this == rhs); } - bool operator < (const AccumuloProxy_createScanner_args & ) const; + bool operator < (const AccumuloProxy_hasNamespacePermission_args & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; @@ -8584,52 +8677,49 @@ class AccumuloProxy_createScanner_args { }; -class AccumuloProxy_createScanner_pargs { +class AccumuloProxy_hasNamespacePermission_pargs { public: - virtual ~AccumuloProxy_createScanner_pargs() throw(); + virtual ~AccumuloProxy_hasNamespacePermission_pargs() throw(); const std::string* login; - const std::string* tableName; - const ScanOptions* options; + const std::string* user; + const std::string* namespaceName; + const NamespacePermission::type* perm; uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -typedef struct _AccumuloProxy_createScanner_result__isset { - _AccumuloProxy_createScanner_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} +typedef struct _AccumuloProxy_hasNamespacePermission_result__isset { + _AccumuloProxy_hasNamespacePermission_result__isset() : success(false), ouch1(false), ouch2(false) {} bool success :1; bool ouch1 :1; bool ouch2 :1; - bool ouch3 :1; -} _AccumuloProxy_createScanner_result__isset; +} _AccumuloProxy_hasNamespacePermission_result__isset; -class AccumuloProxy_createScanner_result { +class AccumuloProxy_hasNamespacePermission_result { public: - AccumuloProxy_createScanner_result(const AccumuloProxy_createScanner_result&); - AccumuloProxy_createScanner_result& operator=(const AccumuloProxy_createScanner_result&); - AccumuloProxy_createScanner_result() : success() { + AccumuloProxy_hasNamespacePermission_result(const AccumuloProxy_hasNamespacePermission_result&); + AccumuloProxy_hasNamespacePermission_result& operator=(const AccumuloProxy_hasNamespacePermission_result&); + AccumuloProxy_hasNamespacePermission_result() : success(0) { } - virtual ~AccumuloProxy_createScanner_result() throw(); - std::string success; + virtual ~AccumuloProxy_hasNamespacePermission_result() throw(); + bool success; AccumuloException ouch1; AccumuloSecurityException ouch2; - TableNotFoundException ouch3; - _AccumuloProxy_createScanner_result__isset __isset; + _AccumuloProxy_hasNamespacePermission_result__isset __isset; - void __set_success(const std::string& val); + void __set_success(const bool val); void __set_ouch1(const AccumuloException& val); void __set_ouch2(const AccumuloSecurityException& val); - void __set_ouch3(const TableNotFoundException& val); - - bool operator == (const AccumuloProxy_createScanner_result & rhs) const + bool operator == (const AccumuloProxy_hasNamespacePermission_result & rhs) const { if (!(success == rhs.success)) return false; @@ -8637,76 +8727,90 @@ class AccumuloProxy_createScanner_result { return false; if (!(ouch2 == rhs.ouch2)) return false; - if (!(ouch3 == rhs.ouch3)) - return false; return true; } - bool operator != (const AccumuloProxy_createScanner_result &rhs) const { + bool operator != (const AccumuloProxy_hasNamespacePermission_result &rhs) const { return !(*this == rhs); } - bool operator < (const AccumuloProxy_createScanner_result & ) const; + bool operator < (const AccumuloProxy_hasNamespacePermission_result & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -typedef struct _AccumuloProxy_createScanner_presult__isset { - _AccumuloProxy_createScanner_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} +typedef struct _AccumuloProxy_hasNamespacePermission_presult__isset { + _AccumuloProxy_hasNamespacePermission_presult__isset() : success(false), ouch1(false), ouch2(false) {} bool success :1; bool ouch1 :1; bool ouch2 :1; - bool ouch3 :1; -} _AccumuloProxy_createScanner_presult__isset; +} _AccumuloProxy_hasNamespacePermission_presult__isset; -class AccumuloProxy_createScanner_presult { +class AccumuloProxy_hasNamespacePermission_presult { public: - virtual ~AccumuloProxy_createScanner_presult() throw(); - std::string* success; + virtual ~AccumuloProxy_hasNamespacePermission_presult() throw(); + bool* success; AccumuloException ouch1; AccumuloSecurityException ouch2; - TableNotFoundException ouch3; - _AccumuloProxy_createScanner_presult__isset __isset; + _AccumuloProxy_hasNamespacePermission_presult__isset __isset; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); }; -typedef struct _AccumuloProxy_hasNext_args__isset { - _AccumuloProxy_hasNext_args__isset() : scanner(false) {} - bool scanner :1; -} _AccumuloProxy_hasNext_args__isset; +typedef struct _AccumuloProxy_revokeNamespacePermission_args__isset { + _AccumuloProxy_revokeNamespacePermission_args__isset() : login(false), user(false), namespaceName(false), perm(false) {} + bool login :1; + bool user :1; + bool namespaceName :1; + bool perm :1; +} _AccumuloProxy_revokeNamespacePermission_args__isset; -class AccumuloProxy_hasNext_args { +class AccumuloProxy_revokeNamespacePermission_args { public: - AccumuloProxy_hasNext_args(const AccumuloProxy_hasNext_args&); - AccumuloProxy_hasNext_args& operator=(const AccumuloProxy_hasNext_args&); - AccumuloProxy_hasNext_args() : scanner() { + AccumuloProxy_revokeNamespacePermission_args(const AccumuloProxy_revokeNamespacePermission_args&); + AccumuloProxy_revokeNamespacePermission_args& operator=(const AccumuloProxy_revokeNamespacePermission_args&); + AccumuloProxy_revokeNamespacePermission_args() : login(), user(), namespaceName(), perm((NamespacePermission::type)0) { } - virtual ~AccumuloProxy_hasNext_args() throw(); - std::string scanner; + virtual ~AccumuloProxy_revokeNamespacePermission_args() throw(); + std::string login; + std::string user; + std::string namespaceName; + NamespacePermission::type perm; - _AccumuloProxy_hasNext_args__isset __isset; + _AccumuloProxy_revokeNamespacePermission_args__isset __isset; - void __set_scanner(const std::string& val); + void __set_login(const std::string& val); - bool operator == (const AccumuloProxy_hasNext_args & rhs) const + void __set_user(const std::string& val); + + void __set_namespaceName(const std::string& val); + + void __set_perm(const NamespacePermission::type val); + + bool operator == (const AccumuloProxy_revokeNamespacePermission_args & rhs) const { - if (!(scanner == rhs.scanner)) + if (!(login == rhs.login)) + return false; + if (!(user == rhs.user)) + return false; + if (!(namespaceName == rhs.namespaceName)) + return false; + if (!(perm == rhs.perm)) return false; return true; } - bool operator != (const AccumuloProxy_hasNext_args &rhs) const { + bool operator != (const AccumuloProxy_revokeNamespacePermission_args &rhs) const { return !(*this == rhs); } - bool operator < (const AccumuloProxy_hasNext_args & ) const; + bool operator < (const AccumuloProxy_revokeNamespacePermission_args & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; @@ -8714,111 +8818,126 @@ class AccumuloProxy_hasNext_args { }; -class AccumuloProxy_hasNext_pargs { +class AccumuloProxy_revokeNamespacePermission_pargs { public: - virtual ~AccumuloProxy_hasNext_pargs() throw(); - const std::string* scanner; + virtual ~AccumuloProxy_revokeNamespacePermission_pargs() throw(); + const std::string* login; + const std::string* user; + const std::string* namespaceName; + const NamespacePermission::type* perm; uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -typedef struct _AccumuloProxy_hasNext_result__isset { - _AccumuloProxy_hasNext_result__isset() : success(false), ouch1(false) {} - bool success :1; +typedef struct _AccumuloProxy_revokeNamespacePermission_result__isset { + _AccumuloProxy_revokeNamespacePermission_result__isset() : ouch1(false), ouch2(false) {} bool ouch1 :1; -} _AccumuloProxy_hasNext_result__isset; + bool ouch2 :1; +} _AccumuloProxy_revokeNamespacePermission_result__isset; -class AccumuloProxy_hasNext_result { +class AccumuloProxy_revokeNamespacePermission_result { public: - AccumuloProxy_hasNext_result(const AccumuloProxy_hasNext_result&); - AccumuloProxy_hasNext_result& operator=(const AccumuloProxy_hasNext_result&); - AccumuloProxy_hasNext_result() : success(0) { + AccumuloProxy_revokeNamespacePermission_result(const AccumuloProxy_revokeNamespacePermission_result&); + AccumuloProxy_revokeNamespacePermission_result& operator=(const AccumuloProxy_revokeNamespacePermission_result&); + AccumuloProxy_revokeNamespacePermission_result() { } - virtual ~AccumuloProxy_hasNext_result() throw(); - bool success; - UnknownScanner ouch1; + virtual ~AccumuloProxy_revokeNamespacePermission_result() throw(); + AccumuloException ouch1; + AccumuloSecurityException ouch2; - _AccumuloProxy_hasNext_result__isset __isset; + _AccumuloProxy_revokeNamespacePermission_result__isset __isset; - void __set_success(const bool val); + void __set_ouch1(const AccumuloException& val); - void __set_ouch1(const UnknownScanner& val); + void __set_ouch2(const AccumuloSecurityException& val); - bool operator == (const AccumuloProxy_hasNext_result & rhs) const + bool operator == (const AccumuloProxy_revokeNamespacePermission_result & rhs) const { - if (!(success == rhs.success)) - return false; if (!(ouch1 == rhs.ouch1)) return false; + if (!(ouch2 == rhs.ouch2)) + return false; return true; } - bool operator != (const AccumuloProxy_hasNext_result &rhs) const { + bool operator != (const AccumuloProxy_revokeNamespacePermission_result &rhs) const { return !(*this == rhs); } - bool operator < (const AccumuloProxy_hasNext_result & ) const; + bool operator < (const AccumuloProxy_revokeNamespacePermission_result & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -typedef struct _AccumuloProxy_hasNext_presult__isset { - _AccumuloProxy_hasNext_presult__isset() : success(false), ouch1(false) {} - bool success :1; +typedef struct _AccumuloProxy_revokeNamespacePermission_presult__isset { + _AccumuloProxy_revokeNamespacePermission_presult__isset() : ouch1(false), ouch2(false) {} bool ouch1 :1; -} _AccumuloProxy_hasNext_presult__isset; + bool ouch2 :1; +} _AccumuloProxy_revokeNamespacePermission_presult__isset; -class AccumuloProxy_hasNext_presult { +class AccumuloProxy_revokeNamespacePermission_presult { public: - virtual ~AccumuloProxy_hasNext_presult() throw(); - bool* success; - UnknownScanner ouch1; + virtual ~AccumuloProxy_revokeNamespacePermission_presult() throw(); + AccumuloException ouch1; + AccumuloSecurityException ouch2; - _AccumuloProxy_hasNext_presult__isset __isset; + _AccumuloProxy_revokeNamespacePermission_presult__isset __isset; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); }; -typedef struct _AccumuloProxy_nextEntry_args__isset { - _AccumuloProxy_nextEntry_args__isset() : scanner(false) {} - bool scanner :1; -} _AccumuloProxy_nextEntry_args__isset; +typedef struct _AccumuloProxy_createBatchScanner_args__isset { + _AccumuloProxy_createBatchScanner_args__isset() : login(false), tableName(false), options(false) {} + bool login :1; + bool tableName :1; + bool options :1; +} _AccumuloProxy_createBatchScanner_args__isset; -class AccumuloProxy_nextEntry_args { +class AccumuloProxy_createBatchScanner_args { public: - AccumuloProxy_nextEntry_args(const AccumuloProxy_nextEntry_args&); - AccumuloProxy_nextEntry_args& operator=(const AccumuloProxy_nextEntry_args&); - AccumuloProxy_nextEntry_args() : scanner() { + AccumuloProxy_createBatchScanner_args(const AccumuloProxy_createBatchScanner_args&); + AccumuloProxy_createBatchScanner_args& operator=(const AccumuloProxy_createBatchScanner_args&); + AccumuloProxy_createBatchScanner_args() : login(), tableName() { } - virtual ~AccumuloProxy_nextEntry_args() throw(); - std::string scanner; + virtual ~AccumuloProxy_createBatchScanner_args() throw(); + std::string login; + std::string tableName; + BatchScanOptions options; - _AccumuloProxy_nextEntry_args__isset __isset; + _AccumuloProxy_createBatchScanner_args__isset __isset; - void __set_scanner(const std::string& val); + void __set_login(const std::string& val); - bool operator == (const AccumuloProxy_nextEntry_args & rhs) const + void __set_tableName(const std::string& val); + + void __set_options(const BatchScanOptions& val); + + bool operator == (const AccumuloProxy_createBatchScanner_args & rhs) const { - if (!(scanner == rhs.scanner)) + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(options == rhs.options)) return false; return true; } - bool operator != (const AccumuloProxy_nextEntry_args &rhs) const { + bool operator != (const AccumuloProxy_createBatchScanner_args &rhs) const { return !(*this == rhs); } - bool operator < (const AccumuloProxy_nextEntry_args & ) const; + bool operator < (const AccumuloProxy_createBatchScanner_args & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; @@ -8826,50 +8945,52 @@ class AccumuloProxy_nextEntry_args { }; -class AccumuloProxy_nextEntry_pargs { +class AccumuloProxy_createBatchScanner_pargs { public: - virtual ~AccumuloProxy_nextEntry_pargs() throw(); - const std::string* scanner; + virtual ~AccumuloProxy_createBatchScanner_pargs() throw(); + const std::string* login; + const std::string* tableName; + const BatchScanOptions* options; uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -typedef struct _AccumuloProxy_nextEntry_result__isset { - _AccumuloProxy_nextEntry_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} +typedef struct _AccumuloProxy_createBatchScanner_result__isset { + _AccumuloProxy_createBatchScanner_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} bool success :1; bool ouch1 :1; bool ouch2 :1; bool ouch3 :1; -} _AccumuloProxy_nextEntry_result__isset; +} _AccumuloProxy_createBatchScanner_result__isset; -class AccumuloProxy_nextEntry_result { +class AccumuloProxy_createBatchScanner_result { public: - AccumuloProxy_nextEntry_result(const AccumuloProxy_nextEntry_result&); - AccumuloProxy_nextEntry_result& operator=(const AccumuloProxy_nextEntry_result&); - AccumuloProxy_nextEntry_result() { + AccumuloProxy_createBatchScanner_result(const AccumuloProxy_createBatchScanner_result&); + AccumuloProxy_createBatchScanner_result& operator=(const AccumuloProxy_createBatchScanner_result&); + AccumuloProxy_createBatchScanner_result() : success() { } - virtual ~AccumuloProxy_nextEntry_result() throw(); - KeyValueAndPeek success; - NoMoreEntriesException ouch1; - UnknownScanner ouch2; - AccumuloSecurityException ouch3; + virtual ~AccumuloProxy_createBatchScanner_result() throw(); + std::string success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; - _AccumuloProxy_nextEntry_result__isset __isset; + _AccumuloProxy_createBatchScanner_result__isset __isset; - void __set_success(const KeyValueAndPeek& val); + void __set_success(const std::string& val); - void __set_ouch1(const NoMoreEntriesException& val); + void __set_ouch1(const AccumuloException& val); - void __set_ouch2(const UnknownScanner& val); + void __set_ouch2(const AccumuloSecurityException& val); - void __set_ouch3(const AccumuloSecurityException& val); + void __set_ouch3(const TableNotFoundException& val); - bool operator == (const AccumuloProxy_nextEntry_result & rhs) const + bool operator == (const AccumuloProxy_createBatchScanner_result & rhs) const { if (!(success == rhs.success)) return false; @@ -8881,78 +9002,84 @@ class AccumuloProxy_nextEntry_result { return false; return true; } - bool operator != (const AccumuloProxy_nextEntry_result &rhs) const { + bool operator != (const AccumuloProxy_createBatchScanner_result &rhs) const { return !(*this == rhs); } - bool operator < (const AccumuloProxy_nextEntry_result & ) const; + bool operator < (const AccumuloProxy_createBatchScanner_result & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -typedef struct _AccumuloProxy_nextEntry_presult__isset { - _AccumuloProxy_nextEntry_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} +typedef struct _AccumuloProxy_createBatchScanner_presult__isset { + _AccumuloProxy_createBatchScanner_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} bool success :1; bool ouch1 :1; bool ouch2 :1; bool ouch3 :1; -} _AccumuloProxy_nextEntry_presult__isset; +} _AccumuloProxy_createBatchScanner_presult__isset; -class AccumuloProxy_nextEntry_presult { +class AccumuloProxy_createBatchScanner_presult { public: - virtual ~AccumuloProxy_nextEntry_presult() throw(); - KeyValueAndPeek* success; - NoMoreEntriesException ouch1; - UnknownScanner ouch2; - AccumuloSecurityException ouch3; + virtual ~AccumuloProxy_createBatchScanner_presult() throw(); + std::string* success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; - _AccumuloProxy_nextEntry_presult__isset __isset; + _AccumuloProxy_createBatchScanner_presult__isset __isset; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); }; -typedef struct _AccumuloProxy_nextK_args__isset { - _AccumuloProxy_nextK_args__isset() : scanner(false), k(false) {} - bool scanner :1; - bool k :1; -} _AccumuloProxy_nextK_args__isset; +typedef struct _AccumuloProxy_createScanner_args__isset { + _AccumuloProxy_createScanner_args__isset() : login(false), tableName(false), options(false) {} + bool login :1; + bool tableName :1; + bool options :1; +} _AccumuloProxy_createScanner_args__isset; -class AccumuloProxy_nextK_args { +class AccumuloProxy_createScanner_args { public: - AccumuloProxy_nextK_args(const AccumuloProxy_nextK_args&); - AccumuloProxy_nextK_args& operator=(const AccumuloProxy_nextK_args&); - AccumuloProxy_nextK_args() : scanner(), k(0) { + AccumuloProxy_createScanner_args(const AccumuloProxy_createScanner_args&); + AccumuloProxy_createScanner_args& operator=(const AccumuloProxy_createScanner_args&); + AccumuloProxy_createScanner_args() : login(), tableName() { } - virtual ~AccumuloProxy_nextK_args() throw(); - std::string scanner; - int32_t k; + virtual ~AccumuloProxy_createScanner_args() throw(); + std::string login; + std::string tableName; + ScanOptions options; - _AccumuloProxy_nextK_args__isset __isset; + _AccumuloProxy_createScanner_args__isset __isset; - void __set_scanner(const std::string& val); + void __set_login(const std::string& val); - void __set_k(const int32_t val); + void __set_tableName(const std::string& val); - bool operator == (const AccumuloProxy_nextK_args & rhs) const + void __set_options(const ScanOptions& val); + + bool operator == (const AccumuloProxy_createScanner_args & rhs) const { - if (!(scanner == rhs.scanner)) + if (!(login == rhs.login)) return false; - if (!(k == rhs.k)) + if (!(tableName == rhs.tableName)) + return false; + if (!(options == rhs.options)) return false; return true; } - bool operator != (const AccumuloProxy_nextK_args &rhs) const { + bool operator != (const AccumuloProxy_createScanner_args &rhs) const { return !(*this == rhs); } - bool operator < (const AccumuloProxy_nextK_args & ) const; + bool operator < (const AccumuloProxy_createScanner_args & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; @@ -8960,51 +9087,52 @@ class AccumuloProxy_nextK_args { }; -class AccumuloProxy_nextK_pargs { +class AccumuloProxy_createScanner_pargs { public: - virtual ~AccumuloProxy_nextK_pargs() throw(); - const std::string* scanner; - const int32_t* k; + virtual ~AccumuloProxy_createScanner_pargs() throw(); + const std::string* login; + const std::string* tableName; + const ScanOptions* options; uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -typedef struct _AccumuloProxy_nextK_result__isset { - _AccumuloProxy_nextK_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} +typedef struct _AccumuloProxy_createScanner_result__isset { + _AccumuloProxy_createScanner_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} bool success :1; bool ouch1 :1; bool ouch2 :1; bool ouch3 :1; -} _AccumuloProxy_nextK_result__isset; +} _AccumuloProxy_createScanner_result__isset; -class AccumuloProxy_nextK_result { +class AccumuloProxy_createScanner_result { public: - AccumuloProxy_nextK_result(const AccumuloProxy_nextK_result&); - AccumuloProxy_nextK_result& operator=(const AccumuloProxy_nextK_result&); - AccumuloProxy_nextK_result() { + AccumuloProxy_createScanner_result(const AccumuloProxy_createScanner_result&); + AccumuloProxy_createScanner_result& operator=(const AccumuloProxy_createScanner_result&); + AccumuloProxy_createScanner_result() : success() { } - virtual ~AccumuloProxy_nextK_result() throw(); - ScanResult success; - NoMoreEntriesException ouch1; - UnknownScanner ouch2; - AccumuloSecurityException ouch3; + virtual ~AccumuloProxy_createScanner_result() throw(); + std::string success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; - _AccumuloProxy_nextK_result__isset __isset; + _AccumuloProxy_createScanner_result__isset __isset; - void __set_success(const ScanResult& val); + void __set_success(const std::string& val); - void __set_ouch1(const NoMoreEntriesException& val); + void __set_ouch1(const AccumuloException& val); - void __set_ouch2(const UnknownScanner& val); + void __set_ouch2(const AccumuloSecurityException& val); - void __set_ouch3(const AccumuloSecurityException& val); + void __set_ouch3(const TableNotFoundException& val); - bool operator == (const AccumuloProxy_nextK_result & rhs) const + bool operator == (const AccumuloProxy_createScanner_result & rhs) const { if (!(success == rhs.success)) return false; @@ -9016,72 +9144,2830 @@ class AccumuloProxy_nextK_result { return false; return true; } - bool operator != (const AccumuloProxy_nextK_result &rhs) const { + bool operator != (const AccumuloProxy_createScanner_result &rhs) const { return !(*this == rhs); } - bool operator < (const AccumuloProxy_nextK_result & ) const; + bool operator < (const AccumuloProxy_createScanner_result & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -typedef struct _AccumuloProxy_nextK_presult__isset { - _AccumuloProxy_nextK_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} +typedef struct _AccumuloProxy_createScanner_presult__isset { + _AccumuloProxy_createScanner_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} bool success :1; bool ouch1 :1; bool ouch2 :1; bool ouch3 :1; -} _AccumuloProxy_nextK_presult__isset; +} _AccumuloProxy_createScanner_presult__isset; -class AccumuloProxy_nextK_presult { +class AccumuloProxy_createScanner_presult { public: - virtual ~AccumuloProxy_nextK_presult() throw(); - ScanResult* success; - NoMoreEntriesException ouch1; - UnknownScanner ouch2; - AccumuloSecurityException ouch3; + virtual ~AccumuloProxy_createScanner_presult() throw(); + std::string* success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; - _AccumuloProxy_nextK_presult__isset __isset; + _AccumuloProxy_createScanner_presult__isset __isset; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); }; -typedef struct _AccumuloProxy_closeScanner_args__isset { - _AccumuloProxy_closeScanner_args__isset() : scanner(false) {} +typedef struct _AccumuloProxy_hasNext_args__isset { + _AccumuloProxy_hasNext_args__isset() : scanner(false) {} bool scanner :1; -} _AccumuloProxy_closeScanner_args__isset; +} _AccumuloProxy_hasNext_args__isset; + +class AccumuloProxy_hasNext_args { + public: + + AccumuloProxy_hasNext_args(const AccumuloProxy_hasNext_args&); + AccumuloProxy_hasNext_args& operator=(const AccumuloProxy_hasNext_args&); + AccumuloProxy_hasNext_args() : scanner() { + } + + virtual ~AccumuloProxy_hasNext_args() throw(); + std::string scanner; + + _AccumuloProxy_hasNext_args__isset __isset; + + void __set_scanner(const std::string& val); + + bool operator == (const AccumuloProxy_hasNext_args & rhs) const + { + if (!(scanner == rhs.scanner)) + return false; + return true; + } + bool operator != (const AccumuloProxy_hasNext_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_hasNext_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_hasNext_pargs { + public: + + + virtual ~AccumuloProxy_hasNext_pargs() throw(); + const std::string* scanner; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_hasNext_result__isset { + _AccumuloProxy_hasNext_result__isset() : success(false), ouch1(false) {} + bool success :1; + bool ouch1 :1; +} _AccumuloProxy_hasNext_result__isset; + +class AccumuloProxy_hasNext_result { + public: + + AccumuloProxy_hasNext_result(const AccumuloProxy_hasNext_result&); + AccumuloProxy_hasNext_result& operator=(const AccumuloProxy_hasNext_result&); + AccumuloProxy_hasNext_result() : success(0) { + } + + virtual ~AccumuloProxy_hasNext_result() throw(); + bool success; + UnknownScanner ouch1; + + _AccumuloProxy_hasNext_result__isset __isset; + + void __set_success(const bool val); + + void __set_ouch1(const UnknownScanner& val); + + bool operator == (const AccumuloProxy_hasNext_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(ouch1 == rhs.ouch1)) + return false; + return true; + } + bool operator != (const AccumuloProxy_hasNext_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_hasNext_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_hasNext_presult__isset { + _AccumuloProxy_hasNext_presult__isset() : success(false), ouch1(false) {} + bool success :1; + bool ouch1 :1; +} _AccumuloProxy_hasNext_presult__isset; + +class AccumuloProxy_hasNext_presult { + public: + + + virtual ~AccumuloProxy_hasNext_presult() throw(); + bool* success; + UnknownScanner ouch1; + + _AccumuloProxy_hasNext_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_nextEntry_args__isset { + _AccumuloProxy_nextEntry_args__isset() : scanner(false) {} + bool scanner :1; +} _AccumuloProxy_nextEntry_args__isset; + +class AccumuloProxy_nextEntry_args { + public: + + AccumuloProxy_nextEntry_args(const AccumuloProxy_nextEntry_args&); + AccumuloProxy_nextEntry_args& operator=(const AccumuloProxy_nextEntry_args&); + AccumuloProxy_nextEntry_args() : scanner() { + } + + virtual ~AccumuloProxy_nextEntry_args() throw(); + std::string scanner; + + _AccumuloProxy_nextEntry_args__isset __isset; + + void __set_scanner(const std::string& val); + + bool operator == (const AccumuloProxy_nextEntry_args & rhs) const + { + if (!(scanner == rhs.scanner)) + return false; + return true; + } + bool operator != (const AccumuloProxy_nextEntry_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_nextEntry_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_nextEntry_pargs { + public: + + + virtual ~AccumuloProxy_nextEntry_pargs() throw(); + const std::string* scanner; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_nextEntry_result__isset { + _AccumuloProxy_nextEntry_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool ouch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_nextEntry_result__isset; + +class AccumuloProxy_nextEntry_result { + public: + + AccumuloProxy_nextEntry_result(const AccumuloProxy_nextEntry_result&); + AccumuloProxy_nextEntry_result& operator=(const AccumuloProxy_nextEntry_result&); + AccumuloProxy_nextEntry_result() { + } + + virtual ~AccumuloProxy_nextEntry_result() throw(); + KeyValueAndPeek success; + NoMoreEntriesException ouch1; + UnknownScanner ouch2; + AccumuloSecurityException ouch3; + + _AccumuloProxy_nextEntry_result__isset __isset; + + void __set_success(const KeyValueAndPeek& val); + + void __set_ouch1(const NoMoreEntriesException& val); + + void __set_ouch2(const UnknownScanner& val); + + void __set_ouch3(const AccumuloSecurityException& val); + + bool operator == (const AccumuloProxy_nextEntry_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_nextEntry_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_nextEntry_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_nextEntry_presult__isset { + _AccumuloProxy_nextEntry_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool ouch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_nextEntry_presult__isset; + +class AccumuloProxy_nextEntry_presult { + public: + + + virtual ~AccumuloProxy_nextEntry_presult() throw(); + KeyValueAndPeek* success; + NoMoreEntriesException ouch1; + UnknownScanner ouch2; + AccumuloSecurityException ouch3; + + _AccumuloProxy_nextEntry_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_nextK_args__isset { + _AccumuloProxy_nextK_args__isset() : scanner(false), k(false) {} + bool scanner :1; + bool k :1; +} _AccumuloProxy_nextK_args__isset; + +class AccumuloProxy_nextK_args { + public: + + AccumuloProxy_nextK_args(const AccumuloProxy_nextK_args&); + AccumuloProxy_nextK_args& operator=(const AccumuloProxy_nextK_args&); + AccumuloProxy_nextK_args() : scanner(), k(0) { + } + + virtual ~AccumuloProxy_nextK_args() throw(); + std::string scanner; + int32_t k; + + _AccumuloProxy_nextK_args__isset __isset; + + void __set_scanner(const std::string& val); + + void __set_k(const int32_t val); + + bool operator == (const AccumuloProxy_nextK_args & rhs) const + { + if (!(scanner == rhs.scanner)) + return false; + if (!(k == rhs.k)) + return false; + return true; + } + bool operator != (const AccumuloProxy_nextK_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_nextK_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_nextK_pargs { + public: + + + virtual ~AccumuloProxy_nextK_pargs() throw(); + const std::string* scanner; + const int32_t* k; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_nextK_result__isset { + _AccumuloProxy_nextK_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool ouch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_nextK_result__isset; + +class AccumuloProxy_nextK_result { + public: + + AccumuloProxy_nextK_result(const AccumuloProxy_nextK_result&); + AccumuloProxy_nextK_result& operator=(const AccumuloProxy_nextK_result&); + AccumuloProxy_nextK_result() { + } + + virtual ~AccumuloProxy_nextK_result() throw(); + ScanResult success; + NoMoreEntriesException ouch1; + UnknownScanner ouch2; + AccumuloSecurityException ouch3; + + _AccumuloProxy_nextK_result__isset __isset; + + void __set_success(const ScanResult& val); + + void __set_ouch1(const NoMoreEntriesException& val); + + void __set_ouch2(const UnknownScanner& val); + + void __set_ouch3(const AccumuloSecurityException& val); + + bool operator == (const AccumuloProxy_nextK_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_nextK_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_nextK_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_nextK_presult__isset { + _AccumuloProxy_nextK_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool ouch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_nextK_presult__isset; + +class AccumuloProxy_nextK_presult { + public: + + + virtual ~AccumuloProxy_nextK_presult() throw(); + ScanResult* success; + NoMoreEntriesException ouch1; + UnknownScanner ouch2; + AccumuloSecurityException ouch3; + + _AccumuloProxy_nextK_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_closeScanner_args__isset { + _AccumuloProxy_closeScanner_args__isset() : scanner(false) {} + bool scanner :1; +} _AccumuloProxy_closeScanner_args__isset; + +class AccumuloProxy_closeScanner_args { + public: + + AccumuloProxy_closeScanner_args(const AccumuloProxy_closeScanner_args&); + AccumuloProxy_closeScanner_args& operator=(const AccumuloProxy_closeScanner_args&); + AccumuloProxy_closeScanner_args() : scanner() { + } + + virtual ~AccumuloProxy_closeScanner_args() throw(); + std::string scanner; + + _AccumuloProxy_closeScanner_args__isset __isset; + + void __set_scanner(const std::string& val); + + bool operator == (const AccumuloProxy_closeScanner_args & rhs) const + { + if (!(scanner == rhs.scanner)) + return false; + return true; + } + bool operator != (const AccumuloProxy_closeScanner_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_closeScanner_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_closeScanner_pargs { + public: + + + virtual ~AccumuloProxy_closeScanner_pargs() throw(); + const std::string* scanner; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_closeScanner_result__isset { + _AccumuloProxy_closeScanner_result__isset() : ouch1(false) {} + bool ouch1 :1; +} _AccumuloProxy_closeScanner_result__isset; + +class AccumuloProxy_closeScanner_result { + public: + + AccumuloProxy_closeScanner_result(const AccumuloProxy_closeScanner_result&); + AccumuloProxy_closeScanner_result& operator=(const AccumuloProxy_closeScanner_result&); + AccumuloProxy_closeScanner_result() { + } + + virtual ~AccumuloProxy_closeScanner_result() throw(); + UnknownScanner ouch1; + + _AccumuloProxy_closeScanner_result__isset __isset; + + void __set_ouch1(const UnknownScanner& val); + + bool operator == (const AccumuloProxy_closeScanner_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + return true; + } + bool operator != (const AccumuloProxy_closeScanner_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_closeScanner_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_closeScanner_presult__isset { + _AccumuloProxy_closeScanner_presult__isset() : ouch1(false) {} + bool ouch1 :1; +} _AccumuloProxy_closeScanner_presult__isset; + +class AccumuloProxy_closeScanner_presult { + public: + + + virtual ~AccumuloProxy_closeScanner_presult() throw(); + UnknownScanner ouch1; + + _AccumuloProxy_closeScanner_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_updateAndFlush_args__isset { + _AccumuloProxy_updateAndFlush_args__isset() : login(false), tableName(false), cells(false) {} + bool login :1; + bool tableName :1; + bool cells :1; +} _AccumuloProxy_updateAndFlush_args__isset; + +class AccumuloProxy_updateAndFlush_args { + public: + + AccumuloProxy_updateAndFlush_args(const AccumuloProxy_updateAndFlush_args&); + AccumuloProxy_updateAndFlush_args& operator=(const AccumuloProxy_updateAndFlush_args&); + AccumuloProxy_updateAndFlush_args() : login(), tableName() { + } + + virtual ~AccumuloProxy_updateAndFlush_args() throw(); + std::string login; + std::string tableName; + std::map<std::string, std::vector<ColumnUpdate> > cells; + + _AccumuloProxy_updateAndFlush_args__isset __isset; + + void __set_login(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_cells(const std::map<std::string, std::vector<ColumnUpdate> > & val); + + bool operator == (const AccumuloProxy_updateAndFlush_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(cells == rhs.cells)) + return false; + return true; + } + bool operator != (const AccumuloProxy_updateAndFlush_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_updateAndFlush_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_updateAndFlush_pargs { + public: + + + virtual ~AccumuloProxy_updateAndFlush_pargs() throw(); + const std::string* login; + const std::string* tableName; + const std::map<std::string, std::vector<ColumnUpdate> > * cells; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_updateAndFlush_result__isset { + _AccumuloProxy_updateAndFlush_result__isset() : outch1(false), ouch2(false), ouch3(false), ouch4(false) {} + bool outch1 :1; + bool ouch2 :1; + bool ouch3 :1; + bool ouch4 :1; +} _AccumuloProxy_updateAndFlush_result__isset; + +class AccumuloProxy_updateAndFlush_result { + public: + + AccumuloProxy_updateAndFlush_result(const AccumuloProxy_updateAndFlush_result&); + AccumuloProxy_updateAndFlush_result& operator=(const AccumuloProxy_updateAndFlush_result&); + AccumuloProxy_updateAndFlush_result() { + } + + virtual ~AccumuloProxy_updateAndFlush_result() throw(); + AccumuloException outch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + MutationsRejectedException ouch4; + + _AccumuloProxy_updateAndFlush_result__isset __isset; + + void __set_outch1(const AccumuloException& val); + + void __set_ouch2(const AccumuloSecurityException& val); + + void __set_ouch3(const TableNotFoundException& val); + + void __set_ouch4(const MutationsRejectedException& val); + + bool operator == (const AccumuloProxy_updateAndFlush_result & rhs) const + { + if (!(outch1 == rhs.outch1)) + 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_updateAndFlush_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_updateAndFlush_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_updateAndFlush_presult__isset { + _AccumuloProxy_updateAndFlush_presult__isset() : outch1(false), ouch2(false), ouch3(false), ouch4(false) {} + bool outch1 :1; + bool ouch2 :1; + bool ouch3 :1; + bool ouch4 :1; +} _AccumuloProxy_updateAndFlush_presult__isset; + +class AccumuloProxy_updateAndFlush_presult { + public: + + + virtual ~AccumuloProxy_updateAndFlush_presult() throw(); + AccumuloException outch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + MutationsRejectedException ouch4; + + _AccumuloProxy_updateAndFlush_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_createWriter_args__isset { + _AccumuloProxy_createWriter_args__isset() : login(false), tableName(false), opts(false) {} + bool login :1; + bool tableName :1; + bool opts :1; +} _AccumuloProxy_createWriter_args__isset; + +class AccumuloProxy_createWriter_args { + public: + + AccumuloProxy_createWriter_args(const AccumuloProxy_createWriter_args&); + AccumuloProxy_createWriter_args& operator=(const AccumuloProxy_createWriter_args&); + AccumuloProxy_createWriter_args() : login(), tableName() { + } + + virtual ~AccumuloProxy_createWriter_args() throw(); + std::string login; + std::string tableName; + WriterOptions opts; + + _AccumuloProxy_createWriter_args__isset __isset; + + void __set_login(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_opts(const WriterOptions& val); + + bool operator == (const AccumuloProxy_createWriter_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(opts == rhs.opts)) + return false; + return true; + } + bool operator != (const AccumuloProxy_createWriter_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_createWriter_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_createWriter_pargs { + public: + + + virtual ~AccumuloProxy_createWriter_pargs() throw(); + const std::string* login; + const std::string* tableName; + const WriterOptions* opts; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_createWriter_result__isset { + _AccumuloProxy_createWriter_result__isset() : success(false), outch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool outch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_createWriter_result__isset; + +class AccumuloProxy_createWriter_result { + public: + + AccumuloProxy_createWriter_result(const AccumuloProxy_createWriter_result&); + AccumuloProxy_createWriter_result& operator=(const AccumuloProxy_createWriter_result&); + AccumuloProxy_createWriter_result() : success() { + } + + virtual ~AccumuloProxy_createWriter_result() throw(); + std::string success; + AccumuloException outch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_createWriter_result__isset __isset; + + void __set_success(const std::string& val); + + void __set_outch1(const AccumuloException& val); + + void __set_ouch2(const AccumuloSecurityException& val); + + void __set_ouch3(const TableNotFoundException& val); + + bool operator == (const AccumuloProxy_createWriter_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(outch1 == rhs.outch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + if (!(ouch3 == rhs.ouch3)) + return false; + return true; + } + bool operator != (const AccumuloProxy_createWriter_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_createWriter_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_createWriter_presult__isset { + _AccumuloProxy_createWriter_presult__isset() : success(false), outch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool outch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_createWriter_presult__isset; + +class AccumuloProxy_createWriter_presult { + public: + + + virtual ~AccumuloProxy_createWriter_presult() throw(); + std::string* success; + AccumuloException outch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_createWriter_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_update_args__isset { + _AccumuloProxy_update_args__isset() : writer(false), cells(false) {} + bool writer :1; + bool cells :1; +} _AccumuloProxy_update_args__isset; + +class AccumuloProxy_update_args { + public: + + AccumuloProxy_update_args(const AccumuloProxy_update_args&); + AccumuloProxy_update_args& operator=(const AccumuloProxy_update_args&); + AccumuloProxy_update_args() : writer() { + } + + virtual ~AccumuloProxy_update_args() throw(); + std::string writer; + std::map<std::string, std::vector<ColumnUpdate> > cells; + + _AccumuloProxy_update_args__isset __isset; + + void __set_writer(const std::string& val); + + void __set_cells(const std::map<std::string, std::vector<ColumnUpdate> > & val); + + bool operator == (const AccumuloProxy_update_args & rhs) const + { + if (!(writer == rhs.writer)) + return false; + if (!(cells == rhs.cells)) + return false; + return true; + } + bool operator != (const AccumuloProxy_update_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_update_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_update_pargs { + public: + + + virtual ~AccumuloProxy_update_pargs() throw(); + const std::string* writer; + const std::map<std::string, std::vector<ColumnUpdate> > * cells; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_flush_args__isset { + _AccumuloProxy_flush_args__isset() : writer(false) {} + bool writer :1; +} _AccumuloProxy_flush_args__isset; + +class AccumuloProxy_flush_args { + public: + + AccumuloProxy_flush_args(const AccumuloProxy_flush_args&); + AccumuloProxy_flush_args& operator=(const AccumuloProxy_flush_args&); + AccumuloProxy_flush_args() : writer() { + } + + virtual ~AccumuloProxy_flush_args() throw(); + std::string writer; + + _AccumuloProxy_flush_args__isset __isset; + + void __set_writer(const std::string& val); + + bool operator == (const AccumuloProxy_flush_args & rhs) const + { + if (!(writer == rhs.writer)) + return false; + return true; + } + bool operator != (const AccumuloProxy_flush_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_flush_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_flush_pargs { + public: + + + virtual ~AccumuloProxy_flush_pargs() throw(); + const std::string* writer; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_flush_result__isset { + _AccumuloProxy_flush_result__isset() : ouch1(false), ouch2(false) {} + bool ouch1 :1; + bool ouch2 :1; +} _AccumuloProxy_flush_result__isset; + +class AccumuloProxy_flush_result { + public: + + AccumuloProxy_flush_result(const AccumuloProxy_flush_result&); + AccumuloProxy_flush_result& operator=(const AccumuloProxy_flush_result&); + AccumuloProxy_flush_result() { + } + + virtual ~AccumuloProxy_flush_result() throw(); + UnknownWriter ouch1; + MutationsRejectedException ouch2; + + _AccumuloProxy_flush_result__isset __isset; + + void __set_ouch1(const UnknownWriter& val); + + void __set_ouch2(const MutationsRejectedException& val); + + bool operator == (const AccumuloProxy_flush_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + return true; + } + bool operator != (const AccumuloProxy_flush_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_flush_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_flush_presult__isset { + _AccumuloProxy_flush_presult__isset() : ouch1(false), ouch2(false) {} + bool ouch1 :1; + bool ouch2 :1; +} _AccumuloProxy_flush_presult__isset; + +class AccumuloProxy_flush_presult { + public: + + + virtual ~AccumuloProxy_flush_presult() throw(); + UnknownWriter ouch1; + MutationsRejectedException ouch2; + + _AccumuloProxy_flush_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_closeWriter_args__isset { + _AccumuloProxy_closeWriter_args__isset() : writer(false) {} + bool writer :1; +} _AccumuloProxy_closeWriter_args__isset; + +class AccumuloProxy_closeWriter_args { + public: + + AccumuloProxy_closeWriter_args(const AccumuloProxy_closeWriter_args&); + AccumuloProxy_closeWriter_args& operator=(const AccumuloProxy_closeWriter_args&); + AccumuloProxy_closeWriter_args() : writer() { + } + + virtual ~AccumuloProxy_closeWriter_args() throw(); + std::string writer; + + _AccumuloProxy_closeWriter_args__isset __isset; + + void __set_writer(const std::string& val); + + bool operator == (const AccumuloProxy_closeWriter_args & rhs) const + { + if (!(writer == rhs.writer)) + return false; + return true; + } + bool operator != (const AccumuloProxy_closeWriter_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_closeWriter_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_closeWriter_pargs { + public: + + + virtual ~AccumuloProxy_closeWriter_pargs() throw(); + const std::string* writer; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_closeWriter_result__isset { + _AccumuloProxy_closeWriter_result__isset() : ouch1(false), ouch2(false) {} + bool ouch1 :1; + bool ouch2 :1; +} _AccumuloProxy_closeWriter_result__isset; + +class AccumuloProxy_closeWriter_result { + public: + + AccumuloProxy_closeWriter_result(const AccumuloProxy_closeWriter_result&); + AccumuloProxy_closeWriter_result& operator=(const AccumuloProxy_closeWriter_result&); + AccumuloProxy_closeWriter_result() { + } + + virtual ~AccumuloProxy_closeWriter_result() throw(); + UnknownWriter ouch1; + MutationsRejectedException ouch2; + + _AccumuloProxy_closeWriter_result__isset __isset; + + void __set_ouch1(const UnknownWriter& val); + + void __set_ouch2(const MutationsRejectedException& val); + + bool operator == (const AccumuloProxy_closeWriter_result & rhs) const + { + if (!(ouch1 == rhs.ouch1)) + return false; + if (!(ouch2 == rhs.ouch2)) + return false; + return true; + } + bool operator != (const AccumuloProxy_closeWriter_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_closeWriter_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_closeWriter_presult__isset { + _AccumuloProxy_closeWriter_presult__isset() : ouch1(false), ouch2(false) {} + bool ouch1 :1; + bool ouch2 :1; +} _AccumuloProxy_closeWriter_presult__isset; + +class AccumuloProxy_closeWriter_presult { + public: + + + virtual ~AccumuloProxy_closeWriter_presult() throw(); + UnknownWriter ouch1; + MutationsRejectedException ouch2; + + _AccumuloProxy_closeWriter_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_updateRowConditionally_args__isset { + _AccumuloProxy_updateRowConditionally_args__isset() : login(false), tableName(false), row(false), updates(false) {} + bool login :1; + bool tableName :1; + bool row :1; + bool updates :1; +} _AccumuloProxy_updateRowConditionally_args__isset; + +class AccumuloProxy_updateRowConditionally_args { + public: + + AccumuloProxy_updateRowConditionally_args(const AccumuloProxy_updateRowConditionally_args&); + AccumuloProxy_updateRowConditionally_args& operator=(const AccumuloProxy_updateRowConditionally_args&); + AccumuloProxy_updateRowConditionally_args() : login(), tableName(), row() { + } + + virtual ~AccumuloProxy_updateRowConditionally_args() throw(); + std::string login; + std::string tableName; + std::string row; + ConditionalUpdates updates; + + _AccumuloProxy_updateRowConditionally_args__isset __isset; + + void __set_login(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_row(const std::string& val); + + void __set_updates(const ConditionalUpdates& val); + + bool operator == (const AccumuloProxy_updateRowConditionally_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(row == rhs.row)) + return false; + if (!(updates == rhs.updates)) + return false; + return true; + } + bool operator != (const AccumuloProxy_updateRowConditionally_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_updateRowConditionally_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_updateRowConditionally_pargs { + public: + + + virtual ~AccumuloProxy_updateRowConditionally_pargs() throw(); + const std::string* login; + const std::string* tableName; + const std::string* row; + const ConditionalUpdates* updates; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_updateRowConditionally_result__isset { + _AccumuloProxy_updateRowConditionally_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool ouch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_updateRowConditionally_result__isset; + +class AccumuloProxy_updateRowConditionally_result { + public: + + AccumuloProxy_updateRowConditionally_result(const AccumuloProxy_updateRowConditionally_result&); + AccumuloProxy_updateRowConditionally_result& operator=(const AccumuloProxy_updateRowConditionally_result&); + AccumuloProxy_updateRowConditionally_result() : success((ConditionalStatus::type)0) { + } + + virtual ~AccumuloProxy_updateRowConditionally_result() throw(); + ConditionalStatus::type success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_updateRowConditionally_result__isset __isset; + + void __set_success(const ConditionalStatus::type val); + + void __set_ouch1(const AccumuloException& val); + + void __set_ouch2(const AccumuloSecurityException& val); + + void __set_ouch3(const TableNotFoundException& val); + + bool operator == (const AccumuloProxy_updateRowConditionally_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_updateRowConditionally_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_updateRowConditionally_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_updateRowConditionally_presult__isset { + _AccumuloProxy_updateRowConditionally_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool ouch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_updateRowConditionally_presult__isset; + +class AccumuloProxy_updateRowConditionally_presult { + public: + + + virtual ~AccumuloProxy_updateRowConditionally_presult() throw(); + ConditionalStatus::type* success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_updateRowConditionally_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_createConditionalWriter_args__isset { + _AccumuloProxy_createConditionalWriter_args__isset() : login(false), tableName(false), options(false) {} + bool login :1; + bool tableName :1; + bool options :1; +} _AccumuloProxy_createConditionalWriter_args__isset; + +class AccumuloProxy_createConditionalWriter_args { + public: + + AccumuloProxy_createConditionalWriter_args(const AccumuloProxy_createConditionalWriter_args&); + AccumuloProxy_createConditionalWriter_args& operator=(const AccumuloProxy_createConditionalWriter_args&); + AccumuloProxy_createConditionalWriter_args() : login(), tableName() { + } + + virtual ~AccumuloProxy_createConditionalWriter_args() throw(); + std::string login; + std::string tableName; + ConditionalWriterOptions options; + + _AccumuloProxy_createConditionalWriter_args__isset __isset; + + void __set_login(const std::string& val); + + void __set_tableName(const std::string& val); + + void __set_options(const ConditionalWriterOptions& val); + + bool operator == (const AccumuloProxy_createConditionalWriter_args & rhs) const + { + if (!(login == rhs.login)) + return false; + if (!(tableName == rhs.tableName)) + return false; + if (!(options == rhs.options)) + return false; + return true; + } + bool operator != (const AccumuloProxy_createConditionalWriter_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_createConditionalWriter_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_createConditionalWriter_pargs { + public: + + + virtual ~AccumuloProxy_createConditionalWriter_pargs() throw(); + const std::string* login; + const std::string* tableName; + const ConditionalWriterOptions* options; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_createConditionalWriter_result__isset { + _AccumuloProxy_createConditionalWriter_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool ouch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_createConditionalWriter_result__isset; + +class AccumuloProxy_createConditionalWriter_result { + public: + + AccumuloProxy_createConditionalWriter_result(const AccumuloProxy_createConditionalWriter_result&); + AccumuloProxy_createConditionalWriter_result& operator=(const AccumuloProxy_createConditionalWriter_result&); + AccumuloProxy_createConditionalWriter_result() : success() { + } + + virtual ~AccumuloProxy_createConditionalWriter_result() throw(); + std::string success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_createConditionalWriter_result__isset __isset; + + void __set_success(const std::string& val); + + void __set_ouch1(const AccumuloException& val); + + void __set_ouch2(const AccumuloSecurityException& val); + + void __set_ouch3(const TableNotFoundException& val); + + bool operator == (const AccumuloProxy_createConditionalWriter_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_createConditionalWriter_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_createConditionalWriter_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_createConditionalWriter_presult__isset { + _AccumuloProxy_createConditionalWriter_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool ouch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_createConditionalWriter_presult__isset; + +class AccumuloProxy_createConditionalWriter_presult { + public: + + + virtual ~AccumuloProxy_createConditionalWriter_presult() throw(); + std::string* success; + AccumuloException ouch1; + AccumuloSecurityException ouch2; + TableNotFoundException ouch3; + + _AccumuloProxy_createConditionalWriter_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_updateRowsConditionally_args__isset { + _AccumuloProxy_updateRowsConditionally_args__isset() : conditionalWriter(false), updates(false) {} + bool conditionalWriter :1; + bool updates :1; +} _AccumuloProxy_updateRowsConditionally_args__isset; + +class AccumuloProxy_updateRowsConditionally_args { + public: + + AccumuloProxy_updateRowsConditionally_args(const AccumuloProxy_updateRowsConditionally_args&); + AccumuloProxy_updateRowsConditionally_args& operator=(const AccumuloProxy_updateRowsConditionally_args&); + AccumuloProxy_updateRowsConditionally_args() : conditionalWriter() { + } + + virtual ~AccumuloProxy_updateRowsConditionally_args() throw(); + std::string conditionalWriter; + std::map<std::string, ConditionalUpdates> updates; + + _AccumuloProxy_updateRowsConditionally_args__isset __isset; + + void __set_conditionalWriter(const std::string& val); + + void __set_updates(const std::map<std::string, ConditionalUpdates> & val); + + bool operator == (const AccumuloProxy_updateRowsConditionally_args & rhs) const + { + if (!(conditionalWriter == rhs.conditionalWriter)) + return false; + if (!(updates == rhs.updates)) + return false; + return true; + } + bool operator != (const AccumuloProxy_updateRowsConditionally_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_updateRowsConditionally_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_updateRowsConditionally_pargs { + public: + + + virtual ~AccumuloProxy_updateRowsConditionally_pargs() throw(); + const std::string* conditionalWriter; + const std::map<std::string, ConditionalUpdates> * updates; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_updateRowsConditionally_result__isset { + _AccumuloProxy_updateRowsConditionally_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool ouch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_updateRowsConditionally_result__isset; + +class AccumuloProxy_updateRowsConditionally_result { + public: + + AccumuloProxy_updateRowsConditionally_result(const AccumuloProxy_updateRowsConditionally_result&); + AccumuloProxy_updateRowsConditionally_result& operator=(const AccumuloProxy_updateRowsConditionally_result&); + AccumuloProxy_updateRowsConditionally_result() { + } + + virtual ~AccumuloProxy_updateRowsConditionally_result() throw(); + std::map<std::string, ConditionalStatus::type> success; + UnknownWriter ouch1; + AccumuloException ouch2; + AccumuloSecurityException ouch3; + + _AccumuloProxy_updateRowsConditionally_result__isset __isset; + + void __set_success(const std::map<std::string, ConditionalStatus::type> & val); + + void __set_ouch1(const UnknownWriter& val); + + void __set_ouch2(const AccumuloException& val); + + void __set_ouch3(const AccumuloSecurityException& val); + + bool operator == (const AccumuloProxy_updateRowsConditionally_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_updateRowsConditionally_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_updateRowsConditionally_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _AccumuloProxy_updateRowsConditionally_presult__isset { + _AccumuloProxy_updateRowsConditionally_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {} + bool success :1; + bool ouch1 :1; + bool ouch2 :1; + bool ouch3 :1; +} _AccumuloProxy_updateRowsConditionally_presult__isset; + +class AccumuloProxy_updateRowsConditionally_presult { + public: + + + virtual ~AccumuloProxy_updateRowsConditionally_presult() throw(); + std::map<std::string, ConditionalStatus::type> * success; + UnknownWriter ouch1; + AccumuloException ouch2; + AccumuloSecurityException ouch3; + + _AccumuloProxy_updateRowsConditionally_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _AccumuloProxy_closeConditionalWriter_args__isset { + _AccumuloProxy_closeConditionalWriter_args__isset() : conditionalWriter(false) {} + bool conditionalWriter :1; +} _AccumuloProxy_closeConditionalWriter_args__isset; + +class AccumuloProxy_closeConditionalWriter_args { + public: + + AccumuloProxy_closeConditionalWriter_args(const AccumuloProxy_closeConditionalWriter_args&); + AccumuloProxy_closeConditionalWriter_args& operator=(const AccumuloProxy_closeConditionalWriter_args&); + AccumuloProxy_closeConditionalWriter_args() : conditionalWriter() { + } + + virtual ~AccumuloProxy_closeConditionalWriter_args() throw(); + std::string conditionalWriter; + + _AccumuloProxy_closeConditionalWriter_args__isset __isset; + + void __set_conditionalWriter(const std::string& val); + + bool operator == (const AccumuloProxy_closeConditionalWriter_args & rhs) const + { + if (!(conditionalWriter == rhs.conditionalWriter)) + return false; + return true; + } + bool operator != (const AccumuloProxy_closeConditionalWriter_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloProxy_closeConditionalWriter_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_closeConditionalWriter_pargs { + public: + + + virtual ~AccumuloProxy_closeConditionalWriter_pargs() throw(); + const std::string* conditionalWriter; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class AccumuloProxy_closeConditionalWriter_result { + public: + + AccumuloProxy_closeConditionalWriter_result(const AccumuloProxy_closeConditionalWriter_result&); + AccumuloProxy_closeConditionalWriter_result& operator=(const AccumuloProxy_closeConditionalWriter_result&); + AccumuloProxy_closeConditionalWriter_result() { + } + + virtual ~AccumuloProxy_closeConditionalWriter_result() throw(); + + bool operator == (const AccumuloProxy_closeConditionalWriter_result & /* rhs */) const + { + return true; + } + bool operator != (const AccumuloProxy_closeConditionalWriter_result &rhs) co
<TRUNCATED>
