[7/9] accumulo git commit: ACCUMULO-4147 Add Accumulo Namespace Operations to Proxy

[kt...@apache.org]

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>