You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hbase.apache.org by st...@apache.org on 2012/11/06 22:22:30 UTC
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...
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 ...]