hbase-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From st...@apache.org
Subject svn commit: r1406339 [3/17] - in /hbase/trunk: ./ examples/ hbase-examples/ hbase-examples/src/ hbase-examples/src/main/ hbase-examples/src/main/cpp/ hbase-examples/src/main/cpp/gen-cpp/ hbase-examples/src/main/java/ hbase-examples/src/main/java/org/ h...
Date Tue, 06 Nov 2012 21:22:30 GMT
Added: hbase/trunk/hbase-examples/src/main/cpp/gen-cpp/Hbase.h
URL: http://svn.apache.org/viewvc/hbase/trunk/hbase-examples/src/main/cpp/gen-cpp/Hbase.h?rev=1406339&view=auto
==============================================================================
--- hbase/trunk/hbase-examples/src/main/cpp/gen-cpp/Hbase.h (added)
+++ hbase/trunk/hbase-examples/src/main/cpp/gen-cpp/Hbase.h Tue Nov  6 21:22:27 2012
@@ -0,0 +1,6701 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef Hbase_H
+#define Hbase_H
+
+#include <thrift/TDispatchProcessor.h>
+#include "Hbase_types.h"
+
+namespace apache { namespace hadoop { namespace hbase { namespace thrift {
+
+class HbaseIf {
+ public:
+  virtual ~HbaseIf() {}
+  virtual void enableTable(const Bytes& tableName) = 0;
+  virtual void disableTable(const Bytes& tableName) = 0;
+  virtual bool isTableEnabled(const Bytes& tableName) = 0;
+  virtual void compact(const Bytes& tableNameOrRegionName) = 0;
+  virtual void majorCompact(const Bytes& tableNameOrRegionName) = 0;
+  virtual void getTableNames(std::vector<Text> & _return) = 0;
+  virtual void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName) = 0;
+  virtual void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName) = 0;
+  virtual void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies) = 0;
+  virtual void deleteTable(const Text& tableName) = 0;
+  virtual void get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes) = 0;
+  virtual void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes) = 0;
+  virtual void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes) = 0;
+  virtual void getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::map<Text, Text> & attributes) = 0;
+  virtual void getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
+  virtual void getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
+  virtual void getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
+  virtual void getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes) = 0;
+  virtual void getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
+  virtual void getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
+  virtual void getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
+  virtual void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes) = 0;
+  virtual void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
+  virtual void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes) = 0;
+  virtual void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
+  virtual int64_t atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value) = 0;
+  virtual void deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes) = 0;
+  virtual void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
+  virtual void deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes) = 0;
+  virtual void increment(const TIncrement& increment) = 0;
+  virtual void incrementRows(const std::vector<TIncrement> & increments) = 0;
+  virtual void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
+  virtual ScannerID scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes) = 0;
+  virtual ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
+  virtual ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
+  virtual ScannerID scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
+  virtual ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
+  virtual ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
+  virtual void scannerGet(std::vector<TRowResult> & _return, const ScannerID id) = 0;
+  virtual void scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows) = 0;
+  virtual void scannerClose(const ScannerID id) = 0;
+  virtual void getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family) = 0;
+  virtual void getRegionInfo(TRegionInfo& _return, const Text& row) = 0;
+};
+
+class HbaseIfFactory {
+ public:
+  typedef HbaseIf Handler;
+
+  virtual ~HbaseIfFactory() {}
+
+  virtual HbaseIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
+  virtual void releaseHandler(HbaseIf* /* handler */) = 0;
+};
+
+class HbaseIfSingletonFactory : virtual public HbaseIfFactory {
+ public:
+  HbaseIfSingletonFactory(const boost::shared_ptr<HbaseIf>& iface) : iface_(iface) {}
+  virtual ~HbaseIfSingletonFactory() {}
+
+  virtual HbaseIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
+    return iface_.get();
+  }
+  virtual void releaseHandler(HbaseIf* /* handler */) {}
+
+ protected:
+  boost::shared_ptr<HbaseIf> iface_;
+};
+
+class HbaseNull : virtual public HbaseIf {
+ public:
+  virtual ~HbaseNull() {}
+  void enableTable(const Bytes& /* tableName */) {
+    return;
+  }
+  void disableTable(const Bytes& /* tableName */) {
+    return;
+  }
+  bool isTableEnabled(const Bytes& /* tableName */) {
+    bool _return = false;
+    return _return;
+  }
+  void compact(const Bytes& /* tableNameOrRegionName */) {
+    return;
+  }
+  void majorCompact(const Bytes& /* tableNameOrRegionName */) {
+    return;
+  }
+  void getTableNames(std::vector<Text> & /* _return */) {
+    return;
+  }
+  void getColumnDescriptors(std::map<Text, ColumnDescriptor> & /* _return */, const Text& /* tableName */) {
+    return;
+  }
+  void getTableRegions(std::vector<TRegionInfo> & /* _return */, const Text& /* tableName */) {
+    return;
+  }
+  void createTable(const Text& /* tableName */, const std::vector<ColumnDescriptor> & /* columnFamilies */) {
+    return;
+  }
+  void deleteTable(const Text& /* tableName */) {
+    return;
+  }
+  void get(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void getVer(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int32_t /* numVersions */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void getVerTs(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* timestamp */, const int32_t /* numVersions */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void getRow(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void getRowWithColumns(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void getRowTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void getRowWithColumnsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void getRows(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void getRowsWithColumns(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void getRowsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void getRowsWithColumnsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void mutateRow(const Text& /* tableName */, const Text& /* row */, const std::vector<Mutation> & /* mutations */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void mutateRowTs(const Text& /* tableName */, const Text& /* row */, const std::vector<Mutation> & /* mutations */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void mutateRows(const Text& /* tableName */, const std::vector<BatchMutation> & /* rowBatches */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void mutateRowsTs(const Text& /* tableName */, const std::vector<BatchMutation> & /* rowBatches */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  int64_t atomicIncrement(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* value */) {
+    int64_t _return = 0;
+    return _return;
+  }
+  void deleteAll(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void deleteAllTs(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void deleteAllRow(const Text& /* tableName */, const Text& /* row */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  void increment(const TIncrement& /* increment */) {
+    return;
+  }
+  void incrementRows(const std::vector<TIncrement> & /* increments */) {
+    return;
+  }
+  void deleteAllRowTs(const Text& /* tableName */, const Text& /* row */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
+    return;
+  }
+  ScannerID scannerOpenWithScan(const Text& /* tableName */, const TScan& /* scan */, const std::map<Text, Text> & /* attributes */) {
+    ScannerID _return = 0;
+    return _return;
+  }
+  ScannerID scannerOpen(const Text& /* tableName */, const Text& /* startRow */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
+    ScannerID _return = 0;
+    return _return;
+  }
+  ScannerID scannerOpenWithStop(const Text& /* tableName */, const Text& /* startRow */, const Text& /* stopRow */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
+    ScannerID _return = 0;
+    return _return;
+  }
+  ScannerID scannerOpenWithPrefix(const Text& /* tableName */, const Text& /* startAndPrefix */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
+    ScannerID _return = 0;
+    return _return;
+  }
+  ScannerID scannerOpenTs(const Text& /* tableName */, const Text& /* startRow */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
+    ScannerID _return = 0;
+    return _return;
+  }
+  ScannerID scannerOpenWithStopTs(const Text& /* tableName */, const Text& /* startRow */, const Text& /* stopRow */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
+    ScannerID _return = 0;
+    return _return;
+  }
+  void scannerGet(std::vector<TRowResult> & /* _return */, const ScannerID /* id */) {
+    return;
+  }
+  void scannerGetList(std::vector<TRowResult> & /* _return */, const ScannerID /* id */, const int32_t /* nbRows */) {
+    return;
+  }
+  void scannerClose(const ScannerID /* id */) {
+    return;
+  }
+  void getRowOrBefore(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* family */) {
+    return;
+  }
+  void getRegionInfo(TRegionInfo& /* _return */, const Text& /* row */) {
+    return;
+  }
+};
+
+typedef struct _Hbase_enableTable_args__isset {
+  _Hbase_enableTable_args__isset() : tableName(false) {}
+  bool tableName;
+} _Hbase_enableTable_args__isset;
+
+class Hbase_enableTable_args {
+ public:
+
+  Hbase_enableTable_args() : tableName() {
+  }
+
+  virtual ~Hbase_enableTable_args() throw() {}
+
+  Bytes tableName;
+
+  _Hbase_enableTable_args__isset __isset;
+
+  void __set_tableName(const Bytes& val) {
+    tableName = val;
+  }
+
+  bool operator == (const Hbase_enableTable_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_enableTable_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_enableTable_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_enableTable_pargs {
+ public:
+
+
+  virtual ~Hbase_enableTable_pargs() throw() {}
+
+  const Bytes* tableName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_enableTable_result__isset {
+  _Hbase_enableTable_result__isset() : io(false) {}
+  bool io;
+} _Hbase_enableTable_result__isset;
+
+class Hbase_enableTable_result {
+ public:
+
+  Hbase_enableTable_result() {
+  }
+
+  virtual ~Hbase_enableTable_result() throw() {}
+
+  IOError io;
+
+  _Hbase_enableTable_result__isset __isset;
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_enableTable_result & rhs) const
+  {
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_enableTable_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_enableTable_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_enableTable_presult__isset {
+  _Hbase_enableTable_presult__isset() : io(false) {}
+  bool io;
+} _Hbase_enableTable_presult__isset;
+
+class Hbase_enableTable_presult {
+ public:
+
+
+  virtual ~Hbase_enableTable_presult() throw() {}
+
+  IOError io;
+
+  _Hbase_enableTable_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_disableTable_args__isset {
+  _Hbase_disableTable_args__isset() : tableName(false) {}
+  bool tableName;
+} _Hbase_disableTable_args__isset;
+
+class Hbase_disableTable_args {
+ public:
+
+  Hbase_disableTable_args() : tableName() {
+  }
+
+  virtual ~Hbase_disableTable_args() throw() {}
+
+  Bytes tableName;
+
+  _Hbase_disableTable_args__isset __isset;
+
+  void __set_tableName(const Bytes& val) {
+    tableName = val;
+  }
+
+  bool operator == (const Hbase_disableTable_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_disableTable_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_disableTable_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_disableTable_pargs {
+ public:
+
+
+  virtual ~Hbase_disableTable_pargs() throw() {}
+
+  const Bytes* tableName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_disableTable_result__isset {
+  _Hbase_disableTable_result__isset() : io(false) {}
+  bool io;
+} _Hbase_disableTable_result__isset;
+
+class Hbase_disableTable_result {
+ public:
+
+  Hbase_disableTable_result() {
+  }
+
+  virtual ~Hbase_disableTable_result() throw() {}
+
+  IOError io;
+
+  _Hbase_disableTable_result__isset __isset;
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_disableTable_result & rhs) const
+  {
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_disableTable_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_disableTable_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_disableTable_presult__isset {
+  _Hbase_disableTable_presult__isset() : io(false) {}
+  bool io;
+} _Hbase_disableTable_presult__isset;
+
+class Hbase_disableTable_presult {
+ public:
+
+
+  virtual ~Hbase_disableTable_presult() throw() {}
+
+  IOError io;
+
+  _Hbase_disableTable_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_isTableEnabled_args__isset {
+  _Hbase_isTableEnabled_args__isset() : tableName(false) {}
+  bool tableName;
+} _Hbase_isTableEnabled_args__isset;
+
+class Hbase_isTableEnabled_args {
+ public:
+
+  Hbase_isTableEnabled_args() : tableName() {
+  }
+
+  virtual ~Hbase_isTableEnabled_args() throw() {}
+
+  Bytes tableName;
+
+  _Hbase_isTableEnabled_args__isset __isset;
+
+  void __set_tableName(const Bytes& val) {
+    tableName = val;
+  }
+
+  bool operator == (const Hbase_isTableEnabled_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_isTableEnabled_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_isTableEnabled_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_isTableEnabled_pargs {
+ public:
+
+
+  virtual ~Hbase_isTableEnabled_pargs() throw() {}
+
+  const Bytes* tableName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_isTableEnabled_result__isset {
+  _Hbase_isTableEnabled_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_isTableEnabled_result__isset;
+
+class Hbase_isTableEnabled_result {
+ public:
+
+  Hbase_isTableEnabled_result() : success(0) {
+  }
+
+  virtual ~Hbase_isTableEnabled_result() throw() {}
+
+  bool success;
+  IOError io;
+
+  _Hbase_isTableEnabled_result__isset __isset;
+
+  void __set_success(const bool val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_isTableEnabled_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_isTableEnabled_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_isTableEnabled_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_isTableEnabled_presult__isset {
+  _Hbase_isTableEnabled_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_isTableEnabled_presult__isset;
+
+class Hbase_isTableEnabled_presult {
+ public:
+
+
+  virtual ~Hbase_isTableEnabled_presult() throw() {}
+
+  bool* success;
+  IOError io;
+
+  _Hbase_isTableEnabled_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_compact_args__isset {
+  _Hbase_compact_args__isset() : tableNameOrRegionName(false) {}
+  bool tableNameOrRegionName;
+} _Hbase_compact_args__isset;
+
+class Hbase_compact_args {
+ public:
+
+  Hbase_compact_args() : tableNameOrRegionName() {
+  }
+
+  virtual ~Hbase_compact_args() throw() {}
+
+  Bytes tableNameOrRegionName;
+
+  _Hbase_compact_args__isset __isset;
+
+  void __set_tableNameOrRegionName(const Bytes& val) {
+    tableNameOrRegionName = val;
+  }
+
+  bool operator == (const Hbase_compact_args & rhs) const
+  {
+    if (!(tableNameOrRegionName == rhs.tableNameOrRegionName))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_compact_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_compact_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_compact_pargs {
+ public:
+
+
+  virtual ~Hbase_compact_pargs() throw() {}
+
+  const Bytes* tableNameOrRegionName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_compact_result__isset {
+  _Hbase_compact_result__isset() : io(false) {}
+  bool io;
+} _Hbase_compact_result__isset;
+
+class Hbase_compact_result {
+ public:
+
+  Hbase_compact_result() {
+  }
+
+  virtual ~Hbase_compact_result() throw() {}
+
+  IOError io;
+
+  _Hbase_compact_result__isset __isset;
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_compact_result & rhs) const
+  {
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_compact_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_compact_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_compact_presult__isset {
+  _Hbase_compact_presult__isset() : io(false) {}
+  bool io;
+} _Hbase_compact_presult__isset;
+
+class Hbase_compact_presult {
+ public:
+
+
+  virtual ~Hbase_compact_presult() throw() {}
+
+  IOError io;
+
+  _Hbase_compact_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_majorCompact_args__isset {
+  _Hbase_majorCompact_args__isset() : tableNameOrRegionName(false) {}
+  bool tableNameOrRegionName;
+} _Hbase_majorCompact_args__isset;
+
+class Hbase_majorCompact_args {
+ public:
+
+  Hbase_majorCompact_args() : tableNameOrRegionName() {
+  }
+
+  virtual ~Hbase_majorCompact_args() throw() {}
+
+  Bytes tableNameOrRegionName;
+
+  _Hbase_majorCompact_args__isset __isset;
+
+  void __set_tableNameOrRegionName(const Bytes& val) {
+    tableNameOrRegionName = val;
+  }
+
+  bool operator == (const Hbase_majorCompact_args & rhs) const
+  {
+    if (!(tableNameOrRegionName == rhs.tableNameOrRegionName))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_majorCompact_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_majorCompact_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_majorCompact_pargs {
+ public:
+
+
+  virtual ~Hbase_majorCompact_pargs() throw() {}
+
+  const Bytes* tableNameOrRegionName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_majorCompact_result__isset {
+  _Hbase_majorCompact_result__isset() : io(false) {}
+  bool io;
+} _Hbase_majorCompact_result__isset;
+
+class Hbase_majorCompact_result {
+ public:
+
+  Hbase_majorCompact_result() {
+  }
+
+  virtual ~Hbase_majorCompact_result() throw() {}
+
+  IOError io;
+
+  _Hbase_majorCompact_result__isset __isset;
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_majorCompact_result & rhs) const
+  {
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_majorCompact_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_majorCompact_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_majorCompact_presult__isset {
+  _Hbase_majorCompact_presult__isset() : io(false) {}
+  bool io;
+} _Hbase_majorCompact_presult__isset;
+
+class Hbase_majorCompact_presult {
+ public:
+
+
+  virtual ~Hbase_majorCompact_presult() throw() {}
+
+  IOError io;
+
+  _Hbase_majorCompact_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Hbase_getTableNames_args {
+ public:
+
+  Hbase_getTableNames_args() {
+  }
+
+  virtual ~Hbase_getTableNames_args() throw() {}
+
+
+  bool operator == (const Hbase_getTableNames_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Hbase_getTableNames_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getTableNames_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getTableNames_pargs {
+ public:
+
+
+  virtual ~Hbase_getTableNames_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getTableNames_result__isset {
+  _Hbase_getTableNames_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getTableNames_result__isset;
+
+class Hbase_getTableNames_result {
+ public:
+
+  Hbase_getTableNames_result() {
+  }
+
+  virtual ~Hbase_getTableNames_result() throw() {}
+
+  std::vector<Text>  success;
+  IOError io;
+
+  _Hbase_getTableNames_result__isset __isset;
+
+  void __set_success(const std::vector<Text> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getTableNames_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getTableNames_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getTableNames_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getTableNames_presult__isset {
+  _Hbase_getTableNames_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getTableNames_presult__isset;
+
+class Hbase_getTableNames_presult {
+ public:
+
+
+  virtual ~Hbase_getTableNames_presult() throw() {}
+
+  std::vector<Text> * success;
+  IOError io;
+
+  _Hbase_getTableNames_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getColumnDescriptors_args__isset {
+  _Hbase_getColumnDescriptors_args__isset() : tableName(false) {}
+  bool tableName;
+} _Hbase_getColumnDescriptors_args__isset;
+
+class Hbase_getColumnDescriptors_args {
+ public:
+
+  Hbase_getColumnDescriptors_args() : tableName() {
+  }
+
+  virtual ~Hbase_getColumnDescriptors_args() throw() {}
+
+  Text tableName;
+
+  _Hbase_getColumnDescriptors_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  bool operator == (const Hbase_getColumnDescriptors_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getColumnDescriptors_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getColumnDescriptors_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getColumnDescriptors_pargs {
+ public:
+
+
+  virtual ~Hbase_getColumnDescriptors_pargs() throw() {}
+
+  const Text* tableName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getColumnDescriptors_result__isset {
+  _Hbase_getColumnDescriptors_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getColumnDescriptors_result__isset;
+
+class Hbase_getColumnDescriptors_result {
+ public:
+
+  Hbase_getColumnDescriptors_result() {
+  }
+
+  virtual ~Hbase_getColumnDescriptors_result() throw() {}
+
+  std::map<Text, ColumnDescriptor>  success;
+  IOError io;
+
+  _Hbase_getColumnDescriptors_result__isset __isset;
+
+  void __set_success(const std::map<Text, ColumnDescriptor> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getColumnDescriptors_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getColumnDescriptors_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getColumnDescriptors_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getColumnDescriptors_presult__isset {
+  _Hbase_getColumnDescriptors_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getColumnDescriptors_presult__isset;
+
+class Hbase_getColumnDescriptors_presult {
+ public:
+
+
+  virtual ~Hbase_getColumnDescriptors_presult() throw() {}
+
+  std::map<Text, ColumnDescriptor> * success;
+  IOError io;
+
+  _Hbase_getColumnDescriptors_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getTableRegions_args__isset {
+  _Hbase_getTableRegions_args__isset() : tableName(false) {}
+  bool tableName;
+} _Hbase_getTableRegions_args__isset;
+
+class Hbase_getTableRegions_args {
+ public:
+
+  Hbase_getTableRegions_args() : tableName() {
+  }
+
+  virtual ~Hbase_getTableRegions_args() throw() {}
+
+  Text tableName;
+
+  _Hbase_getTableRegions_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  bool operator == (const Hbase_getTableRegions_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getTableRegions_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getTableRegions_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getTableRegions_pargs {
+ public:
+
+
+  virtual ~Hbase_getTableRegions_pargs() throw() {}
+
+  const Text* tableName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getTableRegions_result__isset {
+  _Hbase_getTableRegions_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getTableRegions_result__isset;
+
+class Hbase_getTableRegions_result {
+ public:
+
+  Hbase_getTableRegions_result() {
+  }
+
+  virtual ~Hbase_getTableRegions_result() throw() {}
+
+  std::vector<TRegionInfo>  success;
+  IOError io;
+
+  _Hbase_getTableRegions_result__isset __isset;
+
+  void __set_success(const std::vector<TRegionInfo> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getTableRegions_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getTableRegions_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getTableRegions_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getTableRegions_presult__isset {
+  _Hbase_getTableRegions_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getTableRegions_presult__isset;
+
+class Hbase_getTableRegions_presult {
+ public:
+
+
+  virtual ~Hbase_getTableRegions_presult() throw() {}
+
+  std::vector<TRegionInfo> * success;
+  IOError io;
+
+  _Hbase_getTableRegions_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_createTable_args__isset {
+  _Hbase_createTable_args__isset() : tableName(false), columnFamilies(false) {}
+  bool tableName;
+  bool columnFamilies;
+} _Hbase_createTable_args__isset;
+
+class Hbase_createTable_args {
+ public:
+
+  Hbase_createTable_args() : tableName() {
+  }
+
+  virtual ~Hbase_createTable_args() throw() {}
+
+  Text tableName;
+  std::vector<ColumnDescriptor>  columnFamilies;
+
+  _Hbase_createTable_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_columnFamilies(const std::vector<ColumnDescriptor> & val) {
+    columnFamilies = val;
+  }
+
+  bool operator == (const Hbase_createTable_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(columnFamilies == rhs.columnFamilies))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_createTable_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_createTable_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_createTable_pargs {
+ public:
+
+
+  virtual ~Hbase_createTable_pargs() throw() {}
+
+  const Text* tableName;
+  const std::vector<ColumnDescriptor> * columnFamilies;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_createTable_result__isset {
+  _Hbase_createTable_result__isset() : io(false), ia(false), exist(false) {}
+  bool io;
+  bool ia;
+  bool exist;
+} _Hbase_createTable_result__isset;
+
+class Hbase_createTable_result {
+ public:
+
+  Hbase_createTable_result() {
+  }
+
+  virtual ~Hbase_createTable_result() throw() {}
+
+  IOError io;
+  IllegalArgument ia;
+  AlreadyExists exist;
+
+  _Hbase_createTable_result__isset __isset;
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  void __set_ia(const IllegalArgument& val) {
+    ia = val;
+  }
+
+  void __set_exist(const AlreadyExists& val) {
+    exist = val;
+  }
+
+  bool operator == (const Hbase_createTable_result & rhs) const
+  {
+    if (!(io == rhs.io))
+      return false;
+    if (!(ia == rhs.ia))
+      return false;
+    if (!(exist == rhs.exist))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_createTable_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_createTable_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_createTable_presult__isset {
+  _Hbase_createTable_presult__isset() : io(false), ia(false), exist(false) {}
+  bool io;
+  bool ia;
+  bool exist;
+} _Hbase_createTable_presult__isset;
+
+class Hbase_createTable_presult {
+ public:
+
+
+  virtual ~Hbase_createTable_presult() throw() {}
+
+  IOError io;
+  IllegalArgument ia;
+  AlreadyExists exist;
+
+  _Hbase_createTable_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_deleteTable_args__isset {
+  _Hbase_deleteTable_args__isset() : tableName(false) {}
+  bool tableName;
+} _Hbase_deleteTable_args__isset;
+
+class Hbase_deleteTable_args {
+ public:
+
+  Hbase_deleteTable_args() : tableName() {
+  }
+
+  virtual ~Hbase_deleteTable_args() throw() {}
+
+  Text tableName;
+
+  _Hbase_deleteTable_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  bool operator == (const Hbase_deleteTable_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_deleteTable_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_deleteTable_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_deleteTable_pargs {
+ public:
+
+
+  virtual ~Hbase_deleteTable_pargs() throw() {}
+
+  const Text* tableName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_deleteTable_result__isset {
+  _Hbase_deleteTable_result__isset() : io(false) {}
+  bool io;
+} _Hbase_deleteTable_result__isset;
+
+class Hbase_deleteTable_result {
+ public:
+
+  Hbase_deleteTable_result() {
+  }
+
+  virtual ~Hbase_deleteTable_result() throw() {}
+
+  IOError io;
+
+  _Hbase_deleteTable_result__isset __isset;
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_deleteTable_result & rhs) const
+  {
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_deleteTable_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_deleteTable_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_deleteTable_presult__isset {
+  _Hbase_deleteTable_presult__isset() : io(false) {}
+  bool io;
+} _Hbase_deleteTable_presult__isset;
+
+class Hbase_deleteTable_presult {
+ public:
+
+
+  virtual ~Hbase_deleteTable_presult() throw() {}
+
+  IOError io;
+
+  _Hbase_deleteTable_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_get_args__isset {
+  _Hbase_get_args__isset() : tableName(false), row(false), column(false), attributes(false) {}
+  bool tableName;
+  bool row;
+  bool column;
+  bool attributes;
+} _Hbase_get_args__isset;
+
+class Hbase_get_args {
+ public:
+
+  Hbase_get_args() : tableName(), row(), column() {
+  }
+
+  virtual ~Hbase_get_args() throw() {}
+
+  Text tableName;
+  Text row;
+  Text column;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_get_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_row(const Text& val) {
+    row = val;
+  }
+
+  void __set_column(const Text& val) {
+    column = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_get_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(row == rhs.row))
+      return false;
+    if (!(column == rhs.column))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_get_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_get_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_get_pargs {
+ public:
+
+
+  virtual ~Hbase_get_pargs() throw() {}
+
+  const Text* tableName;
+  const Text* row;
+  const Text* column;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_get_result__isset {
+  _Hbase_get_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_get_result__isset;
+
+class Hbase_get_result {
+ public:
+
+  Hbase_get_result() {
+  }
+
+  virtual ~Hbase_get_result() throw() {}
+
+  std::vector<TCell>  success;
+  IOError io;
+
+  _Hbase_get_result__isset __isset;
+
+  void __set_success(const std::vector<TCell> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_get_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_get_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_get_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_get_presult__isset {
+  _Hbase_get_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_get_presult__isset;
+
+class Hbase_get_presult {
+ public:
+
+
+  virtual ~Hbase_get_presult() throw() {}
+
+  std::vector<TCell> * success;
+  IOError io;
+
+  _Hbase_get_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getVer_args__isset {
+  _Hbase_getVer_args__isset() : tableName(false), row(false), column(false), numVersions(false), attributes(false) {}
+  bool tableName;
+  bool row;
+  bool column;
+  bool numVersions;
+  bool attributes;
+} _Hbase_getVer_args__isset;
+
+class Hbase_getVer_args {
+ public:
+
+  Hbase_getVer_args() : tableName(), row(), column(), numVersions(0) {
+  }
+
+  virtual ~Hbase_getVer_args() throw() {}
+
+  Text tableName;
+  Text row;
+  Text column;
+  int32_t numVersions;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_getVer_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_row(const Text& val) {
+    row = val;
+  }
+
+  void __set_column(const Text& val) {
+    column = val;
+  }
+
+  void __set_numVersions(const int32_t val) {
+    numVersions = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_getVer_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(row == rhs.row))
+      return false;
+    if (!(column == rhs.column))
+      return false;
+    if (!(numVersions == rhs.numVersions))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getVer_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getVer_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getVer_pargs {
+ public:
+
+
+  virtual ~Hbase_getVer_pargs() throw() {}
+
+  const Text* tableName;
+  const Text* row;
+  const Text* column;
+  const int32_t* numVersions;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getVer_result__isset {
+  _Hbase_getVer_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getVer_result__isset;
+
+class Hbase_getVer_result {
+ public:
+
+  Hbase_getVer_result() {
+  }
+
+  virtual ~Hbase_getVer_result() throw() {}
+
+  std::vector<TCell>  success;
+  IOError io;
+
+  _Hbase_getVer_result__isset __isset;
+
+  void __set_success(const std::vector<TCell> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getVer_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getVer_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getVer_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getVer_presult__isset {
+  _Hbase_getVer_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getVer_presult__isset;
+
+class Hbase_getVer_presult {
+ public:
+
+
+  virtual ~Hbase_getVer_presult() throw() {}
+
+  std::vector<TCell> * success;
+  IOError io;
+
+  _Hbase_getVer_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getVerTs_args__isset {
+  _Hbase_getVerTs_args__isset() : tableName(false), row(false), column(false), timestamp(false), numVersions(false), attributes(false) {}
+  bool tableName;
+  bool row;
+  bool column;
+  bool timestamp;
+  bool numVersions;
+  bool attributes;
+} _Hbase_getVerTs_args__isset;
+
+class Hbase_getVerTs_args {
+ public:
+
+  Hbase_getVerTs_args() : tableName(), row(), column(), timestamp(0), numVersions(0) {
+  }
+
+  virtual ~Hbase_getVerTs_args() throw() {}
+
+  Text tableName;
+  Text row;
+  Text column;
+  int64_t timestamp;
+  int32_t numVersions;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_getVerTs_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_row(const Text& val) {
+    row = val;
+  }
+
+  void __set_column(const Text& val) {
+    column = val;
+  }
+
+  void __set_timestamp(const int64_t val) {
+    timestamp = val;
+  }
+
+  void __set_numVersions(const int32_t val) {
+    numVersions = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_getVerTs_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(row == rhs.row))
+      return false;
+    if (!(column == rhs.column))
+      return false;
+    if (!(timestamp == rhs.timestamp))
+      return false;
+    if (!(numVersions == rhs.numVersions))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getVerTs_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getVerTs_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getVerTs_pargs {
+ public:
+
+
+  virtual ~Hbase_getVerTs_pargs() throw() {}
+
+  const Text* tableName;
+  const Text* row;
+  const Text* column;
+  const int64_t* timestamp;
+  const int32_t* numVersions;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getVerTs_result__isset {
+  _Hbase_getVerTs_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getVerTs_result__isset;
+
+class Hbase_getVerTs_result {
+ public:
+
+  Hbase_getVerTs_result() {
+  }
+
+  virtual ~Hbase_getVerTs_result() throw() {}
+
+  std::vector<TCell>  success;
+  IOError io;
+
+  _Hbase_getVerTs_result__isset __isset;
+
+  void __set_success(const std::vector<TCell> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getVerTs_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getVerTs_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getVerTs_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getVerTs_presult__isset {
+  _Hbase_getVerTs_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getVerTs_presult__isset;
+
+class Hbase_getVerTs_presult {
+ public:
+
+
+  virtual ~Hbase_getVerTs_presult() throw() {}
+
+  std::vector<TCell> * success;
+  IOError io;
+
+  _Hbase_getVerTs_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getRow_args__isset {
+  _Hbase_getRow_args__isset() : tableName(false), row(false), attributes(false) {}
+  bool tableName;
+  bool row;
+  bool attributes;
+} _Hbase_getRow_args__isset;
+
+class Hbase_getRow_args {
+ public:
+
+  Hbase_getRow_args() : tableName(), row() {
+  }
+
+  virtual ~Hbase_getRow_args() throw() {}
+
+  Text tableName;
+  Text row;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_getRow_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_row(const Text& val) {
+    row = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_getRow_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(row == rhs.row))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRow_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRow_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getRow_pargs {
+ public:
+
+
+  virtual ~Hbase_getRow_pargs() throw() {}
+
+  const Text* tableName;
+  const Text* row;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRow_result__isset {
+  _Hbase_getRow_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRow_result__isset;
+
+class Hbase_getRow_result {
+ public:
+
+  Hbase_getRow_result() {
+  }
+
+  virtual ~Hbase_getRow_result() throw() {}
+
+  std::vector<TRowResult>  success;
+  IOError io;
+
+  _Hbase_getRow_result__isset __isset;
+
+  void __set_success(const std::vector<TRowResult> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getRow_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRow_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRow_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRow_presult__isset {
+  _Hbase_getRow_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRow_presult__isset;
+
+class Hbase_getRow_presult {
+ public:
+
+
+  virtual ~Hbase_getRow_presult() throw() {}
+
+  std::vector<TRowResult> * success;
+  IOError io;
+
+  _Hbase_getRow_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getRowWithColumns_args__isset {
+  _Hbase_getRowWithColumns_args__isset() : tableName(false), row(false), columns(false), attributes(false) {}
+  bool tableName;
+  bool row;
+  bool columns;
+  bool attributes;
+} _Hbase_getRowWithColumns_args__isset;
+
+class Hbase_getRowWithColumns_args {
+ public:
+
+  Hbase_getRowWithColumns_args() : tableName(), row() {
+  }
+
+  virtual ~Hbase_getRowWithColumns_args() throw() {}
+
+  Text tableName;
+  Text row;
+  std::vector<Text>  columns;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_getRowWithColumns_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_row(const Text& val) {
+    row = val;
+  }
+
+  void __set_columns(const std::vector<Text> & val) {
+    columns = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_getRowWithColumns_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(row == rhs.row))
+      return false;
+    if (!(columns == rhs.columns))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowWithColumns_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowWithColumns_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getRowWithColumns_pargs {
+ public:
+
+
+  virtual ~Hbase_getRowWithColumns_pargs() throw() {}
+
+  const Text* tableName;
+  const Text* row;
+  const std::vector<Text> * columns;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowWithColumns_result__isset {
+  _Hbase_getRowWithColumns_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowWithColumns_result__isset;
+
+class Hbase_getRowWithColumns_result {
+ public:
+
+  Hbase_getRowWithColumns_result() {
+  }
+
+  virtual ~Hbase_getRowWithColumns_result() throw() {}
+
+  std::vector<TRowResult>  success;
+  IOError io;
+
+  _Hbase_getRowWithColumns_result__isset __isset;
+
+  void __set_success(const std::vector<TRowResult> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getRowWithColumns_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowWithColumns_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowWithColumns_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowWithColumns_presult__isset {
+  _Hbase_getRowWithColumns_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowWithColumns_presult__isset;
+
+class Hbase_getRowWithColumns_presult {
+ public:
+
+
+  virtual ~Hbase_getRowWithColumns_presult() throw() {}
+
+  std::vector<TRowResult> * success;
+  IOError io;
+
+  _Hbase_getRowWithColumns_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getRowTs_args__isset {
+  _Hbase_getRowTs_args__isset() : tableName(false), row(false), timestamp(false), attributes(false) {}
+  bool tableName;
+  bool row;
+  bool timestamp;
+  bool attributes;
+} _Hbase_getRowTs_args__isset;
+
+class Hbase_getRowTs_args {
+ public:
+
+  Hbase_getRowTs_args() : tableName(), row(), timestamp(0) {
+  }
+
+  virtual ~Hbase_getRowTs_args() throw() {}
+
+  Text tableName;
+  Text row;
+  int64_t timestamp;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_getRowTs_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_row(const Text& val) {
+    row = val;
+  }
+
+  void __set_timestamp(const int64_t val) {
+    timestamp = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_getRowTs_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(row == rhs.row))
+      return false;
+    if (!(timestamp == rhs.timestamp))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowTs_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowTs_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getRowTs_pargs {
+ public:
+
+
+  virtual ~Hbase_getRowTs_pargs() throw() {}
+
+  const Text* tableName;
+  const Text* row;
+  const int64_t* timestamp;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowTs_result__isset {
+  _Hbase_getRowTs_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowTs_result__isset;
+
+class Hbase_getRowTs_result {
+ public:
+
+  Hbase_getRowTs_result() {
+  }
+
+  virtual ~Hbase_getRowTs_result() throw() {}
+
+  std::vector<TRowResult>  success;
+  IOError io;
+
+  _Hbase_getRowTs_result__isset __isset;
+
+  void __set_success(const std::vector<TRowResult> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getRowTs_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowTs_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowTs_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowTs_presult__isset {
+  _Hbase_getRowTs_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowTs_presult__isset;
+
+class Hbase_getRowTs_presult {
+ public:
+
+
+  virtual ~Hbase_getRowTs_presult() throw() {}
+
+  std::vector<TRowResult> * success;
+  IOError io;
+
+  _Hbase_getRowTs_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getRowWithColumnsTs_args__isset {
+  _Hbase_getRowWithColumnsTs_args__isset() : tableName(false), row(false), columns(false), timestamp(false), attributes(false) {}
+  bool tableName;
+  bool row;
+  bool columns;
+  bool timestamp;
+  bool attributes;
+} _Hbase_getRowWithColumnsTs_args__isset;
+
+class Hbase_getRowWithColumnsTs_args {
+ public:
+
+  Hbase_getRowWithColumnsTs_args() : tableName(), row(), timestamp(0) {
+  }
+
+  virtual ~Hbase_getRowWithColumnsTs_args() throw() {}
+
+  Text tableName;
+  Text row;
+  std::vector<Text>  columns;
+  int64_t timestamp;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_getRowWithColumnsTs_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_row(const Text& val) {
+    row = val;
+  }
+
+  void __set_columns(const std::vector<Text> & val) {
+    columns = val;
+  }
+
+  void __set_timestamp(const int64_t val) {
+    timestamp = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_getRowWithColumnsTs_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(row == rhs.row))
+      return false;
+    if (!(columns == rhs.columns))
+      return false;
+    if (!(timestamp == rhs.timestamp))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowWithColumnsTs_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowWithColumnsTs_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getRowWithColumnsTs_pargs {
+ public:
+
+
+  virtual ~Hbase_getRowWithColumnsTs_pargs() throw() {}
+
+  const Text* tableName;
+  const Text* row;
+  const std::vector<Text> * columns;
+  const int64_t* timestamp;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowWithColumnsTs_result__isset {
+  _Hbase_getRowWithColumnsTs_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowWithColumnsTs_result__isset;
+
+class Hbase_getRowWithColumnsTs_result {
+ public:
+
+  Hbase_getRowWithColumnsTs_result() {
+  }
+
+  virtual ~Hbase_getRowWithColumnsTs_result() throw() {}
+
+  std::vector<TRowResult>  success;
+  IOError io;
+
+  _Hbase_getRowWithColumnsTs_result__isset __isset;
+
+  void __set_success(const std::vector<TRowResult> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getRowWithColumnsTs_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowWithColumnsTs_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowWithColumnsTs_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowWithColumnsTs_presult__isset {
+  _Hbase_getRowWithColumnsTs_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowWithColumnsTs_presult__isset;
+
+class Hbase_getRowWithColumnsTs_presult {
+ public:
+
+
+  virtual ~Hbase_getRowWithColumnsTs_presult() throw() {}
+
+  std::vector<TRowResult> * success;
+  IOError io;
+
+  _Hbase_getRowWithColumnsTs_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getRows_args__isset {
+  _Hbase_getRows_args__isset() : tableName(false), rows(false), attributes(false) {}
+  bool tableName;
+  bool rows;
+  bool attributes;
+} _Hbase_getRows_args__isset;
+
+class Hbase_getRows_args {
+ public:
+
+  Hbase_getRows_args() : tableName() {
+  }
+
+  virtual ~Hbase_getRows_args() throw() {}
+
+  Text tableName;
+  std::vector<Text>  rows;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_getRows_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_rows(const std::vector<Text> & val) {
+    rows = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_getRows_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(rows == rhs.rows))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRows_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRows_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getRows_pargs {
+ public:
+
+
+  virtual ~Hbase_getRows_pargs() throw() {}
+
+  const Text* tableName;
+  const std::vector<Text> * rows;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRows_result__isset {
+  _Hbase_getRows_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRows_result__isset;
+
+class Hbase_getRows_result {
+ public:
+
+  Hbase_getRows_result() {
+  }
+
+  virtual ~Hbase_getRows_result() throw() {}
+
+  std::vector<TRowResult>  success;
+  IOError io;
+
+  _Hbase_getRows_result__isset __isset;
+
+  void __set_success(const std::vector<TRowResult> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getRows_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRows_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRows_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRows_presult__isset {
+  _Hbase_getRows_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRows_presult__isset;
+
+class Hbase_getRows_presult {
+ public:
+
+
+  virtual ~Hbase_getRows_presult() throw() {}
+
+  std::vector<TRowResult> * success;
+  IOError io;
+
+  _Hbase_getRows_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getRowsWithColumns_args__isset {
+  _Hbase_getRowsWithColumns_args__isset() : tableName(false), rows(false), columns(false), attributes(false) {}
+  bool tableName;
+  bool rows;
+  bool columns;
+  bool attributes;
+} _Hbase_getRowsWithColumns_args__isset;
+
+class Hbase_getRowsWithColumns_args {
+ public:
+
+  Hbase_getRowsWithColumns_args() : tableName() {
+  }
+
+  virtual ~Hbase_getRowsWithColumns_args() throw() {}
+
+  Text tableName;
+  std::vector<Text>  rows;
+  std::vector<Text>  columns;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_getRowsWithColumns_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_rows(const std::vector<Text> & val) {
+    rows = val;
+  }
+
+  void __set_columns(const std::vector<Text> & val) {
+    columns = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_getRowsWithColumns_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(rows == rhs.rows))
+      return false;
+    if (!(columns == rhs.columns))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowsWithColumns_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowsWithColumns_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getRowsWithColumns_pargs {
+ public:
+
+
+  virtual ~Hbase_getRowsWithColumns_pargs() throw() {}
+
+  const Text* tableName;
+  const std::vector<Text> * rows;
+  const std::vector<Text> * columns;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowsWithColumns_result__isset {
+  _Hbase_getRowsWithColumns_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowsWithColumns_result__isset;
+
+class Hbase_getRowsWithColumns_result {
+ public:
+
+  Hbase_getRowsWithColumns_result() {
+  }
+
+  virtual ~Hbase_getRowsWithColumns_result() throw() {}
+
+  std::vector<TRowResult>  success;
+  IOError io;
+
+  _Hbase_getRowsWithColumns_result__isset __isset;
+
+  void __set_success(const std::vector<TRowResult> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getRowsWithColumns_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowsWithColumns_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowsWithColumns_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowsWithColumns_presult__isset {
+  _Hbase_getRowsWithColumns_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowsWithColumns_presult__isset;
+
+class Hbase_getRowsWithColumns_presult {
+ public:
+
+
+  virtual ~Hbase_getRowsWithColumns_presult() throw() {}
+
+  std::vector<TRowResult> * success;
+  IOError io;
+
+  _Hbase_getRowsWithColumns_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getRowsTs_args__isset {
+  _Hbase_getRowsTs_args__isset() : tableName(false), rows(false), timestamp(false), attributes(false) {}
+  bool tableName;
+  bool rows;
+  bool timestamp;
+  bool attributes;
+} _Hbase_getRowsTs_args__isset;
+
+class Hbase_getRowsTs_args {
+ public:
+
+  Hbase_getRowsTs_args() : tableName(), timestamp(0) {
+  }
+
+  virtual ~Hbase_getRowsTs_args() throw() {}
+
+  Text tableName;
+  std::vector<Text>  rows;
+  int64_t timestamp;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_getRowsTs_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_rows(const std::vector<Text> & val) {
+    rows = val;
+  }
+
+  void __set_timestamp(const int64_t val) {
+    timestamp = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_getRowsTs_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(rows == rhs.rows))
+      return false;
+    if (!(timestamp == rhs.timestamp))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowsTs_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowsTs_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getRowsTs_pargs {
+ public:
+
+
+  virtual ~Hbase_getRowsTs_pargs() throw() {}
+
+  const Text* tableName;
+  const std::vector<Text> * rows;
+  const int64_t* timestamp;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowsTs_result__isset {
+  _Hbase_getRowsTs_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowsTs_result__isset;
+
+class Hbase_getRowsTs_result {
+ public:
+
+  Hbase_getRowsTs_result() {
+  }
+
+  virtual ~Hbase_getRowsTs_result() throw() {}
+
+  std::vector<TRowResult>  success;
+  IOError io;
+
+  _Hbase_getRowsTs_result__isset __isset;
+
+  void __set_success(const std::vector<TRowResult> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getRowsTs_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowsTs_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowsTs_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowsTs_presult__isset {
+  _Hbase_getRowsTs_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowsTs_presult__isset;
+
+class Hbase_getRowsTs_presult {
+ public:
+
+
+  virtual ~Hbase_getRowsTs_presult() throw() {}
+
+  std::vector<TRowResult> * success;
+  IOError io;
+
+  _Hbase_getRowsTs_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_getRowsWithColumnsTs_args__isset {
+  _Hbase_getRowsWithColumnsTs_args__isset() : tableName(false), rows(false), columns(false), timestamp(false), attributes(false) {}
+  bool tableName;
+  bool rows;
+  bool columns;
+  bool timestamp;
+  bool attributes;
+} _Hbase_getRowsWithColumnsTs_args__isset;
+
+class Hbase_getRowsWithColumnsTs_args {
+ public:
+
+  Hbase_getRowsWithColumnsTs_args() : tableName(), timestamp(0) {
+  }
+
+  virtual ~Hbase_getRowsWithColumnsTs_args() throw() {}
+
+  Text tableName;
+  std::vector<Text>  rows;
+  std::vector<Text>  columns;
+  int64_t timestamp;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_getRowsWithColumnsTs_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_rows(const std::vector<Text> & val) {
+    rows = val;
+  }
+
+  void __set_columns(const std::vector<Text> & val) {
+    columns = val;
+  }
+
+  void __set_timestamp(const int64_t val) {
+    timestamp = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_getRowsWithColumnsTs_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(rows == rhs.rows))
+      return false;
+    if (!(columns == rhs.columns))
+      return false;
+    if (!(timestamp == rhs.timestamp))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowsWithColumnsTs_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowsWithColumnsTs_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_getRowsWithColumnsTs_pargs {
+ public:
+
+
+  virtual ~Hbase_getRowsWithColumnsTs_pargs() throw() {}
+
+  const Text* tableName;
+  const std::vector<Text> * rows;
+  const std::vector<Text> * columns;
+  const int64_t* timestamp;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowsWithColumnsTs_result__isset {
+  _Hbase_getRowsWithColumnsTs_result__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowsWithColumnsTs_result__isset;
+
+class Hbase_getRowsWithColumnsTs_result {
+ public:
+
+  Hbase_getRowsWithColumnsTs_result() {
+  }
+
+  virtual ~Hbase_getRowsWithColumnsTs_result() throw() {}
+
+  std::vector<TRowResult>  success;
+  IOError io;
+
+  _Hbase_getRowsWithColumnsTs_result__isset __isset;
+
+  void __set_success(const std::vector<TRowResult> & val) {
+    success = val;
+  }
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  bool operator == (const Hbase_getRowsWithColumnsTs_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(io == rhs.io))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_getRowsWithColumnsTs_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_getRowsWithColumnsTs_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_getRowsWithColumnsTs_presult__isset {
+  _Hbase_getRowsWithColumnsTs_presult__isset() : success(false), io(false) {}
+  bool success;
+  bool io;
+} _Hbase_getRowsWithColumnsTs_presult__isset;
+
+class Hbase_getRowsWithColumnsTs_presult {
+ public:
+
+
+  virtual ~Hbase_getRowsWithColumnsTs_presult() throw() {}
+
+  std::vector<TRowResult> * success;
+  IOError io;
+
+  _Hbase_getRowsWithColumnsTs_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_mutateRow_args__isset {
+  _Hbase_mutateRow_args__isset() : tableName(false), row(false), mutations(false), attributes(false) {}
+  bool tableName;
+  bool row;
+  bool mutations;
+  bool attributes;
+} _Hbase_mutateRow_args__isset;
+
+class Hbase_mutateRow_args {
+ public:
+
+  Hbase_mutateRow_args() : tableName(), row() {
+  }
+
+  virtual ~Hbase_mutateRow_args() throw() {}
+
+  Text tableName;
+  Text row;
+  std::vector<Mutation>  mutations;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_mutateRow_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_row(const Text& val) {
+    row = val;
+  }
+
+  void __set_mutations(const std::vector<Mutation> & val) {
+    mutations = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_mutateRow_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(row == rhs.row))
+      return false;
+    if (!(mutations == rhs.mutations))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_mutateRow_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_mutateRow_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_mutateRow_pargs {
+ public:
+
+
+  virtual ~Hbase_mutateRow_pargs() throw() {}
+
+  const Text* tableName;
+  const Text* row;
+  const std::vector<Mutation> * mutations;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_mutateRow_result__isset {
+  _Hbase_mutateRow_result__isset() : io(false), ia(false) {}
+  bool io;
+  bool ia;
+} _Hbase_mutateRow_result__isset;
+
+class Hbase_mutateRow_result {
+ public:
+
+  Hbase_mutateRow_result() {
+  }
+
+  virtual ~Hbase_mutateRow_result() throw() {}
+
+  IOError io;
+  IllegalArgument ia;
+
+  _Hbase_mutateRow_result__isset __isset;
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  void __set_ia(const IllegalArgument& val) {
+    ia = val;
+  }
+
+  bool operator == (const Hbase_mutateRow_result & rhs) const
+  {
+    if (!(io == rhs.io))
+      return false;
+    if (!(ia == rhs.ia))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_mutateRow_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_mutateRow_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_mutateRow_presult__isset {
+  _Hbase_mutateRow_presult__isset() : io(false), ia(false) {}
+  bool io;
+  bool ia;
+} _Hbase_mutateRow_presult__isset;
+
+class Hbase_mutateRow_presult {
+ public:
+
+
+  virtual ~Hbase_mutateRow_presult() throw() {}
+
+  IOError io;
+  IllegalArgument ia;
+
+  _Hbase_mutateRow_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_mutateRowTs_args__isset {
+  _Hbase_mutateRowTs_args__isset() : tableName(false), row(false), mutations(false), timestamp(false), attributes(false) {}
+  bool tableName;
+  bool row;
+  bool mutations;
+  bool timestamp;
+  bool attributes;
+} _Hbase_mutateRowTs_args__isset;
+
+class Hbase_mutateRowTs_args {
+ public:
+
+  Hbase_mutateRowTs_args() : tableName(), row(), timestamp(0) {
+  }
+
+  virtual ~Hbase_mutateRowTs_args() throw() {}
+
+  Text tableName;
+  Text row;
+  std::vector<Mutation>  mutations;
+  int64_t timestamp;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_mutateRowTs_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_row(const Text& val) {
+    row = val;
+  }
+
+  void __set_mutations(const std::vector<Mutation> & val) {
+    mutations = val;
+  }
+
+  void __set_timestamp(const int64_t val) {
+    timestamp = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_mutateRowTs_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(row == rhs.row))
+      return false;
+    if (!(mutations == rhs.mutations))
+      return false;
+    if (!(timestamp == rhs.timestamp))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_mutateRowTs_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_mutateRowTs_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_mutateRowTs_pargs {
+ public:
+
+
+  virtual ~Hbase_mutateRowTs_pargs() throw() {}
+
+  const Text* tableName;
+  const Text* row;
+  const std::vector<Mutation> * mutations;
+  const int64_t* timestamp;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_mutateRowTs_result__isset {
+  _Hbase_mutateRowTs_result__isset() : io(false), ia(false) {}
+  bool io;
+  bool ia;
+} _Hbase_mutateRowTs_result__isset;
+
+class Hbase_mutateRowTs_result {
+ public:
+
+  Hbase_mutateRowTs_result() {
+  }
+
+  virtual ~Hbase_mutateRowTs_result() throw() {}
+
+  IOError io;
+  IllegalArgument ia;
+
+  _Hbase_mutateRowTs_result__isset __isset;
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  void __set_ia(const IllegalArgument& val) {
+    ia = val;
+  }
+
+  bool operator == (const Hbase_mutateRowTs_result & rhs) const
+  {
+    if (!(io == rhs.io))
+      return false;
+    if (!(ia == rhs.ia))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_mutateRowTs_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_mutateRowTs_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_mutateRowTs_presult__isset {
+  _Hbase_mutateRowTs_presult__isset() : io(false), ia(false) {}
+  bool io;
+  bool ia;
+} _Hbase_mutateRowTs_presult__isset;
+
+class Hbase_mutateRowTs_presult {
+ public:
+
+
+  virtual ~Hbase_mutateRowTs_presult() throw() {}
+
+  IOError io;
+  IllegalArgument ia;
+
+  _Hbase_mutateRowTs_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_mutateRows_args__isset {
+  _Hbase_mutateRows_args__isset() : tableName(false), rowBatches(false), attributes(false) {}
+  bool tableName;
+  bool rowBatches;
+  bool attributes;
+} _Hbase_mutateRows_args__isset;
+
+class Hbase_mutateRows_args {
+ public:
+
+  Hbase_mutateRows_args() : tableName() {
+  }
+
+  virtual ~Hbase_mutateRows_args() throw() {}
+
+  Text tableName;
+  std::vector<BatchMutation>  rowBatches;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_mutateRows_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_rowBatches(const std::vector<BatchMutation> & val) {
+    rowBatches = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_mutateRows_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(rowBatches == rhs.rowBatches))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_mutateRows_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_mutateRows_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_mutateRows_pargs {
+ public:
+
+
+  virtual ~Hbase_mutateRows_pargs() throw() {}
+
+  const Text* tableName;
+  const std::vector<BatchMutation> * rowBatches;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_mutateRows_result__isset {
+  _Hbase_mutateRows_result__isset() : io(false), ia(false) {}
+  bool io;
+  bool ia;
+} _Hbase_mutateRows_result__isset;
+
+class Hbase_mutateRows_result {
+ public:
+
+  Hbase_mutateRows_result() {
+  }
+
+  virtual ~Hbase_mutateRows_result() throw() {}
+
+  IOError io;
+  IllegalArgument ia;
+
+  _Hbase_mutateRows_result__isset __isset;
+
+  void __set_io(const IOError& val) {
+    io = val;
+  }
+
+  void __set_ia(const IllegalArgument& val) {
+    ia = val;
+  }
+
+  bool operator == (const Hbase_mutateRows_result & rhs) const
+  {
+    if (!(io == rhs.io))
+      return false;
+    if (!(ia == rhs.ia))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_mutateRows_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_mutateRows_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_mutateRows_presult__isset {
+  _Hbase_mutateRows_presult__isset() : io(false), ia(false) {}
+  bool io;
+  bool ia;
+} _Hbase_mutateRows_presult__isset;
+
+class Hbase_mutateRows_presult {
+ public:
+
+
+  virtual ~Hbase_mutateRows_presult() throw() {}
+
+  IOError io;
+  IllegalArgument ia;
+
+  _Hbase_mutateRows_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Hbase_mutateRowsTs_args__isset {
+  _Hbase_mutateRowsTs_args__isset() : tableName(false), rowBatches(false), timestamp(false), attributes(false) {}
+  bool tableName;
+  bool rowBatches;
+  bool timestamp;
+  bool attributes;
+} _Hbase_mutateRowsTs_args__isset;
+
+class Hbase_mutateRowsTs_args {
+ public:
+
+  Hbase_mutateRowsTs_args() : tableName(), timestamp(0) {
+  }
+
+  virtual ~Hbase_mutateRowsTs_args() throw() {}
+
+  Text tableName;
+  std::vector<BatchMutation>  rowBatches;
+  int64_t timestamp;
+  std::map<Text, Text>  attributes;
+
+  _Hbase_mutateRowsTs_args__isset __isset;
+
+  void __set_tableName(const Text& val) {
+    tableName = val;
+  }
+
+  void __set_rowBatches(const std::vector<BatchMutation> & val) {
+    rowBatches = val;
+  }
+
+  void __set_timestamp(const int64_t val) {
+    timestamp = val;
+  }
+
+  void __set_attributes(const std::map<Text, Text> & val) {
+    attributes = val;
+  }
+
+  bool operator == (const Hbase_mutateRowsTs_args & rhs) const
+  {
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(rowBatches == rhs.rowBatches))
+      return false;
+    if (!(timestamp == rhs.timestamp))
+      return false;
+    if (!(attributes == rhs.attributes))
+      return false;
+    return true;
+  }
+  bool operator != (const Hbase_mutateRowsTs_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Hbase_mutateRowsTs_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Hbase_mutateRowsTs_pargs {
+ public:
+
+
+  virtual ~Hbase_mutateRowsTs_pargs() throw() {}
+
+  const Text* tableName;
+  const std::vector<BatchMutation> * rowBatches;
+  const int64_t* timestamp;
+  const std::map<Text, Text> * attributes;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Hbase_mutateRowsTs_result__isset {
+  _Hbase_mutateRowsTs_result__isset() : io(false), ia(false) {}
+  bool io;

[... 3201 lines stripped ...]


Mime
View raw message