accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From e..@apache.org
Subject [09/18] accumulo git commit: ACCUMULO-4077 back out a couple of 0.9.1 hacks, run the new compiler
Date Wed, 16 Dec 2015 21:11:14 GMT
http://git-wip-us.apache.org/repos/asf/accumulo/blob/3af75fc6/proxy/src/main/cpp/AccumuloProxy.h
----------------------------------------------------------------------
diff --git a/proxy/src/main/cpp/AccumuloProxy.h b/proxy/src/main/cpp/AccumuloProxy.h
index 269884f..a14fda9 100644
--- a/proxy/src/main/cpp/AccumuloProxy.h
+++ b/proxy/src/main/cpp/AccumuloProxy.h
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 /**
- * Autogenerated by Thrift Compiler (0.9.1)
+ * Autogenerated by Thrift Compiler (0.9.3)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -24,10 +24,16 @@
 #define AccumuloProxy_H
 
 #include <thrift/TDispatchProcessor.h>
+#include <thrift/async/TConcurrentClientSyncInfo.h>
 #include "proxy_types.h"
 
 namespace accumulo {
 
+#ifdef _WIN32
+  #pragma warning( push )
+  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
+#endif
+
 class AccumuloProxyIf {
  public:
   virtual ~AccumuloProxyIf() {}
@@ -381,30 +387,27 @@ class AccumuloProxyNull : virtual public AccumuloProxyIf {
 
 typedef struct _AccumuloProxy_login_args__isset {
   _AccumuloProxy_login_args__isset() : principal(false), loginProperties(false) {}
-  bool principal;
-  bool loginProperties;
+  bool principal :1;
+  bool loginProperties :1;
 } _AccumuloProxy_login_args__isset;
 
 class AccumuloProxy_login_args {
  public:
 
+  AccumuloProxy_login_args(const AccumuloProxy_login_args&);
+  AccumuloProxy_login_args& operator=(const AccumuloProxy_login_args&);
   AccumuloProxy_login_args() : principal() {
   }
 
-  virtual ~AccumuloProxy_login_args() throw() {}
-
+  virtual ~AccumuloProxy_login_args() throw();
   std::string principal;
   std::map<std::string, std::string>  loginProperties;
 
   _AccumuloProxy_login_args__isset __isset;
 
-  void __set_principal(const std::string& val) {
-    principal = val;
-  }
+  void __set_principal(const std::string& val);
 
-  void __set_loginProperties(const std::map<std::string, std::string> & val) {
-    loginProperties = val;
-  }
+  void __set_loginProperties(const std::map<std::string, std::string> & val);
 
   bool operator == (const AccumuloProxy_login_args & rhs) const
   {
@@ -430,8 +433,7 @@ class AccumuloProxy_login_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_login_pargs() throw() {}
-
+  virtual ~AccumuloProxy_login_pargs() throw();
   const std::string* principal;
   const std::map<std::string, std::string> * loginProperties;
 
@@ -441,30 +443,27 @@ class AccumuloProxy_login_pargs {
 
 typedef struct _AccumuloProxy_login_result__isset {
   _AccumuloProxy_login_result__isset() : success(false), ouch2(false) {}
-  bool success;
-  bool ouch2;
+  bool success :1;
+  bool ouch2 :1;
 } _AccumuloProxy_login_result__isset;
 
 class AccumuloProxy_login_result {
  public:
 
+  AccumuloProxy_login_result(const AccumuloProxy_login_result&);
+  AccumuloProxy_login_result& operator=(const AccumuloProxy_login_result&);
   AccumuloProxy_login_result() : success() {
   }
 
-  virtual ~AccumuloProxy_login_result() throw() {}
-
+  virtual ~AccumuloProxy_login_result() throw();
   std::string success;
   AccumuloSecurityException ouch2;
 
   _AccumuloProxy_login_result__isset __isset;
 
-  void __set_success(const std::string& val) {
-    success = val;
-  }
+  void __set_success(const std::string& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
   bool operator == (const AccumuloProxy_login_result & rhs) const
   {
@@ -487,16 +486,15 @@ class AccumuloProxy_login_result {
 
 typedef struct _AccumuloProxy_login_presult__isset {
   _AccumuloProxy_login_presult__isset() : success(false), ouch2(false) {}
-  bool success;
-  bool ouch2;
+  bool success :1;
+  bool ouch2 :1;
 } _AccumuloProxy_login_presult__isset;
 
 class AccumuloProxy_login_presult {
  public:
 
 
-  virtual ~AccumuloProxy_login_presult() throw() {}
-
+  virtual ~AccumuloProxy_login_presult() throw();
   std::string* success;
   AccumuloSecurityException ouch2;
 
@@ -508,36 +506,31 @@ class AccumuloProxy_login_presult {
 
 typedef struct _AccumuloProxy_addConstraint_args__isset {
   _AccumuloProxy_addConstraint_args__isset() : login(false), tableName(false), constraintClassName(false) {}
-  bool login;
-  bool tableName;
-  bool constraintClassName;
+  bool login :1;
+  bool tableName :1;
+  bool constraintClassName :1;
 } _AccumuloProxy_addConstraint_args__isset;
 
 class AccumuloProxy_addConstraint_args {
  public:
 
+  AccumuloProxy_addConstraint_args(const AccumuloProxy_addConstraint_args&);
+  AccumuloProxy_addConstraint_args& operator=(const AccumuloProxy_addConstraint_args&);
   AccumuloProxy_addConstraint_args() : login(), tableName(), constraintClassName() {
   }
 
-  virtual ~AccumuloProxy_addConstraint_args() throw() {}
-
+  virtual ~AccumuloProxy_addConstraint_args() throw();
   std::string login;
   std::string tableName;
   std::string constraintClassName;
 
   _AccumuloProxy_addConstraint_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_constraintClassName(const std::string& val) {
-    constraintClassName = val;
-  }
+  void __set_constraintClassName(const std::string& val);
 
   bool operator == (const AccumuloProxy_addConstraint_args & rhs) const
   {
@@ -565,8 +558,7 @@ class AccumuloProxy_addConstraint_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_addConstraint_pargs() throw() {}
-
+  virtual ~AccumuloProxy_addConstraint_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const std::string* constraintClassName;
@@ -577,20 +569,21 @@ class AccumuloProxy_addConstraint_pargs {
 
 typedef struct _AccumuloProxy_addConstraint_result__isset {
   _AccumuloProxy_addConstraint_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_addConstraint_result__isset;
 
 class AccumuloProxy_addConstraint_result {
  public:
 
+  AccumuloProxy_addConstraint_result(const AccumuloProxy_addConstraint_result&);
+  AccumuloProxy_addConstraint_result& operator=(const AccumuloProxy_addConstraint_result&);
   AccumuloProxy_addConstraint_result() : success(0) {
   }
 
-  virtual ~AccumuloProxy_addConstraint_result() throw() {}
-
+  virtual ~AccumuloProxy_addConstraint_result() throw();
   int32_t success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -598,21 +591,13 @@ class AccumuloProxy_addConstraint_result {
 
   _AccumuloProxy_addConstraint_result__isset __isset;
 
-  void __set_success(const int32_t val) {
-    success = val;
-  }
+  void __set_success(const int32_t val);
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_addConstraint_result & rhs) const
   {
@@ -639,18 +624,17 @@ class AccumuloProxy_addConstraint_result {
 
 typedef struct _AccumuloProxy_addConstraint_presult__isset {
   _AccumuloProxy_addConstraint_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_addConstraint_presult__isset;
 
 class AccumuloProxy_addConstraint_presult {
  public:
 
 
-  virtual ~AccumuloProxy_addConstraint_presult() throw() {}
-
+  virtual ~AccumuloProxy_addConstraint_presult() throw();
   int32_t* success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -664,36 +648,31 @@ class AccumuloProxy_addConstraint_presult {
 
 typedef struct _AccumuloProxy_addSplits_args__isset {
   _AccumuloProxy_addSplits_args__isset() : login(false), tableName(false), splits(false) {}
-  bool login;
-  bool tableName;
-  bool splits;
+  bool login :1;
+  bool tableName :1;
+  bool splits :1;
 } _AccumuloProxy_addSplits_args__isset;
 
 class AccumuloProxy_addSplits_args {
  public:
 
+  AccumuloProxy_addSplits_args(const AccumuloProxy_addSplits_args&);
+  AccumuloProxy_addSplits_args& operator=(const AccumuloProxy_addSplits_args&);
   AccumuloProxy_addSplits_args() : login(), tableName() {
   }
 
-  virtual ~AccumuloProxy_addSplits_args() throw() {}
-
+  virtual ~AccumuloProxy_addSplits_args() throw();
   std::string login;
   std::string tableName;
   std::set<std::string>  splits;
 
   _AccumuloProxy_addSplits_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_splits(const std::set<std::string> & val) {
-    splits = val;
-  }
+  void __set_splits(const std::set<std::string> & val);
 
   bool operator == (const AccumuloProxy_addSplits_args & rhs) const
   {
@@ -721,8 +700,7 @@ class AccumuloProxy_addSplits_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_addSplits_pargs() throw() {}
-
+  virtual ~AccumuloProxy_addSplits_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const std::set<std::string> * splits;
@@ -733,36 +711,31 @@ class AccumuloProxy_addSplits_pargs {
 
 typedef struct _AccumuloProxy_addSplits_result__isset {
   _AccumuloProxy_addSplits_result__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_addSplits_result__isset;
 
 class AccumuloProxy_addSplits_result {
  public:
 
+  AccumuloProxy_addSplits_result(const AccumuloProxy_addSplits_result&);
+  AccumuloProxy_addSplits_result& operator=(const AccumuloProxy_addSplits_result&);
   AccumuloProxy_addSplits_result() {
   }
 
-  virtual ~AccumuloProxy_addSplits_result() throw() {}
-
+  virtual ~AccumuloProxy_addSplits_result() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
 
   _AccumuloProxy_addSplits_result__isset __isset;
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_addSplits_result & rhs) const
   {
@@ -787,17 +760,16 @@ class AccumuloProxy_addSplits_result {
 
 typedef struct _AccumuloProxy_addSplits_presult__isset {
   _AccumuloProxy_addSplits_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_addSplits_presult__isset;
 
 class AccumuloProxy_addSplits_presult {
  public:
 
 
-  virtual ~AccumuloProxy_addSplits_presult() throw() {}
-
+  virtual ~AccumuloProxy_addSplits_presult() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
@@ -810,20 +782,21 @@ class AccumuloProxy_addSplits_presult {
 
 typedef struct _AccumuloProxy_attachIterator_args__isset {
   _AccumuloProxy_attachIterator_args__isset() : login(false), tableName(false), setting(false), scopes(false) {}
-  bool login;
-  bool tableName;
-  bool setting;
-  bool scopes;
+  bool login :1;
+  bool tableName :1;
+  bool setting :1;
+  bool scopes :1;
 } _AccumuloProxy_attachIterator_args__isset;
 
 class AccumuloProxy_attachIterator_args {
  public:
 
+  AccumuloProxy_attachIterator_args(const AccumuloProxy_attachIterator_args&);
+  AccumuloProxy_attachIterator_args& operator=(const AccumuloProxy_attachIterator_args&);
   AccumuloProxy_attachIterator_args() : login(), tableName() {
   }
 
-  virtual ~AccumuloProxy_attachIterator_args() throw() {}
-
+  virtual ~AccumuloProxy_attachIterator_args() throw();
   std::string login;
   std::string tableName;
   IteratorSetting setting;
@@ -831,21 +804,13 @@ class AccumuloProxy_attachIterator_args {
 
   _AccumuloProxy_attachIterator_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_setting(const IteratorSetting& val) {
-    setting = val;
-  }
+  void __set_setting(const IteratorSetting& val);
 
-  void __set_scopes(const std::set<IteratorScope::type> & val) {
-    scopes = val;
-  }
+  void __set_scopes(const std::set<IteratorScope::type> & val);
 
   bool operator == (const AccumuloProxy_attachIterator_args & rhs) const
   {
@@ -875,8 +840,7 @@ class AccumuloProxy_attachIterator_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_attachIterator_pargs() throw() {}
-
+  virtual ~AccumuloProxy_attachIterator_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const IteratorSetting* setting;
@@ -888,36 +852,31 @@ class AccumuloProxy_attachIterator_pargs {
 
 typedef struct _AccumuloProxy_attachIterator_result__isset {
   _AccumuloProxy_attachIterator_result__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_attachIterator_result__isset;
 
 class AccumuloProxy_attachIterator_result {
  public:
 
+  AccumuloProxy_attachIterator_result(const AccumuloProxy_attachIterator_result&);
+  AccumuloProxy_attachIterator_result& operator=(const AccumuloProxy_attachIterator_result&);
   AccumuloProxy_attachIterator_result() {
   }
 
-  virtual ~AccumuloProxy_attachIterator_result() throw() {}
-
+  virtual ~AccumuloProxy_attachIterator_result() throw();
   AccumuloSecurityException ouch1;
   AccumuloException ouch2;
   TableNotFoundException ouch3;
 
   _AccumuloProxy_attachIterator_result__isset __isset;
 
-  void __set_ouch1(const AccumuloSecurityException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloSecurityException& val);
 
-  void __set_ouch2(const AccumuloException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_attachIterator_result & rhs) const
   {
@@ -942,17 +901,16 @@ class AccumuloProxy_attachIterator_result {
 
 typedef struct _AccumuloProxy_attachIterator_presult__isset {
   _AccumuloProxy_attachIterator_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_attachIterator_presult__isset;
 
 class AccumuloProxy_attachIterator_presult {
  public:
 
 
-  virtual ~AccumuloProxy_attachIterator_presult() throw() {}
-
+  virtual ~AccumuloProxy_attachIterator_presult() throw();
   AccumuloSecurityException ouch1;
   AccumuloException ouch2;
   TableNotFoundException ouch3;
@@ -965,20 +923,21 @@ class AccumuloProxy_attachIterator_presult {
 
 typedef struct _AccumuloProxy_checkIteratorConflicts_args__isset {
   _AccumuloProxy_checkIteratorConflicts_args__isset() : login(false), tableName(false), setting(false), scopes(false) {}
-  bool login;
-  bool tableName;
-  bool setting;
-  bool scopes;
+  bool login :1;
+  bool tableName :1;
+  bool setting :1;
+  bool scopes :1;
 } _AccumuloProxy_checkIteratorConflicts_args__isset;
 
 class AccumuloProxy_checkIteratorConflicts_args {
  public:
 
+  AccumuloProxy_checkIteratorConflicts_args(const AccumuloProxy_checkIteratorConflicts_args&);
+  AccumuloProxy_checkIteratorConflicts_args& operator=(const AccumuloProxy_checkIteratorConflicts_args&);
   AccumuloProxy_checkIteratorConflicts_args() : login(), tableName() {
   }
 
-  virtual ~AccumuloProxy_checkIteratorConflicts_args() throw() {}
-
+  virtual ~AccumuloProxy_checkIteratorConflicts_args() throw();
   std::string login;
   std::string tableName;
   IteratorSetting setting;
@@ -986,21 +945,13 @@ class AccumuloProxy_checkIteratorConflicts_args {
 
   _AccumuloProxy_checkIteratorConflicts_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_setting(const IteratorSetting& val) {
-    setting = val;
-  }
+  void __set_setting(const IteratorSetting& val);
 
-  void __set_scopes(const std::set<IteratorScope::type> & val) {
-    scopes = val;
-  }
+  void __set_scopes(const std::set<IteratorScope::type> & val);
 
   bool operator == (const AccumuloProxy_checkIteratorConflicts_args & rhs) const
   {
@@ -1030,8 +981,7 @@ class AccumuloProxy_checkIteratorConflicts_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_checkIteratorConflicts_pargs() throw() {}
-
+  virtual ~AccumuloProxy_checkIteratorConflicts_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const IteratorSetting* setting;
@@ -1043,36 +993,31 @@ class AccumuloProxy_checkIteratorConflicts_pargs {
 
 typedef struct _AccumuloProxy_checkIteratorConflicts_result__isset {
   _AccumuloProxy_checkIteratorConflicts_result__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_checkIteratorConflicts_result__isset;
 
 class AccumuloProxy_checkIteratorConflicts_result {
  public:
 
+  AccumuloProxy_checkIteratorConflicts_result(const AccumuloProxy_checkIteratorConflicts_result&);
+  AccumuloProxy_checkIteratorConflicts_result& operator=(const AccumuloProxy_checkIteratorConflicts_result&);
   AccumuloProxy_checkIteratorConflicts_result() {
   }
 
-  virtual ~AccumuloProxy_checkIteratorConflicts_result() throw() {}
-
+  virtual ~AccumuloProxy_checkIteratorConflicts_result() throw();
   AccumuloSecurityException ouch1;
   AccumuloException ouch2;
   TableNotFoundException ouch3;
 
   _AccumuloProxy_checkIteratorConflicts_result__isset __isset;
 
-  void __set_ouch1(const AccumuloSecurityException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloSecurityException& val);
 
-  void __set_ouch2(const AccumuloException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_checkIteratorConflicts_result & rhs) const
   {
@@ -1097,17 +1042,16 @@ class AccumuloProxy_checkIteratorConflicts_result {
 
 typedef struct _AccumuloProxy_checkIteratorConflicts_presult__isset {
   _AccumuloProxy_checkIteratorConflicts_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_checkIteratorConflicts_presult__isset;
 
 class AccumuloProxy_checkIteratorConflicts_presult {
  public:
 
 
-  virtual ~AccumuloProxy_checkIteratorConflicts_presult() throw() {}
-
+  virtual ~AccumuloProxy_checkIteratorConflicts_presult() throw();
   AccumuloSecurityException ouch1;
   AccumuloException ouch2;
   TableNotFoundException ouch3;
@@ -1120,30 +1064,27 @@ class AccumuloProxy_checkIteratorConflicts_presult {
 
 typedef struct _AccumuloProxy_clearLocatorCache_args__isset {
   _AccumuloProxy_clearLocatorCache_args__isset() : login(false), tableName(false) {}
-  bool login;
-  bool tableName;
+  bool login :1;
+  bool tableName :1;
 } _AccumuloProxy_clearLocatorCache_args__isset;
 
 class AccumuloProxy_clearLocatorCache_args {
  public:
 
+  AccumuloProxy_clearLocatorCache_args(const AccumuloProxy_clearLocatorCache_args&);
+  AccumuloProxy_clearLocatorCache_args& operator=(const AccumuloProxy_clearLocatorCache_args&);
   AccumuloProxy_clearLocatorCache_args() : login(), tableName() {
   }
 
-  virtual ~AccumuloProxy_clearLocatorCache_args() throw() {}
-
+  virtual ~AccumuloProxy_clearLocatorCache_args() throw();
   std::string login;
   std::string tableName;
 
   _AccumuloProxy_clearLocatorCache_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
   bool operator == (const AccumuloProxy_clearLocatorCache_args & rhs) const
   {
@@ -1169,8 +1110,7 @@ class AccumuloProxy_clearLocatorCache_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_clearLocatorCache_pargs() throw() {}
-
+  virtual ~AccumuloProxy_clearLocatorCache_pargs() throw();
   const std::string* login;
   const std::string* tableName;
 
@@ -1180,24 +1120,23 @@ class AccumuloProxy_clearLocatorCache_pargs {
 
 typedef struct _AccumuloProxy_clearLocatorCache_result__isset {
   _AccumuloProxy_clearLocatorCache_result__isset() : ouch1(false) {}
-  bool ouch1;
+  bool ouch1 :1;
 } _AccumuloProxy_clearLocatorCache_result__isset;
 
 class AccumuloProxy_clearLocatorCache_result {
  public:
 
+  AccumuloProxy_clearLocatorCache_result(const AccumuloProxy_clearLocatorCache_result&);
+  AccumuloProxy_clearLocatorCache_result& operator=(const AccumuloProxy_clearLocatorCache_result&);
   AccumuloProxy_clearLocatorCache_result() {
   }
 
-  virtual ~AccumuloProxy_clearLocatorCache_result() throw() {}
-
+  virtual ~AccumuloProxy_clearLocatorCache_result() throw();
   TableNotFoundException ouch1;
 
   _AccumuloProxy_clearLocatorCache_result__isset __isset;
 
-  void __set_ouch1(const TableNotFoundException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_clearLocatorCache_result & rhs) const
   {
@@ -1218,15 +1157,14 @@ class AccumuloProxy_clearLocatorCache_result {
 
 typedef struct _AccumuloProxy_clearLocatorCache_presult__isset {
   _AccumuloProxy_clearLocatorCache_presult__isset() : ouch1(false) {}
-  bool ouch1;
+  bool ouch1 :1;
 } _AccumuloProxy_clearLocatorCache_presult__isset;
 
 class AccumuloProxy_clearLocatorCache_presult {
  public:
 
 
-  virtual ~AccumuloProxy_clearLocatorCache_presult() throw() {}
-
+  virtual ~AccumuloProxy_clearLocatorCache_presult() throw();
   TableNotFoundException ouch1;
 
   _AccumuloProxy_clearLocatorCache_presult__isset __isset;
@@ -1237,22 +1175,23 @@ class AccumuloProxy_clearLocatorCache_presult {
 
 typedef struct _AccumuloProxy_cloneTable_args__isset {
   _AccumuloProxy_cloneTable_args__isset() : login(false), tableName(false), newTableName(false), flush(false), propertiesToSet(false), propertiesToExclude(false) {}
-  bool login;
-  bool tableName;
-  bool newTableName;
-  bool flush;
-  bool propertiesToSet;
-  bool propertiesToExclude;
+  bool login :1;
+  bool tableName :1;
+  bool newTableName :1;
+  bool flush :1;
+  bool propertiesToSet :1;
+  bool propertiesToExclude :1;
 } _AccumuloProxy_cloneTable_args__isset;
 
 class AccumuloProxy_cloneTable_args {
  public:
 
+  AccumuloProxy_cloneTable_args(const AccumuloProxy_cloneTable_args&);
+  AccumuloProxy_cloneTable_args& operator=(const AccumuloProxy_cloneTable_args&);
   AccumuloProxy_cloneTable_args() : login(), tableName(), newTableName(), flush(0) {
   }
 
-  virtual ~AccumuloProxy_cloneTable_args() throw() {}
-
+  virtual ~AccumuloProxy_cloneTable_args() throw();
   std::string login;
   std::string tableName;
   std::string newTableName;
@@ -1262,29 +1201,17 @@ class AccumuloProxy_cloneTable_args {
 
   _AccumuloProxy_cloneTable_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_newTableName(const std::string& val) {
-    newTableName = val;
-  }
+  void __set_newTableName(const std::string& val);
 
-  void __set_flush(const bool val) {
-    flush = val;
-  }
+  void __set_flush(const bool val);
 
-  void __set_propertiesToSet(const std::map<std::string, std::string> & val) {
-    propertiesToSet = val;
-  }
+  void __set_propertiesToSet(const std::map<std::string, std::string> & val);
 
-  void __set_propertiesToExclude(const std::set<std::string> & val) {
-    propertiesToExclude = val;
-  }
+  void __set_propertiesToExclude(const std::set<std::string> & val);
 
   bool operator == (const AccumuloProxy_cloneTable_args & rhs) const
   {
@@ -1318,8 +1245,7 @@ class AccumuloProxy_cloneTable_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_cloneTable_pargs() throw() {}
-
+  virtual ~AccumuloProxy_cloneTable_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const std::string* newTableName;
@@ -1333,20 +1259,21 @@ class AccumuloProxy_cloneTable_pargs {
 
 typedef struct _AccumuloProxy_cloneTable_result__isset {
   _AccumuloProxy_cloneTable_result__isset() : ouch1(false), ouch2(false), ouch3(false), ouch4(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
-  bool ouch4;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
+  bool ouch4 :1;
 } _AccumuloProxy_cloneTable_result__isset;
 
 class AccumuloProxy_cloneTable_result {
  public:
 
+  AccumuloProxy_cloneTable_result(const AccumuloProxy_cloneTable_result&);
+  AccumuloProxy_cloneTable_result& operator=(const AccumuloProxy_cloneTable_result&);
   AccumuloProxy_cloneTable_result() {
   }
 
-  virtual ~AccumuloProxy_cloneTable_result() throw() {}
-
+  virtual ~AccumuloProxy_cloneTable_result() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
@@ -1354,21 +1281,13 @@ class AccumuloProxy_cloneTable_result {
 
   _AccumuloProxy_cloneTable_result__isset __isset;
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
-  void __set_ouch4(const TableExistsException& val) {
-    ouch4 = val;
-  }
+  void __set_ouch4(const TableExistsException& val);
 
   bool operator == (const AccumuloProxy_cloneTable_result & rhs) const
   {
@@ -1395,18 +1314,17 @@ class AccumuloProxy_cloneTable_result {
 
 typedef struct _AccumuloProxy_cloneTable_presult__isset {
   _AccumuloProxy_cloneTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false), ouch4(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
-  bool ouch4;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
+  bool ouch4 :1;
 } _AccumuloProxy_cloneTable_presult__isset;
 
 class AccumuloProxy_cloneTable_presult {
  public:
 
 
-  virtual ~AccumuloProxy_cloneTable_presult() throw() {}
-
+  virtual ~AccumuloProxy_cloneTable_presult() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
@@ -1420,24 +1338,25 @@ class AccumuloProxy_cloneTable_presult {
 
 typedef struct _AccumuloProxy_compactTable_args__isset {
   _AccumuloProxy_compactTable_args__isset() : login(false), tableName(false), startRow(false), endRow(false), iterators(false), flush(false), wait(false), compactionStrategy(false) {}
-  bool login;
-  bool tableName;
-  bool startRow;
-  bool endRow;
-  bool iterators;
-  bool flush;
-  bool wait;
-  bool compactionStrategy;
+  bool login :1;
+  bool tableName :1;
+  bool startRow :1;
+  bool endRow :1;
+  bool iterators :1;
+  bool flush :1;
+  bool wait :1;
+  bool compactionStrategy :1;
 } _AccumuloProxy_compactTable_args__isset;
 
 class AccumuloProxy_compactTable_args {
  public:
 
+  AccumuloProxy_compactTable_args(const AccumuloProxy_compactTable_args&);
+  AccumuloProxy_compactTable_args& operator=(const AccumuloProxy_compactTable_args&);
   AccumuloProxy_compactTable_args() : login(), tableName(), startRow(), endRow(), flush(0), wait(0) {
   }
 
-  virtual ~AccumuloProxy_compactTable_args() throw() {}
-
+  virtual ~AccumuloProxy_compactTable_args() throw();
   std::string login;
   std::string tableName;
   std::string startRow;
@@ -1449,37 +1368,21 @@ class AccumuloProxy_compactTable_args {
 
   _AccumuloProxy_compactTable_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_startRow(const std::string& val) {
-    startRow = val;
-  }
+  void __set_startRow(const std::string& val);
 
-  void __set_endRow(const std::string& val) {
-    endRow = val;
-  }
+  void __set_endRow(const std::string& val);
 
-  void __set_iterators(const std::vector<IteratorSetting> & val) {
-    iterators = val;
-  }
+  void __set_iterators(const std::vector<IteratorSetting> & val);
 
-  void __set_flush(const bool val) {
-    flush = val;
-  }
+  void __set_flush(const bool val);
 
-  void __set_wait(const bool val) {
-    wait = val;
-  }
+  void __set_wait(const bool val);
 
-  void __set_compactionStrategy(const CompactionStrategyConfig& val) {
-    compactionStrategy = val;
-  }
+  void __set_compactionStrategy(const CompactionStrategyConfig& val);
 
   bool operator == (const AccumuloProxy_compactTable_args & rhs) const
   {
@@ -1517,8 +1420,7 @@ class AccumuloProxy_compactTable_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_compactTable_pargs() throw() {}
-
+  virtual ~AccumuloProxy_compactTable_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const std::string* startRow;
@@ -1534,36 +1436,31 @@ class AccumuloProxy_compactTable_pargs {
 
 typedef struct _AccumuloProxy_compactTable_result__isset {
   _AccumuloProxy_compactTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_compactTable_result__isset;
 
 class AccumuloProxy_compactTable_result {
  public:
 
+  AccumuloProxy_compactTable_result(const AccumuloProxy_compactTable_result&);
+  AccumuloProxy_compactTable_result& operator=(const AccumuloProxy_compactTable_result&);
   AccumuloProxy_compactTable_result() {
   }
 
-  virtual ~AccumuloProxy_compactTable_result() throw() {}
-
+  virtual ~AccumuloProxy_compactTable_result() throw();
   AccumuloSecurityException ouch1;
   TableNotFoundException ouch2;
   AccumuloException ouch3;
 
   _AccumuloProxy_compactTable_result__isset __isset;
 
-  void __set_ouch1(const AccumuloSecurityException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloSecurityException& val);
 
-  void __set_ouch2(const TableNotFoundException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const TableNotFoundException& val);
 
-  void __set_ouch3(const AccumuloException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const AccumuloException& val);
 
   bool operator == (const AccumuloProxy_compactTable_result & rhs) const
   {
@@ -1588,17 +1485,16 @@ class AccumuloProxy_compactTable_result {
 
 typedef struct _AccumuloProxy_compactTable_presult__isset {
   _AccumuloProxy_compactTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_compactTable_presult__isset;
 
 class AccumuloProxy_compactTable_presult {
  public:
 
 
-  virtual ~AccumuloProxy_compactTable_presult() throw() {}
-
+  virtual ~AccumuloProxy_compactTable_presult() throw();
   AccumuloSecurityException ouch1;
   TableNotFoundException ouch2;
   AccumuloException ouch3;
@@ -1611,30 +1507,27 @@ class AccumuloProxy_compactTable_presult {
 
 typedef struct _AccumuloProxy_cancelCompaction_args__isset {
   _AccumuloProxy_cancelCompaction_args__isset() : login(false), tableName(false) {}
-  bool login;
-  bool tableName;
+  bool login :1;
+  bool tableName :1;
 } _AccumuloProxy_cancelCompaction_args__isset;
 
 class AccumuloProxy_cancelCompaction_args {
  public:
 
+  AccumuloProxy_cancelCompaction_args(const AccumuloProxy_cancelCompaction_args&);
+  AccumuloProxy_cancelCompaction_args& operator=(const AccumuloProxy_cancelCompaction_args&);
   AccumuloProxy_cancelCompaction_args() : login(), tableName() {
   }
 
-  virtual ~AccumuloProxy_cancelCompaction_args() throw() {}
-
+  virtual ~AccumuloProxy_cancelCompaction_args() throw();
   std::string login;
   std::string tableName;
 
   _AccumuloProxy_cancelCompaction_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
   bool operator == (const AccumuloProxy_cancelCompaction_args & rhs) const
   {
@@ -1660,8 +1553,7 @@ class AccumuloProxy_cancelCompaction_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_cancelCompaction_pargs() throw() {}
-
+  virtual ~AccumuloProxy_cancelCompaction_pargs() throw();
   const std::string* login;
   const std::string* tableName;
 
@@ -1671,36 +1563,31 @@ class AccumuloProxy_cancelCompaction_pargs {
 
 typedef struct _AccumuloProxy_cancelCompaction_result__isset {
   _AccumuloProxy_cancelCompaction_result__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_cancelCompaction_result__isset;
 
 class AccumuloProxy_cancelCompaction_result {
  public:
 
+  AccumuloProxy_cancelCompaction_result(const AccumuloProxy_cancelCompaction_result&);
+  AccumuloProxy_cancelCompaction_result& operator=(const AccumuloProxy_cancelCompaction_result&);
   AccumuloProxy_cancelCompaction_result() {
   }
 
-  virtual ~AccumuloProxy_cancelCompaction_result() throw() {}
-
+  virtual ~AccumuloProxy_cancelCompaction_result() throw();
   AccumuloSecurityException ouch1;
   TableNotFoundException ouch2;
   AccumuloException ouch3;
 
   _AccumuloProxy_cancelCompaction_result__isset __isset;
 
-  void __set_ouch1(const AccumuloSecurityException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloSecurityException& val);
 
-  void __set_ouch2(const TableNotFoundException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const TableNotFoundException& val);
 
-  void __set_ouch3(const AccumuloException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const AccumuloException& val);
 
   bool operator == (const AccumuloProxy_cancelCompaction_result & rhs) const
   {
@@ -1725,17 +1612,16 @@ class AccumuloProxy_cancelCompaction_result {
 
 typedef struct _AccumuloProxy_cancelCompaction_presult__isset {
   _AccumuloProxy_cancelCompaction_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_cancelCompaction_presult__isset;
 
 class AccumuloProxy_cancelCompaction_presult {
  public:
 
 
-  virtual ~AccumuloProxy_cancelCompaction_presult() throw() {}
-
+  virtual ~AccumuloProxy_cancelCompaction_presult() throw();
   AccumuloSecurityException ouch1;
   TableNotFoundException ouch2;
   AccumuloException ouch3;
@@ -1748,20 +1634,21 @@ class AccumuloProxy_cancelCompaction_presult {
 
 typedef struct _AccumuloProxy_createTable_args__isset {
   _AccumuloProxy_createTable_args__isset() : login(false), tableName(false), versioningIter(false), type(false) {}
-  bool login;
-  bool tableName;
-  bool versioningIter;
-  bool type;
+  bool login :1;
+  bool tableName :1;
+  bool versioningIter :1;
+  bool type :1;
 } _AccumuloProxy_createTable_args__isset;
 
 class AccumuloProxy_createTable_args {
  public:
 
+  AccumuloProxy_createTable_args(const AccumuloProxy_createTable_args&);
+  AccumuloProxy_createTable_args& operator=(const AccumuloProxy_createTable_args&);
   AccumuloProxy_createTable_args() : login(), tableName(), versioningIter(0), type((TimeType::type)0) {
   }
 
-  virtual ~AccumuloProxy_createTable_args() throw() {}
-
+  virtual ~AccumuloProxy_createTable_args() throw();
   std::string login;
   std::string tableName;
   bool versioningIter;
@@ -1769,21 +1656,13 @@ class AccumuloProxy_createTable_args {
 
   _AccumuloProxy_createTable_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_versioningIter(const bool val) {
-    versioningIter = val;
-  }
+  void __set_versioningIter(const bool val);
 
-  void __set_type(const TimeType::type val) {
-    type = val;
-  }
+  void __set_type(const TimeType::type val);
 
   bool operator == (const AccumuloProxy_createTable_args & rhs) const
   {
@@ -1813,8 +1692,7 @@ class AccumuloProxy_createTable_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_createTable_pargs() throw() {}
-
+  virtual ~AccumuloProxy_createTable_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const bool* versioningIter;
@@ -1826,36 +1704,31 @@ class AccumuloProxy_createTable_pargs {
 
 typedef struct _AccumuloProxy_createTable_result__isset {
   _AccumuloProxy_createTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_createTable_result__isset;
 
 class AccumuloProxy_createTable_result {
  public:
 
+  AccumuloProxy_createTable_result(const AccumuloProxy_createTable_result&);
+  AccumuloProxy_createTable_result& operator=(const AccumuloProxy_createTable_result&);
   AccumuloProxy_createTable_result() {
   }
 
-  virtual ~AccumuloProxy_createTable_result() throw() {}
-
+  virtual ~AccumuloProxy_createTable_result() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableExistsException ouch3;
 
   _AccumuloProxy_createTable_result__isset __isset;
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableExistsException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableExistsException& val);
 
   bool operator == (const AccumuloProxy_createTable_result & rhs) const
   {
@@ -1880,17 +1753,16 @@ class AccumuloProxy_createTable_result {
 
 typedef struct _AccumuloProxy_createTable_presult__isset {
   _AccumuloProxy_createTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_createTable_presult__isset;
 
 class AccumuloProxy_createTable_presult {
  public:
 
 
-  virtual ~AccumuloProxy_createTable_presult() throw() {}
-
+  virtual ~AccumuloProxy_createTable_presult() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableExistsException ouch3;
@@ -1903,30 +1775,27 @@ class AccumuloProxy_createTable_presult {
 
 typedef struct _AccumuloProxy_deleteTable_args__isset {
   _AccumuloProxy_deleteTable_args__isset() : login(false), tableName(false) {}
-  bool login;
-  bool tableName;
+  bool login :1;
+  bool tableName :1;
 } _AccumuloProxy_deleteTable_args__isset;
 
 class AccumuloProxy_deleteTable_args {
  public:
 
+  AccumuloProxy_deleteTable_args(const AccumuloProxy_deleteTable_args&);
+  AccumuloProxy_deleteTable_args& operator=(const AccumuloProxy_deleteTable_args&);
   AccumuloProxy_deleteTable_args() : login(), tableName() {
   }
 
-  virtual ~AccumuloProxy_deleteTable_args() throw() {}
-
+  virtual ~AccumuloProxy_deleteTable_args() throw();
   std::string login;
   std::string tableName;
 
   _AccumuloProxy_deleteTable_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
   bool operator == (const AccumuloProxy_deleteTable_args & rhs) const
   {
@@ -1952,8 +1821,7 @@ class AccumuloProxy_deleteTable_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_deleteTable_pargs() throw() {}
-
+  virtual ~AccumuloProxy_deleteTable_pargs() throw();
   const std::string* login;
   const std::string* tableName;
 
@@ -1963,36 +1831,31 @@ class AccumuloProxy_deleteTable_pargs {
 
 typedef struct _AccumuloProxy_deleteTable_result__isset {
   _AccumuloProxy_deleteTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_deleteTable_result__isset;
 
 class AccumuloProxy_deleteTable_result {
  public:
 
+  AccumuloProxy_deleteTable_result(const AccumuloProxy_deleteTable_result&);
+  AccumuloProxy_deleteTable_result& operator=(const AccumuloProxy_deleteTable_result&);
   AccumuloProxy_deleteTable_result() {
   }
 
-  virtual ~AccumuloProxy_deleteTable_result() throw() {}
-
+  virtual ~AccumuloProxy_deleteTable_result() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
 
   _AccumuloProxy_deleteTable_result__isset __isset;
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_deleteTable_result & rhs) const
   {
@@ -2017,17 +1880,16 @@ class AccumuloProxy_deleteTable_result {
 
 typedef struct _AccumuloProxy_deleteTable_presult__isset {
   _AccumuloProxy_deleteTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_deleteTable_presult__isset;
 
 class AccumuloProxy_deleteTable_presult {
  public:
 
 
-  virtual ~AccumuloProxy_deleteTable_presult() throw() {}
-
+  virtual ~AccumuloProxy_deleteTable_presult() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
@@ -2040,20 +1902,21 @@ class AccumuloProxy_deleteTable_presult {
 
 typedef struct _AccumuloProxy_deleteRows_args__isset {
   _AccumuloProxy_deleteRows_args__isset() : login(false), tableName(false), startRow(false), endRow(false) {}
-  bool login;
-  bool tableName;
-  bool startRow;
-  bool endRow;
+  bool login :1;
+  bool tableName :1;
+  bool startRow :1;
+  bool endRow :1;
 } _AccumuloProxy_deleteRows_args__isset;
 
 class AccumuloProxy_deleteRows_args {
  public:
 
+  AccumuloProxy_deleteRows_args(const AccumuloProxy_deleteRows_args&);
+  AccumuloProxy_deleteRows_args& operator=(const AccumuloProxy_deleteRows_args&);
   AccumuloProxy_deleteRows_args() : login(), tableName(), startRow(), endRow() {
   }
 
-  virtual ~AccumuloProxy_deleteRows_args() throw() {}
-
+  virtual ~AccumuloProxy_deleteRows_args() throw();
   std::string login;
   std::string tableName;
   std::string startRow;
@@ -2061,21 +1924,13 @@ class AccumuloProxy_deleteRows_args {
 
   _AccumuloProxy_deleteRows_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_startRow(const std::string& val) {
-    startRow = val;
-  }
+  void __set_startRow(const std::string& val);
 
-  void __set_endRow(const std::string& val) {
-    endRow = val;
-  }
+  void __set_endRow(const std::string& val);
 
   bool operator == (const AccumuloProxy_deleteRows_args & rhs) const
   {
@@ -2105,8 +1960,7 @@ class AccumuloProxy_deleteRows_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_deleteRows_pargs() throw() {}
-
+  virtual ~AccumuloProxy_deleteRows_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const std::string* startRow;
@@ -2118,36 +1972,31 @@ class AccumuloProxy_deleteRows_pargs {
 
 typedef struct _AccumuloProxy_deleteRows_result__isset {
   _AccumuloProxy_deleteRows_result__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_deleteRows_result__isset;
 
 class AccumuloProxy_deleteRows_result {
  public:
 
+  AccumuloProxy_deleteRows_result(const AccumuloProxy_deleteRows_result&);
+  AccumuloProxy_deleteRows_result& operator=(const AccumuloProxy_deleteRows_result&);
   AccumuloProxy_deleteRows_result() {
   }
 
-  virtual ~AccumuloProxy_deleteRows_result() throw() {}
-
+  virtual ~AccumuloProxy_deleteRows_result() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
 
   _AccumuloProxy_deleteRows_result__isset __isset;
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_deleteRows_result & rhs) const
   {
@@ -2172,17 +2021,16 @@ class AccumuloProxy_deleteRows_result {
 
 typedef struct _AccumuloProxy_deleteRows_presult__isset {
   _AccumuloProxy_deleteRows_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_deleteRows_presult__isset;
 
 class AccumuloProxy_deleteRows_presult {
  public:
 
 
-  virtual ~AccumuloProxy_deleteRows_presult() throw() {}
-
+  virtual ~AccumuloProxy_deleteRows_presult() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
@@ -2195,36 +2043,31 @@ class AccumuloProxy_deleteRows_presult {
 
 typedef struct _AccumuloProxy_exportTable_args__isset {
   _AccumuloProxy_exportTable_args__isset() : login(false), tableName(false), exportDir(false) {}
-  bool login;
-  bool tableName;
-  bool exportDir;
+  bool login :1;
+  bool tableName :1;
+  bool exportDir :1;
 } _AccumuloProxy_exportTable_args__isset;
 
 class AccumuloProxy_exportTable_args {
  public:
 
+  AccumuloProxy_exportTable_args(const AccumuloProxy_exportTable_args&);
+  AccumuloProxy_exportTable_args& operator=(const AccumuloProxy_exportTable_args&);
   AccumuloProxy_exportTable_args() : login(), tableName(), exportDir() {
   }
 
-  virtual ~AccumuloProxy_exportTable_args() throw() {}
-
+  virtual ~AccumuloProxy_exportTable_args() throw();
   std::string login;
   std::string tableName;
   std::string exportDir;
 
   _AccumuloProxy_exportTable_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_exportDir(const std::string& val) {
-    exportDir = val;
-  }
+  void __set_exportDir(const std::string& val);
 
   bool operator == (const AccumuloProxy_exportTable_args & rhs) const
   {
@@ -2252,8 +2095,7 @@ class AccumuloProxy_exportTable_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_exportTable_pargs() throw() {}
-
+  virtual ~AccumuloProxy_exportTable_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const std::string* exportDir;
@@ -2264,36 +2106,31 @@ class AccumuloProxy_exportTable_pargs {
 
 typedef struct _AccumuloProxy_exportTable_result__isset {
   _AccumuloProxy_exportTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_exportTable_result__isset;
 
 class AccumuloProxy_exportTable_result {
  public:
 
+  AccumuloProxy_exportTable_result(const AccumuloProxy_exportTable_result&);
+  AccumuloProxy_exportTable_result& operator=(const AccumuloProxy_exportTable_result&);
   AccumuloProxy_exportTable_result() {
   }
 
-  virtual ~AccumuloProxy_exportTable_result() throw() {}
-
+  virtual ~AccumuloProxy_exportTable_result() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
 
   _AccumuloProxy_exportTable_result__isset __isset;
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_exportTable_result & rhs) const
   {
@@ -2318,17 +2155,16 @@ class AccumuloProxy_exportTable_result {
 
 typedef struct _AccumuloProxy_exportTable_presult__isset {
   _AccumuloProxy_exportTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_exportTable_presult__isset;
 
 class AccumuloProxy_exportTable_presult {
  public:
 
 
-  virtual ~AccumuloProxy_exportTable_presult() throw() {}
-
+  virtual ~AccumuloProxy_exportTable_presult() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
@@ -2341,21 +2177,22 @@ class AccumuloProxy_exportTable_presult {
 
 typedef struct _AccumuloProxy_flushTable_args__isset {
   _AccumuloProxy_flushTable_args__isset() : login(false), tableName(false), startRow(false), endRow(false), wait(false) {}
-  bool login;
-  bool tableName;
-  bool startRow;
-  bool endRow;
-  bool wait;
+  bool login :1;
+  bool tableName :1;
+  bool startRow :1;
+  bool endRow :1;
+  bool wait :1;
 } _AccumuloProxy_flushTable_args__isset;
 
 class AccumuloProxy_flushTable_args {
  public:
 
+  AccumuloProxy_flushTable_args(const AccumuloProxy_flushTable_args&);
+  AccumuloProxy_flushTable_args& operator=(const AccumuloProxy_flushTable_args&);
   AccumuloProxy_flushTable_args() : login(), tableName(), startRow(), endRow(), wait(0) {
   }
 
-  virtual ~AccumuloProxy_flushTable_args() throw() {}
-
+  virtual ~AccumuloProxy_flushTable_args() throw();
   std::string login;
   std::string tableName;
   std::string startRow;
@@ -2364,25 +2201,15 @@ class AccumuloProxy_flushTable_args {
 
   _AccumuloProxy_flushTable_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_startRow(const std::string& val) {
-    startRow = val;
-  }
+  void __set_startRow(const std::string& val);
 
-  void __set_endRow(const std::string& val) {
-    endRow = val;
-  }
+  void __set_endRow(const std::string& val);
 
-  void __set_wait(const bool val) {
-    wait = val;
-  }
+  void __set_wait(const bool val);
 
   bool operator == (const AccumuloProxy_flushTable_args & rhs) const
   {
@@ -2414,8 +2241,7 @@ class AccumuloProxy_flushTable_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_flushTable_pargs() throw() {}
-
+  virtual ~AccumuloProxy_flushTable_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const std::string* startRow;
@@ -2428,36 +2254,31 @@ class AccumuloProxy_flushTable_pargs {
 
 typedef struct _AccumuloProxy_flushTable_result__isset {
   _AccumuloProxy_flushTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_flushTable_result__isset;
 
 class AccumuloProxy_flushTable_result {
  public:
 
+  AccumuloProxy_flushTable_result(const AccumuloProxy_flushTable_result&);
+  AccumuloProxy_flushTable_result& operator=(const AccumuloProxy_flushTable_result&);
   AccumuloProxy_flushTable_result() {
   }
 
-  virtual ~AccumuloProxy_flushTable_result() throw() {}
-
+  virtual ~AccumuloProxy_flushTable_result() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
 
   _AccumuloProxy_flushTable_result__isset __isset;
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_flushTable_result & rhs) const
   {
@@ -2482,17 +2303,16 @@ class AccumuloProxy_flushTable_result {
 
 typedef struct _AccumuloProxy_flushTable_presult__isset {
   _AccumuloProxy_flushTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_flushTable_presult__isset;
 
 class AccumuloProxy_flushTable_presult {
  public:
 
 
-  virtual ~AccumuloProxy_flushTable_presult() throw() {}
-
+  virtual ~AccumuloProxy_flushTable_presult() throw();
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
   TableNotFoundException ouch3;
@@ -2505,30 +2325,27 @@ class AccumuloProxy_flushTable_presult {
 
 typedef struct _AccumuloProxy_getDiskUsage_args__isset {
   _AccumuloProxy_getDiskUsage_args__isset() : login(false), tables(false) {}
-  bool login;
-  bool tables;
+  bool login :1;
+  bool tables :1;
 } _AccumuloProxy_getDiskUsage_args__isset;
 
 class AccumuloProxy_getDiskUsage_args {
  public:
 
+  AccumuloProxy_getDiskUsage_args(const AccumuloProxy_getDiskUsage_args&);
+  AccumuloProxy_getDiskUsage_args& operator=(const AccumuloProxy_getDiskUsage_args&);
   AccumuloProxy_getDiskUsage_args() : login() {
   }
 
-  virtual ~AccumuloProxy_getDiskUsage_args() throw() {}
-
+  virtual ~AccumuloProxy_getDiskUsage_args() throw();
   std::string login;
   std::set<std::string>  tables;
 
   _AccumuloProxy_getDiskUsage_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tables(const std::set<std::string> & val) {
-    tables = val;
-  }
+  void __set_tables(const std::set<std::string> & val);
 
   bool operator == (const AccumuloProxy_getDiskUsage_args & rhs) const
   {
@@ -2554,8 +2371,7 @@ class AccumuloProxy_getDiskUsage_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_getDiskUsage_pargs() throw() {}
-
+  virtual ~AccumuloProxy_getDiskUsage_pargs() throw();
   const std::string* login;
   const std::set<std::string> * tables;
 
@@ -2565,20 +2381,21 @@ class AccumuloProxy_getDiskUsage_pargs {
 
 typedef struct _AccumuloProxy_getDiskUsage_result__isset {
   _AccumuloProxy_getDiskUsage_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_getDiskUsage_result__isset;
 
 class AccumuloProxy_getDiskUsage_result {
  public:
 
+  AccumuloProxy_getDiskUsage_result(const AccumuloProxy_getDiskUsage_result&);
+  AccumuloProxy_getDiskUsage_result& operator=(const AccumuloProxy_getDiskUsage_result&);
   AccumuloProxy_getDiskUsage_result() {
   }
 
-  virtual ~AccumuloProxy_getDiskUsage_result() throw() {}
-
+  virtual ~AccumuloProxy_getDiskUsage_result() throw();
   std::vector<DiskUsage>  success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -2586,21 +2403,13 @@ class AccumuloProxy_getDiskUsage_result {
 
   _AccumuloProxy_getDiskUsage_result__isset __isset;
 
-  void __set_success(const std::vector<DiskUsage> & val) {
-    success = val;
-  }
+  void __set_success(const std::vector<DiskUsage> & val);
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_getDiskUsage_result & rhs) const
   {
@@ -2627,18 +2436,17 @@ class AccumuloProxy_getDiskUsage_result {
 
 typedef struct _AccumuloProxy_getDiskUsage_presult__isset {
   _AccumuloProxy_getDiskUsage_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_getDiskUsage_presult__isset;
 
 class AccumuloProxy_getDiskUsage_presult {
  public:
 
 
-  virtual ~AccumuloProxy_getDiskUsage_presult() throw() {}
-
+  virtual ~AccumuloProxy_getDiskUsage_presult() throw();
   std::vector<DiskUsage> * success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -2652,30 +2460,27 @@ class AccumuloProxy_getDiskUsage_presult {
 
 typedef struct _AccumuloProxy_getLocalityGroups_args__isset {
   _AccumuloProxy_getLocalityGroups_args__isset() : login(false), tableName(false) {}
-  bool login;
-  bool tableName;
+  bool login :1;
+  bool tableName :1;
 } _AccumuloProxy_getLocalityGroups_args__isset;
 
 class AccumuloProxy_getLocalityGroups_args {
  public:
 
+  AccumuloProxy_getLocalityGroups_args(const AccumuloProxy_getLocalityGroups_args&);
+  AccumuloProxy_getLocalityGroups_args& operator=(const AccumuloProxy_getLocalityGroups_args&);
   AccumuloProxy_getLocalityGroups_args() : login(), tableName() {
   }
 
-  virtual ~AccumuloProxy_getLocalityGroups_args() throw() {}
-
+  virtual ~AccumuloProxy_getLocalityGroups_args() throw();
   std::string login;
   std::string tableName;
 
   _AccumuloProxy_getLocalityGroups_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
   bool operator == (const AccumuloProxy_getLocalityGroups_args & rhs) const
   {
@@ -2701,8 +2506,7 @@ class AccumuloProxy_getLocalityGroups_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_getLocalityGroups_pargs() throw() {}
-
+  virtual ~AccumuloProxy_getLocalityGroups_pargs() throw();
   const std::string* login;
   const std::string* tableName;
 
@@ -2712,20 +2516,21 @@ class AccumuloProxy_getLocalityGroups_pargs {
 
 typedef struct _AccumuloProxy_getLocalityGroups_result__isset {
   _AccumuloProxy_getLocalityGroups_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_getLocalityGroups_result__isset;
 
 class AccumuloProxy_getLocalityGroups_result {
  public:
 
+  AccumuloProxy_getLocalityGroups_result(const AccumuloProxy_getLocalityGroups_result&);
+  AccumuloProxy_getLocalityGroups_result& operator=(const AccumuloProxy_getLocalityGroups_result&);
   AccumuloProxy_getLocalityGroups_result() {
   }
 
-  virtual ~AccumuloProxy_getLocalityGroups_result() throw() {}
-
+  virtual ~AccumuloProxy_getLocalityGroups_result() throw();
   std::map<std::string, std::set<std::string> >  success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -2733,21 +2538,13 @@ class AccumuloProxy_getLocalityGroups_result {
 
   _AccumuloProxy_getLocalityGroups_result__isset __isset;
 
-  void __set_success(const std::map<std::string, std::set<std::string> > & val) {
-    success = val;
-  }
+  void __set_success(const std::map<std::string, std::set<std::string> > & val);
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_getLocalityGroups_result & rhs) const
   {
@@ -2774,18 +2571,17 @@ class AccumuloProxy_getLocalityGroups_result {
 
 typedef struct _AccumuloProxy_getLocalityGroups_presult__isset {
   _AccumuloProxy_getLocalityGroups_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_getLocalityGroups_presult__isset;
 
 class AccumuloProxy_getLocalityGroups_presult {
  public:
 
 
-  virtual ~AccumuloProxy_getLocalityGroups_presult() throw() {}
-
+  virtual ~AccumuloProxy_getLocalityGroups_presult() throw();
   std::map<std::string, std::set<std::string> > * success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -2799,20 +2595,21 @@ class AccumuloProxy_getLocalityGroups_presult {
 
 typedef struct _AccumuloProxy_getIteratorSetting_args__isset {
   _AccumuloProxy_getIteratorSetting_args__isset() : login(false), tableName(false), iteratorName(false), scope(false) {}
-  bool login;
-  bool tableName;
-  bool iteratorName;
-  bool scope;
+  bool login :1;
+  bool tableName :1;
+  bool iteratorName :1;
+  bool scope :1;
 } _AccumuloProxy_getIteratorSetting_args__isset;
 
 class AccumuloProxy_getIteratorSetting_args {
  public:
 
+  AccumuloProxy_getIteratorSetting_args(const AccumuloProxy_getIteratorSetting_args&);
+  AccumuloProxy_getIteratorSetting_args& operator=(const AccumuloProxy_getIteratorSetting_args&);
   AccumuloProxy_getIteratorSetting_args() : login(), tableName(), iteratorName(), scope((IteratorScope::type)0) {
   }
 
-  virtual ~AccumuloProxy_getIteratorSetting_args() throw() {}
-
+  virtual ~AccumuloProxy_getIteratorSetting_args() throw();
   std::string login;
   std::string tableName;
   std::string iteratorName;
@@ -2820,21 +2617,13 @@ class AccumuloProxy_getIteratorSetting_args {
 
   _AccumuloProxy_getIteratorSetting_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_iteratorName(const std::string& val) {
-    iteratorName = val;
-  }
+  void __set_iteratorName(const std::string& val);
 
-  void __set_scope(const IteratorScope::type val) {
-    scope = val;
-  }
+  void __set_scope(const IteratorScope::type val);
 
   bool operator == (const AccumuloProxy_getIteratorSetting_args & rhs) const
   {
@@ -2864,8 +2653,7 @@ class AccumuloProxy_getIteratorSetting_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_getIteratorSetting_pargs() throw() {}
-
+  virtual ~AccumuloProxy_getIteratorSetting_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const std::string* iteratorName;
@@ -2877,20 +2665,21 @@ class AccumuloProxy_getIteratorSetting_pargs {
 
 typedef struct _AccumuloProxy_getIteratorSetting_result__isset {
   _AccumuloProxy_getIteratorSetting_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_getIteratorSetting_result__isset;
 
 class AccumuloProxy_getIteratorSetting_result {
  public:
 
+  AccumuloProxy_getIteratorSetting_result(const AccumuloProxy_getIteratorSetting_result&);
+  AccumuloProxy_getIteratorSetting_result& operator=(const AccumuloProxy_getIteratorSetting_result&);
   AccumuloProxy_getIteratorSetting_result() {
   }
 
-  virtual ~AccumuloProxy_getIteratorSetting_result() throw() {}
-
+  virtual ~AccumuloProxy_getIteratorSetting_result() throw();
   IteratorSetting success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -2898,21 +2687,13 @@ class AccumuloProxy_getIteratorSetting_result {
 
   _AccumuloProxy_getIteratorSetting_result__isset __isset;
 
-  void __set_success(const IteratorSetting& val) {
-    success = val;
-  }
+  void __set_success(const IteratorSetting& val);
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_getIteratorSetting_result & rhs) const
   {
@@ -2939,18 +2720,17 @@ class AccumuloProxy_getIteratorSetting_result {
 
 typedef struct _AccumuloProxy_getIteratorSetting_presult__isset {
   _AccumuloProxy_getIteratorSetting_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_getIteratorSetting_presult__isset;
 
 class AccumuloProxy_getIteratorSetting_presult {
  public:
 
 
-  virtual ~AccumuloProxy_getIteratorSetting_presult() throw() {}
-
+  virtual ~AccumuloProxy_getIteratorSetting_presult() throw();
   IteratorSetting* success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -2964,23 +2744,24 @@ class AccumuloProxy_getIteratorSetting_presult {
 
 typedef struct _AccumuloProxy_getMaxRow_args__isset {
   _AccumuloProxy_getMaxRow_args__isset() : login(false), tableName(false), auths(false), startRow(false), startInclusive(false), endRow(false), endInclusive(false) {}
-  bool login;
-  bool tableName;
-  bool auths;
-  bool startRow;
-  bool startInclusive;
-  bool endRow;
-  bool endInclusive;
+  bool login :1;
+  bool tableName :1;
+  bool auths :1;
+  bool startRow :1;
+  bool startInclusive :1;
+  bool endRow :1;
+  bool endInclusive :1;
 } _AccumuloProxy_getMaxRow_args__isset;
 
 class AccumuloProxy_getMaxRow_args {
  public:
 
+  AccumuloProxy_getMaxRow_args(const AccumuloProxy_getMaxRow_args&);
+  AccumuloProxy_getMaxRow_args& operator=(const AccumuloProxy_getMaxRow_args&);
   AccumuloProxy_getMaxRow_args() : login(), tableName(), startRow(), startInclusive(0), endRow(), endInclusive(0) {
   }
 
-  virtual ~AccumuloProxy_getMaxRow_args() throw() {}
-
+  virtual ~AccumuloProxy_getMaxRow_args() throw();
   std::string login;
   std::string tableName;
   std::set<std::string>  auths;
@@ -2991,33 +2772,19 @@ class AccumuloProxy_getMaxRow_args {
 
   _AccumuloProxy_getMaxRow_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_auths(const std::set<std::string> & val) {
-    auths = val;
-  }
+  void __set_auths(const std::set<std::string> & val);
 
-  void __set_startRow(const std::string& val) {
-    startRow = val;
-  }
+  void __set_startRow(const std::string& val);
 
-  void __set_startInclusive(const bool val) {
-    startInclusive = val;
-  }
+  void __set_startInclusive(const bool val);
 
-  void __set_endRow(const std::string& val) {
-    endRow = val;
-  }
+  void __set_endRow(const std::string& val);
 
-  void __set_endInclusive(const bool val) {
-    endInclusive = val;
-  }
+  void __set_endInclusive(const bool val);
 
   bool operator == (const AccumuloProxy_getMaxRow_args & rhs) const
   {
@@ -3053,8 +2820,7 @@ class AccumuloProxy_getMaxRow_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_getMaxRow_pargs() throw() {}
-
+  virtual ~AccumuloProxy_getMaxRow_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const std::set<std::string> * auths;
@@ -3069,20 +2835,21 @@ class AccumuloProxy_getMaxRow_pargs {
 
 typedef struct _AccumuloProxy_getMaxRow_result__isset {
   _AccumuloProxy_getMaxRow_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_getMaxRow_result__isset;
 
 class AccumuloProxy_getMaxRow_result {
  public:
 
+  AccumuloProxy_getMaxRow_result(const AccumuloProxy_getMaxRow_result&);
+  AccumuloProxy_getMaxRow_result& operator=(const AccumuloProxy_getMaxRow_result&);
   AccumuloProxy_getMaxRow_result() : success() {
   }
 
-  virtual ~AccumuloProxy_getMaxRow_result() throw() {}
-
+  virtual ~AccumuloProxy_getMaxRow_result() throw();
   std::string success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -3090,21 +2857,13 @@ class AccumuloProxy_getMaxRow_result {
 
   _AccumuloProxy_getMaxRow_result__isset __isset;
 
-  void __set_success(const std::string& val) {
-    success = val;
-  }
+  void __set_success(const std::string& val);
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_getMaxRow_result & rhs) const
   {
@@ -3131,18 +2890,17 @@ class AccumuloProxy_getMaxRow_result {
 
 typedef struct _AccumuloProxy_getMaxRow_presult__isset {
   _AccumuloProxy_getMaxRow_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_getMaxRow_presult__isset;
 
 class AccumuloProxy_getMaxRow_presult {
  public:
 
 
-  virtual ~AccumuloProxy_getMaxRow_presult() throw() {}
-
+  virtual ~AccumuloProxy_getMaxRow_presult() throw();
   std::string* success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -3156,30 +2914,27 @@ class AccumuloProxy_getMaxRow_presult {
 
 typedef struct _AccumuloProxy_getTableProperties_args__isset {
   _AccumuloProxy_getTableProperties_args__isset() : login(false), tableName(false) {}
-  bool login;
-  bool tableName;
+  bool login :1;
+  bool tableName :1;
 } _AccumuloProxy_getTableProperties_args__isset;
 
 class AccumuloProxy_getTableProperties_args {
  public:
 
+  AccumuloProxy_getTableProperties_args(const AccumuloProxy_getTableProperties_args&);
+  AccumuloProxy_getTableProperties_args& operator=(const AccumuloProxy_getTableProperties_args&);
   AccumuloProxy_getTableProperties_args() : login(), tableName() {
   }
 
-  virtual ~AccumuloProxy_getTableProperties_args() throw() {}
-
+  virtual ~AccumuloProxy_getTableProperties_args() throw();
   std::string login;
   std::string tableName;
 
   _AccumuloProxy_getTableProperties_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
   bool operator == (const AccumuloProxy_getTableProperties_args & rhs) const
   {
@@ -3205,8 +2960,7 @@ class AccumuloProxy_getTableProperties_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_getTableProperties_pargs() throw() {}
-
+  virtual ~AccumuloProxy_getTableProperties_pargs() throw();
   const std::string* login;
   const std::string* tableName;
 
@@ -3216,20 +2970,21 @@ class AccumuloProxy_getTableProperties_pargs {
 
 typedef struct _AccumuloProxy_getTableProperties_result__isset {
   _AccumuloProxy_getTableProperties_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_getTableProperties_result__isset;
 
 class AccumuloProxy_getTableProperties_result {
  public:
 
+  AccumuloProxy_getTableProperties_result(const AccumuloProxy_getTableProperties_result&);
+  AccumuloProxy_getTableProperties_result& operator=(const AccumuloProxy_getTableProperties_result&);
   AccumuloProxy_getTableProperties_result() {
   }
 
-  virtual ~AccumuloProxy_getTableProperties_result() throw() {}
-
+  virtual ~AccumuloProxy_getTableProperties_result() throw();
   std::map<std::string, std::string>  success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -3237,21 +2992,13 @@ class AccumuloProxy_getTableProperties_result {
 
   _AccumuloProxy_getTableProperties_result__isset __isset;
 
-  void __set_success(const std::map<std::string, std::string> & val) {
-    success = val;
-  }
+  void __set_success(const std::map<std::string, std::string> & val);
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_getTableProperties_result & rhs) const
   {
@@ -3278,18 +3025,17 @@ class AccumuloProxy_getTableProperties_result {
 
 typedef struct _AccumuloProxy_getTableProperties_presult__isset {
   _AccumuloProxy_getTableProperties_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_getTableProperties_presult__isset;
 
 class AccumuloProxy_getTableProperties_presult {
  public:
 
 
-  virtual ~AccumuloProxy_getTableProperties_presult() throw() {}
-
+  virtual ~AccumuloProxy_getTableProperties_presult() throw();
   std::map<std::string, std::string> * success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -3303,21 +3049,22 @@ class AccumuloProxy_getTableProperties_presult {
 
 typedef struct _AccumuloProxy_importDirectory_args__isset {
   _AccumuloProxy_importDirectory_args__isset() : login(false), tableName(false), importDir(false), failureDir(false), setTime(false) {}
-  bool login;
-  bool tableName;
-  bool importDir;
-  bool failureDir;
-  bool setTime;
+  bool login :1;
+  bool tableName :1;
+  bool importDir :1;
+  bool failureDir :1;
+  bool setTime :1;
 } _AccumuloProxy_importDirectory_args__isset;
 
 class AccumuloProxy_importDirectory_args {
  public:
 
+  AccumuloProxy_importDirectory_args(const AccumuloProxy_importDirectory_args&);
+  AccumuloProxy_importDirectory_args& operator=(const AccumuloProxy_importDirectory_args&);
   AccumuloProxy_importDirectory_args() : login(), tableName(), importDir(), failureDir(), setTime(0) {
   }
 
-  virtual ~AccumuloProxy_importDirectory_args() throw() {}
-
+  virtual ~AccumuloProxy_importDirectory_args() throw();
   std::string login;
   std::string tableName;
   std::string importDir;
@@ -3326,25 +3073,15 @@ class AccumuloProxy_importDirectory_args {
 
   _AccumuloProxy_importDirectory_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_importDir(const std::string& val) {
-    importDir = val;
-  }
+  void __set_importDir(const std::string& val);
 
-  void __set_failureDir(const std::string& val) {
-    failureDir = val;
-  }
+  void __set_failureDir(const std::string& val);
 
-  void __set_setTime(const bool val) {
-    setTime = val;
-  }
+  void __set_setTime(const bool val);
 
   bool operator == (const AccumuloProxy_importDirectory_args & rhs) const
   {
@@ -3376,8 +3113,7 @@ class AccumuloProxy_importDirectory_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_importDirectory_pargs() throw() {}
-
+  virtual ~AccumuloProxy_importDirectory_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const std::string* importDir;
@@ -3390,36 +3126,31 @@ class AccumuloProxy_importDirectory_pargs {
 
 typedef struct _AccumuloProxy_importDirectory_result__isset {
   _AccumuloProxy_importDirectory_result__isset() : ouch1(false), ouch3(false), ouch4(false) {}
-  bool ouch1;
-  bool ouch3;
-  bool ouch4;
+  bool ouch1 :1;
+  bool ouch3 :1;
+  bool ouch4 :1;
 } _AccumuloProxy_importDirectory_result__isset;
 
 class AccumuloProxy_importDirectory_result {
  public:
 
+  AccumuloProxy_importDirectory_result(const AccumuloProxy_importDirectory_result&);
+  AccumuloProxy_importDirectory_result& operator=(const AccumuloProxy_importDirectory_result&);
   AccumuloProxy_importDirectory_result() {
   }
 
-  virtual ~AccumuloProxy_importDirectory_result() throw() {}
-
+  virtual ~AccumuloProxy_importDirectory_result() throw();
   TableNotFoundException ouch1;
   AccumuloException ouch3;
   AccumuloSecurityException ouch4;
 
   _AccumuloProxy_importDirectory_result__isset __isset;
 
-  void __set_ouch1(const TableNotFoundException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const TableNotFoundException& val);
 
-  void __set_ouch3(const AccumuloException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const AccumuloException& val);
 
-  void __set_ouch4(const AccumuloSecurityException& val) {
-    ouch4 = val;
-  }
+  void __set_ouch4(const AccumuloSecurityException& val);
 
   bool operator == (const AccumuloProxy_importDirectory_result & rhs) const
   {
@@ -3444,17 +3175,16 @@ class AccumuloProxy_importDirectory_result {
 
 typedef struct _AccumuloProxy_importDirectory_presult__isset {
   _AccumuloProxy_importDirectory_presult__isset() : ouch1(false), ouch3(false), ouch4(false) {}
-  bool ouch1;
-  bool ouch3;
-  bool ouch4;
+  bool ouch1 :1;
+  bool ouch3 :1;
+  bool ouch4 :1;
 } _AccumuloProxy_importDirectory_presult__isset;
 
 class AccumuloProxy_importDirectory_presult {
  public:
 
 
-  virtual ~AccumuloProxy_importDirectory_presult() throw() {}
-
+  virtual ~AccumuloProxy_importDirectory_presult() throw();
   TableNotFoundException ouch1;
   AccumuloException ouch3;
   AccumuloSecurityException ouch4;
@@ -3467,36 +3197,31 @@ class AccumuloProxy_importDirectory_presult {
 
 typedef struct _AccumuloProxy_importTable_args__isset {
   _AccumuloProxy_importTable_args__isset() : login(false), tableName(false), importDir(false) {}
-  bool login;
-  bool tableName;
-  bool importDir;
+  bool login :1;
+  bool tableName :1;
+  bool importDir :1;
 } _AccumuloProxy_importTable_args__isset;
 
 class AccumuloProxy_importTable_args {
  public:
 
+  AccumuloProxy_importTable_args(const AccumuloProxy_importTable_args&);
+  AccumuloProxy_importTable_args& operator=(const AccumuloProxy_importTable_args&);
   AccumuloProxy_importTable_args() : login(), tableName(), importDir() {
   }
 
-  virtual ~AccumuloProxy_importTable_args() throw() {}
-
+  virtual ~AccumuloProxy_importTable_args() throw();
   std::string login;
   std::string tableName;
   std::string importDir;
 
   _AccumuloProxy_importTable_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_importDir(const std::string& val) {
-    importDir = val;
-  }
+  void __set_importDir(const std::string& val);
 
   bool operator == (const AccumuloProxy_importTable_args & rhs) const
   {
@@ -3524,8 +3249,7 @@ class AccumuloProxy_importTable_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_importTable_pargs() throw() {}
-
+  virtual ~AccumuloProxy_importTable_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const std::string* importDir;
@@ -3536,36 +3260,31 @@ class AccumuloProxy_importTable_pargs {
 
 typedef struct _AccumuloProxy_importTable_result__isset {
   _AccumuloProxy_importTable_result__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_importTable_result__isset;
 
 class AccumuloProxy_importTable_result {
  public:
 
+  AccumuloProxy_importTable_result(const AccumuloProxy_importTable_result&);
+  AccumuloProxy_importTable_result& operator=(const AccumuloProxy_importTable_result&);
   AccumuloProxy_importTable_result() {
   }
 
-  virtual ~AccumuloProxy_importTable_result() throw() {}
-
+  virtual ~AccumuloProxy_importTable_result() throw();
   TableExistsException ouch1;
   AccumuloException ouch2;
   AccumuloSecurityException ouch3;
 
   _AccumuloProxy_importTable_result__isset __isset;
 
-  void __set_ouch1(const TableExistsException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const TableExistsException& val);
 
-  void __set_ouch2(const AccumuloException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloException& val);
 
-  void __set_ouch3(const AccumuloSecurityException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const AccumuloSecurityException& val);
 
   bool operator == (const AccumuloProxy_importTable_result & rhs) const
   {
@@ -3590,17 +3309,16 @@ class AccumuloProxy_importTable_result {
 
 typedef struct _AccumuloProxy_importTable_presult__isset {
   _AccumuloProxy_importTable_presult__isset() : ouch1(false), ouch2(false), ouch3(false) {}
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_importTable_presult__isset;
 
 class AccumuloProxy_importTable_presult {
  public:
 
 
-  virtual ~AccumuloProxy_importTable_presult() throw() {}
-
+  virtual ~AccumuloProxy_importTable_presult() throw();
   TableExistsException ouch1;
   AccumuloException ouch2;
   AccumuloSecurityException ouch3;
@@ -3613,36 +3331,31 @@ class AccumuloProxy_importTable_presult {
 
 typedef struct _AccumuloProxy_listSplits_args__isset {
   _AccumuloProxy_listSplits_args__isset() : login(false), tableName(false), maxSplits(false) {}
-  bool login;
-  bool tableName;
-  bool maxSplits;
+  bool login :1;
+  bool tableName :1;
+  bool maxSplits :1;
 } _AccumuloProxy_listSplits_args__isset;
 
 class AccumuloProxy_listSplits_args {
  public:
 
+  AccumuloProxy_listSplits_args(const AccumuloProxy_listSplits_args&);
+  AccumuloProxy_listSplits_args& operator=(const AccumuloProxy_listSplits_args&);
   AccumuloProxy_listSplits_args() : login(), tableName(), maxSplits(0) {
   }
 
-  virtual ~AccumuloProxy_listSplits_args() throw() {}
-
+  virtual ~AccumuloProxy_listSplits_args() throw();
   std::string login;
   std::string tableName;
   int32_t maxSplits;
 
   _AccumuloProxy_listSplits_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
-  void __set_tableName(const std::string& val) {
-    tableName = val;
-  }
+  void __set_tableName(const std::string& val);
 
-  void __set_maxSplits(const int32_t val) {
-    maxSplits = val;
-  }
+  void __set_maxSplits(const int32_t val);
 
   bool operator == (const AccumuloProxy_listSplits_args & rhs) const
   {
@@ -3670,8 +3383,7 @@ class AccumuloProxy_listSplits_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_listSplits_pargs() throw() {}
-
+  virtual ~AccumuloProxy_listSplits_pargs() throw();
   const std::string* login;
   const std::string* tableName;
   const int32_t* maxSplits;
@@ -3682,20 +3394,21 @@ class AccumuloProxy_listSplits_pargs {
 
 typedef struct _AccumuloProxy_listSplits_result__isset {
   _AccumuloProxy_listSplits_result__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_listSplits_result__isset;
 
 class AccumuloProxy_listSplits_result {
  public:
 
+  AccumuloProxy_listSplits_result(const AccumuloProxy_listSplits_result&);
+  AccumuloProxy_listSplits_result& operator=(const AccumuloProxy_listSplits_result&);
   AccumuloProxy_listSplits_result() {
   }
 
-  virtual ~AccumuloProxy_listSplits_result() throw() {}
-
+  virtual ~AccumuloProxy_listSplits_result() throw();
   std::vector<std::string>  success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -3703,21 +3416,13 @@ class AccumuloProxy_listSplits_result {
 
   _AccumuloProxy_listSplits_result__isset __isset;
 
-  void __set_success(const std::vector<std::string> & val) {
-    success = val;
-  }
+  void __set_success(const std::vector<std::string> & val);
 
-  void __set_ouch1(const AccumuloException& val) {
-    ouch1 = val;
-  }
+  void __set_ouch1(const AccumuloException& val);
 
-  void __set_ouch2(const AccumuloSecurityException& val) {
-    ouch2 = val;
-  }
+  void __set_ouch2(const AccumuloSecurityException& val);
 
-  void __set_ouch3(const TableNotFoundException& val) {
-    ouch3 = val;
-  }
+  void __set_ouch3(const TableNotFoundException& val);
 
   bool operator == (const AccumuloProxy_listSplits_result & rhs) const
   {
@@ -3744,18 +3449,17 @@ class AccumuloProxy_listSplits_result {
 
 typedef struct _AccumuloProxy_listSplits_presult__isset {
   _AccumuloProxy_listSplits_presult__isset() : success(false), ouch1(false), ouch2(false), ouch3(false) {}
-  bool success;
-  bool ouch1;
-  bool ouch2;
-  bool ouch3;
+  bool success :1;
+  bool ouch1 :1;
+  bool ouch2 :1;
+  bool ouch3 :1;
 } _AccumuloProxy_listSplits_presult__isset;
 
 class AccumuloProxy_listSplits_presult {
  public:
 
 
-  virtual ~AccumuloProxy_listSplits_presult() throw() {}
-
+  virtual ~AccumuloProxy_listSplits_presult() throw();
   std::vector<std::string> * success;
   AccumuloException ouch1;
   AccumuloSecurityException ouch2;
@@ -3769,24 +3473,23 @@ class AccumuloProxy_listSplits_presult {
 
 typedef struct _AccumuloProxy_listTables_args__isset {
   _AccumuloProxy_listTables_args__isset() : login(false) {}
-  bool login;
+  bool login :1;
 } _AccumuloProxy_listTables_args__isset;
 
 class AccumuloProxy_listTables_args {
  public:
 
+  AccumuloProxy_listTables_args(const AccumuloProxy_listTables_args&);
+  AccumuloProxy_listTables_args& operator=(const AccumuloProxy_listTables_args&);
   AccumuloProxy_listTables_args() : login() {
   }
 
-  virtual ~AccumuloProxy_listTables_args() throw() {}
-
+  virtual ~AccumuloProxy_listTables_args() throw();
   std::string login;
 
   _AccumuloProxy_listTables_args__isset __isset;
 
-  void __set_login(const std::string& val) {
-    login = val;
-  }
+  void __set_login(const std::string& val);
 
   bool operator == (const AccumuloProxy_listTables_args & rhs) const
   {
@@ -3810,8 +3513,7 @@ class AccumuloProxy_listTables_pargs {
  public:
 
 
-  virtual ~AccumuloProxy_listTables_pargs() throw() {}
-
+  virtual ~AccumuloProxy_listTables_pargs() t

<TRUNCATED>

Mime
View raw message