[11/29] ACCUMULO-2197 provide generated proxy libraries, with modified generate-thrift script which tacks on headers

[el...@apache.org]

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

<TRUNCATED>