Hbase.h
Go to the documentation of this file.
00001 
00006 #ifndef Hbase_H
00007 #define Hbase_H
00008 
00009 #include <TProcessor.h>
00010 #include "Hbase_types.h"
00011 
00012 namespace apache { namespace hadoop { namespace hbase { namespace thrift {
00013 
00014 class HbaseIf {
00015  public:
00016   virtual ~HbaseIf() {}
00017   virtual void enableTable(const Bytes& tableName) = 0;
00018   virtual void disableTable(const Bytes& tableName) = 0;
00019   virtual bool isTableEnabled(const Bytes& tableName) = 0;
00020   virtual void compact(const Bytes& tableNameOrRegionName) = 0;
00021   virtual void majorCompact(const Bytes& tableNameOrRegionName) = 0;
00022   virtual void getTableNames(std::vector<Text> & _return) = 0;
00023   virtual void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName) = 0;
00024   virtual void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName) = 0;
00025   virtual void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies) = 0;
00026   virtual void deleteTable(const Text& tableName) = 0;
00027   virtual void get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column) = 0;
00028   virtual void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions) = 0;
00029   virtual void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions) = 0;
00030   virtual void getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row) = 0;
00031   virtual void getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns) = 0;
00032   virtual void getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp) = 0;
00033   virtual void getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp) = 0;
00034   virtual void getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows) = 0;
00035   virtual void getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns) = 0;
00036   virtual void getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp) = 0;
00037   virtual void getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp) = 0;
00038   virtual void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations) = 0;
00039   virtual void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp) = 0;
00040   virtual void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches) = 0;
00041   virtual void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp) = 0;
00042   virtual int64_t atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value) = 0;
00043   virtual void deleteAll(const Text& tableName, const Text& row, const Text& column) = 0;
00044   virtual void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp) = 0;
00045   virtual void deleteAllRow(const Text& tableName, const Text& row) = 0;
00046   virtual void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp) = 0;
00047   virtual ScannerID scannerOpenWithScan(const Text& tableName, const TScan& scan) = 0;
00048   virtual ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns) = 0;
00049   virtual ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns) = 0;
00050   virtual ScannerID scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns) = 0;
00051   virtual ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp) = 0;
00052   virtual ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp) = 0;
00053   virtual void scannerGet(std::vector<TRowResult> & _return, const ScannerID id) = 0;
00054   virtual void scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows) = 0;
00055   virtual void scannerClose(const ScannerID id) = 0;
00056   virtual void getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family) = 0;
00057   virtual void getRegionInfo(TRegionInfo& _return, const Text& row) = 0;
00058 };
00059 
00060 class HbaseNull : virtual public HbaseIf {
00061  public:
00062   virtual ~HbaseNull() {}
00063   void enableTable(const Bytes& /* tableName */) {
00064     return;
00065   }
00066   void disableTable(const Bytes& /* tableName */) {
00067     return;
00068   }
00069   bool isTableEnabled(const Bytes& /* tableName */) {
00070     bool _return = false;
00071     return _return;
00072   }
00073   void compact(const Bytes& /* tableNameOrRegionName */) {
00074     return;
00075   }
00076   void majorCompact(const Bytes& /* tableNameOrRegionName */) {
00077     return;
00078   }
00079   void getTableNames(std::vector<Text> & /* _return */) {
00080     return;
00081   }
00082   void getColumnDescriptors(std::map<Text, ColumnDescriptor> & /* _return */, const Text& /* tableName */) {
00083     return;
00084   }
00085   void getTableRegions(std::vector<TRegionInfo> & /* _return */, const Text& /* tableName */) {
00086     return;
00087   }
00088   void createTable(const Text& /* tableName */, const std::vector<ColumnDescriptor> & /* columnFamilies */) {
00089     return;
00090   }
00091   void deleteTable(const Text& /* tableName */) {
00092     return;
00093   }
00094   void get(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */) {
00095     return;
00096   }
00097   void getVer(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int32_t /* numVersions */) {
00098     return;
00099   }
00100   void getVerTs(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* timestamp */, const int32_t /* numVersions */) {
00101     return;
00102   }
00103   void getRow(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */) {
00104     return;
00105   }
00106   void getRowWithColumns(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const std::vector<Text> & /* columns */) {
00107     return;
00108   }
00109   void getRowTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const int64_t /* timestamp */) {
00110     return;
00111   }
00112   void getRowWithColumnsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */) {
00113     return;
00114   }
00115   void getRows(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */) {
00116     return;
00117   }
00118   void getRowsWithColumns(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const std::vector<Text> & /* columns */) {
00119     return;
00120   }
00121   void getRowsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const int64_t /* timestamp */) {
00122     return;
00123   }
00124   void getRowsWithColumnsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */) {
00125     return;
00126   }
00127   void mutateRow(const Text& /* tableName */, const Text& /* row */, const std::vector<Mutation> & /* mutations */) {
00128     return;
00129   }
00130   void mutateRowTs(const Text& /* tableName */, const Text& /* row */, const std::vector<Mutation> & /* mutations */, const int64_t /* timestamp */) {
00131     return;
00132   }
00133   void mutateRows(const Text& /* tableName */, const std::vector<BatchMutation> & /* rowBatches */) {
00134     return;
00135   }
00136   void mutateRowsTs(const Text& /* tableName */, const std::vector<BatchMutation> & /* rowBatches */, const int64_t /* timestamp */) {
00137     return;
00138   }
00139   int64_t atomicIncrement(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* value */) {
00140     int64_t _return = 0;
00141     return _return;
00142   }
00143   void deleteAll(const Text& /* tableName */, const Text& /* row */, const Text& /* column */) {
00144     return;
00145   }
00146   void deleteAllTs(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* timestamp */) {
00147     return;
00148   }
00149   void deleteAllRow(const Text& /* tableName */, const Text& /* row */) {
00150     return;
00151   }
00152   void deleteAllRowTs(const Text& /* tableName */, const Text& /* row */, const int64_t /* timestamp */) {
00153     return;
00154   }
00155   ScannerID scannerOpenWithScan(const Text& /* tableName */, const TScan& /* scan */) {
00156     ScannerID _return = 0;
00157     return _return;
00158   }
00159   ScannerID scannerOpen(const Text& /* tableName */, const Text& /* startRow */, const std::vector<Text> & /* columns */) {
00160     ScannerID _return = 0;
00161     return _return;
00162   }
00163   ScannerID scannerOpenWithStop(const Text& /* tableName */, const Text& /* startRow */, const Text& /* stopRow */, const std::vector<Text> & /* columns */) {
00164     ScannerID _return = 0;
00165     return _return;
00166   }
00167   ScannerID scannerOpenWithPrefix(const Text& /* tableName */, const Text& /* startAndPrefix */, const std::vector<Text> & /* columns */) {
00168     ScannerID _return = 0;
00169     return _return;
00170   }
00171   ScannerID scannerOpenTs(const Text& /* tableName */, const Text& /* startRow */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */) {
00172     ScannerID _return = 0;
00173     return _return;
00174   }
00175   ScannerID scannerOpenWithStopTs(const Text& /* tableName */, const Text& /* startRow */, const Text& /* stopRow */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */) {
00176     ScannerID _return = 0;
00177     return _return;
00178   }
00179   void scannerGet(std::vector<TRowResult> & /* _return */, const ScannerID /* id */) {
00180     return;
00181   }
00182   void scannerGetList(std::vector<TRowResult> & /* _return */, const ScannerID /* id */, const int32_t /* nbRows */) {
00183     return;
00184   }
00185   void scannerClose(const ScannerID /* id */) {
00186     return;
00187   }
00188   void getRowOrBefore(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* family */) {
00189     return;
00190   }
00191   void getRegionInfo(TRegionInfo& /* _return */, const Text& /* row */) {
00192     return;
00193   }
00194 };
00195 
00196 typedef struct _Hbase_enableTable_args__isset {
00197   _Hbase_enableTable_args__isset() : tableName(false) {}
00198   bool tableName;
00199 } _Hbase_enableTable_args__isset;
00200 
00201 class Hbase_enableTable_args {
00202  public:
00203 
00204   Hbase_enableTable_args() : tableName("") {
00205   }
00206 
00207   virtual ~Hbase_enableTable_args() throw() {}
00208 
00209   Bytes tableName;
00210 
00211   _Hbase_enableTable_args__isset __isset;
00212 
00213   void __set_tableName(const Bytes& val) {
00214     tableName = val;
00215   }
00216 
00217   bool operator == (const Hbase_enableTable_args & rhs) const
00218   {
00219     if (!(tableName == rhs.tableName))
00220       return false;
00221     return true;
00222   }
00223   bool operator != (const Hbase_enableTable_args &rhs) const {
00224     return !(*this == rhs);
00225   }
00226 
00227   bool operator < (const Hbase_enableTable_args & ) const;
00228 
00229   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00230   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00231 
00232 };
00233 
00234 
00235 class Hbase_enableTable_pargs {
00236  public:
00237 
00238 
00239   virtual ~Hbase_enableTable_pargs() throw() {}
00240 
00241   const Bytes* tableName;
00242 
00243   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00244 
00245 };
00246 
00247 typedef struct _Hbase_enableTable_result__isset {
00248   _Hbase_enableTable_result__isset() : io(false) {}
00249   bool io;
00250 } _Hbase_enableTable_result__isset;
00251 
00252 class Hbase_enableTable_result {
00253  public:
00254 
00255   Hbase_enableTable_result() {
00256   }
00257 
00258   virtual ~Hbase_enableTable_result() throw() {}
00259 
00260   IOError io;
00261 
00262   _Hbase_enableTable_result__isset __isset;
00263 
00264   void __set_io(const IOError& val) {
00265     io = val;
00266   }
00267 
00268   bool operator == (const Hbase_enableTable_result & rhs) const
00269   {
00270     if (!(io == rhs.io))
00271       return false;
00272     return true;
00273   }
00274   bool operator != (const Hbase_enableTable_result &rhs) const {
00275     return !(*this == rhs);
00276   }
00277 
00278   bool operator < (const Hbase_enableTable_result & ) const;
00279 
00280   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00281   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00282 
00283 };
00284 
00285 typedef struct _Hbase_enableTable_presult__isset {
00286   _Hbase_enableTable_presult__isset() : io(false) {}
00287   bool io;
00288 } _Hbase_enableTable_presult__isset;
00289 
00290 class Hbase_enableTable_presult {
00291  public:
00292 
00293 
00294   virtual ~Hbase_enableTable_presult() throw() {}
00295 
00296   IOError io;
00297 
00298   _Hbase_enableTable_presult__isset __isset;
00299 
00300   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00301 
00302 };
00303 
00304 typedef struct _Hbase_disableTable_args__isset {
00305   _Hbase_disableTable_args__isset() : tableName(false) {}
00306   bool tableName;
00307 } _Hbase_disableTable_args__isset;
00308 
00309 class Hbase_disableTable_args {
00310  public:
00311 
00312   Hbase_disableTable_args() : tableName("") {
00313   }
00314 
00315   virtual ~Hbase_disableTable_args() throw() {}
00316 
00317   Bytes tableName;
00318 
00319   _Hbase_disableTable_args__isset __isset;
00320 
00321   void __set_tableName(const Bytes& val) {
00322     tableName = val;
00323   }
00324 
00325   bool operator == (const Hbase_disableTable_args & rhs) const
00326   {
00327     if (!(tableName == rhs.tableName))
00328       return false;
00329     return true;
00330   }
00331   bool operator != (const Hbase_disableTable_args &rhs) const {
00332     return !(*this == rhs);
00333   }
00334 
00335   bool operator < (const Hbase_disableTable_args & ) const;
00336 
00337   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00338   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00339 
00340 };
00341 
00342 
00343 class Hbase_disableTable_pargs {
00344  public:
00345 
00346 
00347   virtual ~Hbase_disableTable_pargs() throw() {}
00348 
00349   const Bytes* tableName;
00350 
00351   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00352 
00353 };
00354 
00355 typedef struct _Hbase_disableTable_result__isset {
00356   _Hbase_disableTable_result__isset() : io(false) {}
00357   bool io;
00358 } _Hbase_disableTable_result__isset;
00359 
00360 class Hbase_disableTable_result {
00361  public:
00362 
00363   Hbase_disableTable_result() {
00364   }
00365 
00366   virtual ~Hbase_disableTable_result() throw() {}
00367 
00368   IOError io;
00369 
00370   _Hbase_disableTable_result__isset __isset;
00371 
00372   void __set_io(const IOError& val) {
00373     io = val;
00374   }
00375 
00376   bool operator == (const Hbase_disableTable_result & rhs) const
00377   {
00378     if (!(io == rhs.io))
00379       return false;
00380     return true;
00381   }
00382   bool operator != (const Hbase_disableTable_result &rhs) const {
00383     return !(*this == rhs);
00384   }
00385 
00386   bool operator < (const Hbase_disableTable_result & ) const;
00387 
00388   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00389   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00390 
00391 };
00392 
00393 typedef struct _Hbase_disableTable_presult__isset {
00394   _Hbase_disableTable_presult__isset() : io(false) {}
00395   bool io;
00396 } _Hbase_disableTable_presult__isset;
00397 
00398 class Hbase_disableTable_presult {
00399  public:
00400 
00401 
00402   virtual ~Hbase_disableTable_presult() throw() {}
00403 
00404   IOError io;
00405 
00406   _Hbase_disableTable_presult__isset __isset;
00407 
00408   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00409 
00410 };
00411 
00412 typedef struct _Hbase_isTableEnabled_args__isset {
00413   _Hbase_isTableEnabled_args__isset() : tableName(false) {}
00414   bool tableName;
00415 } _Hbase_isTableEnabled_args__isset;
00416 
00417 class Hbase_isTableEnabled_args {
00418  public:
00419 
00420   Hbase_isTableEnabled_args() : tableName("") {
00421   }
00422 
00423   virtual ~Hbase_isTableEnabled_args() throw() {}
00424 
00425   Bytes tableName;
00426 
00427   _Hbase_isTableEnabled_args__isset __isset;
00428 
00429   void __set_tableName(const Bytes& val) {
00430     tableName = val;
00431   }
00432 
00433   bool operator == (const Hbase_isTableEnabled_args & rhs) const
00434   {
00435     if (!(tableName == rhs.tableName))
00436       return false;
00437     return true;
00438   }
00439   bool operator != (const Hbase_isTableEnabled_args &rhs) const {
00440     return !(*this == rhs);
00441   }
00442 
00443   bool operator < (const Hbase_isTableEnabled_args & ) const;
00444 
00445   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00446   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00447 
00448 };
00449 
00450 
00451 class Hbase_isTableEnabled_pargs {
00452  public:
00453 
00454 
00455   virtual ~Hbase_isTableEnabled_pargs() throw() {}
00456 
00457   const Bytes* tableName;
00458 
00459   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00460 
00461 };
00462 
00463 typedef struct _Hbase_isTableEnabled_result__isset {
00464   _Hbase_isTableEnabled_result__isset() : success(false), io(false) {}
00465   bool success;
00466   bool io;
00467 } _Hbase_isTableEnabled_result__isset;
00468 
00469 class Hbase_isTableEnabled_result {
00470  public:
00471 
00472   Hbase_isTableEnabled_result() : success(0) {
00473   }
00474 
00475   virtual ~Hbase_isTableEnabled_result() throw() {}
00476 
00477   bool success;
00478   IOError io;
00479 
00480   _Hbase_isTableEnabled_result__isset __isset;
00481 
00482   void __set_success(const bool val) {
00483     success = val;
00484   }
00485 
00486   void __set_io(const IOError& val) {
00487     io = val;
00488   }
00489 
00490   bool operator == (const Hbase_isTableEnabled_result & rhs) const
00491   {
00492     if (!(success == rhs.success))
00493       return false;
00494     if (!(io == rhs.io))
00495       return false;
00496     return true;
00497   }
00498   bool operator != (const Hbase_isTableEnabled_result &rhs) const {
00499     return !(*this == rhs);
00500   }
00501 
00502   bool operator < (const Hbase_isTableEnabled_result & ) const;
00503 
00504   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00505   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00506 
00507 };
00508 
00509 typedef struct _Hbase_isTableEnabled_presult__isset {
00510   _Hbase_isTableEnabled_presult__isset() : success(false), io(false) {}
00511   bool success;
00512   bool io;
00513 } _Hbase_isTableEnabled_presult__isset;
00514 
00515 class Hbase_isTableEnabled_presult {
00516  public:
00517 
00518 
00519   virtual ~Hbase_isTableEnabled_presult() throw() {}
00520 
00521   bool* success;
00522   IOError io;
00523 
00524   _Hbase_isTableEnabled_presult__isset __isset;
00525 
00526   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00527 
00528 };
00529 
00530 typedef struct _Hbase_compact_args__isset {
00531   _Hbase_compact_args__isset() : tableNameOrRegionName(false) {}
00532   bool tableNameOrRegionName;
00533 } _Hbase_compact_args__isset;
00534 
00535 class Hbase_compact_args {
00536  public:
00537 
00538   Hbase_compact_args() : tableNameOrRegionName("") {
00539   }
00540 
00541   virtual ~Hbase_compact_args() throw() {}
00542 
00543   Bytes tableNameOrRegionName;
00544 
00545   _Hbase_compact_args__isset __isset;
00546 
00547   void __set_tableNameOrRegionName(const Bytes& val) {
00548     tableNameOrRegionName = val;
00549   }
00550 
00551   bool operator == (const Hbase_compact_args & rhs) const
00552   {
00553     if (!(tableNameOrRegionName == rhs.tableNameOrRegionName))
00554       return false;
00555     return true;
00556   }
00557   bool operator != (const Hbase_compact_args &rhs) const {
00558     return !(*this == rhs);
00559   }
00560 
00561   bool operator < (const Hbase_compact_args & ) const;
00562 
00563   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00564   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00565 
00566 };
00567 
00568 
00569 class Hbase_compact_pargs {
00570  public:
00571 
00572 
00573   virtual ~Hbase_compact_pargs() throw() {}
00574 
00575   const Bytes* tableNameOrRegionName;
00576 
00577   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00578 
00579 };
00580 
00581 typedef struct _Hbase_compact_result__isset {
00582   _Hbase_compact_result__isset() : io(false) {}
00583   bool io;
00584 } _Hbase_compact_result__isset;
00585 
00586 class Hbase_compact_result {
00587  public:
00588 
00589   Hbase_compact_result() {
00590   }
00591 
00592   virtual ~Hbase_compact_result() throw() {}
00593 
00594   IOError io;
00595 
00596   _Hbase_compact_result__isset __isset;
00597 
00598   void __set_io(const IOError& val) {
00599     io = val;
00600   }
00601 
00602   bool operator == (const Hbase_compact_result & rhs) const
00603   {
00604     if (!(io == rhs.io))
00605       return false;
00606     return true;
00607   }
00608   bool operator != (const Hbase_compact_result &rhs) const {
00609     return !(*this == rhs);
00610   }
00611 
00612   bool operator < (const Hbase_compact_result & ) const;
00613 
00614   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00615   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00616 
00617 };
00618 
00619 typedef struct _Hbase_compact_presult__isset {
00620   _Hbase_compact_presult__isset() : io(false) {}
00621   bool io;
00622 } _Hbase_compact_presult__isset;
00623 
00624 class Hbase_compact_presult {
00625  public:
00626 
00627 
00628   virtual ~Hbase_compact_presult() throw() {}
00629 
00630   IOError io;
00631 
00632   _Hbase_compact_presult__isset __isset;
00633 
00634   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00635 
00636 };
00637 
00638 typedef struct _Hbase_majorCompact_args__isset {
00639   _Hbase_majorCompact_args__isset() : tableNameOrRegionName(false) {}
00640   bool tableNameOrRegionName;
00641 } _Hbase_majorCompact_args__isset;
00642 
00643 class Hbase_majorCompact_args {
00644  public:
00645 
00646   Hbase_majorCompact_args() : tableNameOrRegionName("") {
00647   }
00648 
00649   virtual ~Hbase_majorCompact_args() throw() {}
00650 
00651   Bytes tableNameOrRegionName;
00652 
00653   _Hbase_majorCompact_args__isset __isset;
00654 
00655   void __set_tableNameOrRegionName(const Bytes& val) {
00656     tableNameOrRegionName = val;
00657   }
00658 
00659   bool operator == (const Hbase_majorCompact_args & rhs) const
00660   {
00661     if (!(tableNameOrRegionName == rhs.tableNameOrRegionName))
00662       return false;
00663     return true;
00664   }
00665   bool operator != (const Hbase_majorCompact_args &rhs) const {
00666     return !(*this == rhs);
00667   }
00668 
00669   bool operator < (const Hbase_majorCompact_args & ) const;
00670 
00671   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00672   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00673 
00674 };
00675 
00676 
00677 class Hbase_majorCompact_pargs {
00678  public:
00679 
00680 
00681   virtual ~Hbase_majorCompact_pargs() throw() {}
00682 
00683   const Bytes* tableNameOrRegionName;
00684 
00685   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00686 
00687 };
00688 
00689 typedef struct _Hbase_majorCompact_result__isset {
00690   _Hbase_majorCompact_result__isset() : io(false) {}
00691   bool io;
00692 } _Hbase_majorCompact_result__isset;
00693 
00694 class Hbase_majorCompact_result {
00695  public:
00696 
00697   Hbase_majorCompact_result() {
00698   }
00699 
00700   virtual ~Hbase_majorCompact_result() throw() {}
00701 
00702   IOError io;
00703 
00704   _Hbase_majorCompact_result__isset __isset;
00705 
00706   void __set_io(const IOError& val) {
00707     io = val;
00708   }
00709 
00710   bool operator == (const Hbase_majorCompact_result & rhs) const
00711   {
00712     if (!(io == rhs.io))
00713       return false;
00714     return true;
00715   }
00716   bool operator != (const Hbase_majorCompact_result &rhs) const {
00717     return !(*this == rhs);
00718   }
00719 
00720   bool operator < (const Hbase_majorCompact_result & ) const;
00721 
00722   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00723   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00724 
00725 };
00726 
00727 typedef struct _Hbase_majorCompact_presult__isset {
00728   _Hbase_majorCompact_presult__isset() : io(false) {}
00729   bool io;
00730 } _Hbase_majorCompact_presult__isset;
00731 
00732 class Hbase_majorCompact_presult {
00733  public:
00734 
00735 
00736   virtual ~Hbase_majorCompact_presult() throw() {}
00737 
00738   IOError io;
00739 
00740   _Hbase_majorCompact_presult__isset __isset;
00741 
00742   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00743 
00744 };
00745 
00746 
00747 class Hbase_getTableNames_args {
00748  public:
00749 
00750   Hbase_getTableNames_args() {
00751   }
00752 
00753   virtual ~Hbase_getTableNames_args() throw() {}
00754 
00755 
00756   bool operator == (const Hbase_getTableNames_args & /* rhs */) const
00757   {
00758     return true;
00759   }
00760   bool operator != (const Hbase_getTableNames_args &rhs) const {
00761     return !(*this == rhs);
00762   }
00763 
00764   bool operator < (const Hbase_getTableNames_args & ) const;
00765 
00766   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00767   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00768 
00769 };
00770 
00771 
00772 class Hbase_getTableNames_pargs {
00773  public:
00774 
00775 
00776   virtual ~Hbase_getTableNames_pargs() throw() {}
00777 
00778 
00779   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00780 
00781 };
00782 
00783 typedef struct _Hbase_getTableNames_result__isset {
00784   _Hbase_getTableNames_result__isset() : success(false), io(false) {}
00785   bool success;
00786   bool io;
00787 } _Hbase_getTableNames_result__isset;
00788 
00789 class Hbase_getTableNames_result {
00790  public:
00791 
00792   Hbase_getTableNames_result() {
00793   }
00794 
00795   virtual ~Hbase_getTableNames_result() throw() {}
00796 
00797   std::vector<Text>  success;
00798   IOError io;
00799 
00800   _Hbase_getTableNames_result__isset __isset;
00801 
00802   void __set_success(const std::vector<Text> & val) {
00803     success = val;
00804   }
00805 
00806   void __set_io(const IOError& val) {
00807     io = val;
00808   }
00809 
00810   bool operator == (const Hbase_getTableNames_result & rhs) const
00811   {
00812     if (!(success == rhs.success))
00813       return false;
00814     if (!(io == rhs.io))
00815       return false;
00816     return true;
00817   }
00818   bool operator != (const Hbase_getTableNames_result &rhs) const {
00819     return !(*this == rhs);
00820   }
00821 
00822   bool operator < (const Hbase_getTableNames_result & ) const;
00823 
00824   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00825   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00826 
00827 };
00828 
00829 typedef struct _Hbase_getTableNames_presult__isset {
00830   _Hbase_getTableNames_presult__isset() : success(false), io(false) {}
00831   bool success;
00832   bool io;
00833 } _Hbase_getTableNames_presult__isset;
00834 
00835 class Hbase_getTableNames_presult {
00836  public:
00837 
00838 
00839   virtual ~Hbase_getTableNames_presult() throw() {}
00840 
00841   std::vector<Text> * success;
00842   IOError io;
00843 
00844   _Hbase_getTableNames_presult__isset __isset;
00845 
00846   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00847 
00848 };
00849 
00850 typedef struct _Hbase_getColumnDescriptors_args__isset {
00851   _Hbase_getColumnDescriptors_args__isset() : tableName(false) {}
00852   bool tableName;
00853 } _Hbase_getColumnDescriptors_args__isset;
00854 
00855 class Hbase_getColumnDescriptors_args {
00856  public:
00857 
00858   Hbase_getColumnDescriptors_args() : tableName("") {
00859   }
00860 
00861   virtual ~Hbase_getColumnDescriptors_args() throw() {}
00862 
00863   Text tableName;
00864 
00865   _Hbase_getColumnDescriptors_args__isset __isset;
00866 
00867   void __set_tableName(const Text& val) {
00868     tableName = val;
00869   }
00870 
00871   bool operator == (const Hbase_getColumnDescriptors_args & rhs) const
00872   {
00873     if (!(tableName == rhs.tableName))
00874       return false;
00875     return true;
00876   }
00877   bool operator != (const Hbase_getColumnDescriptors_args &rhs) const {
00878     return !(*this == rhs);
00879   }
00880 
00881   bool operator < (const Hbase_getColumnDescriptors_args & ) const;
00882 
00883   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00884   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00885 
00886 };
00887 
00888 
00889 class Hbase_getColumnDescriptors_pargs {
00890  public:
00891 
00892 
00893   virtual ~Hbase_getColumnDescriptors_pargs() throw() {}
00894 
00895   const Text* tableName;
00896 
00897   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00898 
00899 };
00900 
00901 typedef struct _Hbase_getColumnDescriptors_result__isset {
00902   _Hbase_getColumnDescriptors_result__isset() : success(false), io(false) {}
00903   bool success;
00904   bool io;
00905 } _Hbase_getColumnDescriptors_result__isset;
00906 
00907 class Hbase_getColumnDescriptors_result {
00908  public:
00909 
00910   Hbase_getColumnDescriptors_result() {
00911   }
00912 
00913   virtual ~Hbase_getColumnDescriptors_result() throw() {}
00914 
00915   std::map<Text, ColumnDescriptor>  success;
00916   IOError io;
00917 
00918   _Hbase_getColumnDescriptors_result__isset __isset;
00919 
00920   void __set_success(const std::map<Text, ColumnDescriptor> & val) {
00921     success = val;
00922   }
00923 
00924   void __set_io(const IOError& val) {
00925     io = val;
00926   }
00927 
00928   bool operator == (const Hbase_getColumnDescriptors_result & rhs) const
00929   {
00930     if (!(success == rhs.success))
00931       return false;
00932     if (!(io == rhs.io))
00933       return false;
00934     return true;
00935   }
00936   bool operator != (const Hbase_getColumnDescriptors_result &rhs) const {
00937     return !(*this == rhs);
00938   }
00939 
00940   bool operator < (const Hbase_getColumnDescriptors_result & ) const;
00941 
00942   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00943   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00944 
00945 };
00946 
00947 typedef struct _Hbase_getColumnDescriptors_presult__isset {
00948   _Hbase_getColumnDescriptors_presult__isset() : success(false), io(false) {}
00949   bool success;
00950   bool io;
00951 } _Hbase_getColumnDescriptors_presult__isset;
00952 
00953 class Hbase_getColumnDescriptors_presult {
00954  public:
00955 
00956 
00957   virtual ~Hbase_getColumnDescriptors_presult() throw() {}
00958 
00959   std::map<Text, ColumnDescriptor> * success;
00960   IOError io;
00961 
00962   _Hbase_getColumnDescriptors_presult__isset __isset;
00963 
00964   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00965 
00966 };
00967 
00968 typedef struct _Hbase_getTableRegions_args__isset {
00969   _Hbase_getTableRegions_args__isset() : tableName(false) {}
00970   bool tableName;
00971 } _Hbase_getTableRegions_args__isset;
00972 
00973 class Hbase_getTableRegions_args {
00974  public:
00975 
00976   Hbase_getTableRegions_args() : tableName("") {
00977   }
00978 
00979   virtual ~Hbase_getTableRegions_args() throw() {}
00980 
00981   Text tableName;
00982 
00983   _Hbase_getTableRegions_args__isset __isset;
00984 
00985   void __set_tableName(const Text& val) {
00986     tableName = val;
00987   }
00988 
00989   bool operator == (const Hbase_getTableRegions_args & rhs) const
00990   {
00991     if (!(tableName == rhs.tableName))
00992       return false;
00993     return true;
00994   }
00995   bool operator != (const Hbase_getTableRegions_args &rhs) const {
00996     return !(*this == rhs);
00997   }
00998 
00999   bool operator < (const Hbase_getTableRegions_args & ) const;
01000 
01001   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01002   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01003 
01004 };
01005 
01006 
01007 class Hbase_getTableRegions_pargs {
01008  public:
01009 
01010 
01011   virtual ~Hbase_getTableRegions_pargs() throw() {}
01012 
01013   const Text* tableName;
01014 
01015   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01016 
01017 };
01018 
01019 typedef struct _Hbase_getTableRegions_result__isset {
01020   _Hbase_getTableRegions_result__isset() : success(false), io(false) {}
01021   bool success;
01022   bool io;
01023 } _Hbase_getTableRegions_result__isset;
01024 
01025 class Hbase_getTableRegions_result {
01026  public:
01027 
01028   Hbase_getTableRegions_result() {
01029   }
01030 
01031   virtual ~Hbase_getTableRegions_result() throw() {}
01032 
01033   std::vector<TRegionInfo>  success;
01034   IOError io;
01035 
01036   _Hbase_getTableRegions_result__isset __isset;
01037 
01038   void __set_success(const std::vector<TRegionInfo> & val) {
01039     success = val;
01040   }
01041 
01042   void __set_io(const IOError& val) {
01043     io = val;
01044   }
01045 
01046   bool operator == (const Hbase_getTableRegions_result & rhs) const
01047   {
01048     if (!(success == rhs.success))
01049       return false;
01050     if (!(io == rhs.io))
01051       return false;
01052     return true;
01053   }
01054   bool operator != (const Hbase_getTableRegions_result &rhs) const {
01055     return !(*this == rhs);
01056   }
01057 
01058   bool operator < (const Hbase_getTableRegions_result & ) const;
01059 
01060   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01061   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01062 
01063 };
01064 
01065 typedef struct _Hbase_getTableRegions_presult__isset {
01066   _Hbase_getTableRegions_presult__isset() : success(false), io(false) {}
01067   bool success;
01068   bool io;
01069 } _Hbase_getTableRegions_presult__isset;
01070 
01071 class Hbase_getTableRegions_presult {
01072  public:
01073 
01074 
01075   virtual ~Hbase_getTableRegions_presult() throw() {}
01076 
01077   std::vector<TRegionInfo> * success;
01078   IOError io;
01079 
01080   _Hbase_getTableRegions_presult__isset __isset;
01081 
01082   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01083 
01084 };
01085 
01086 typedef struct _Hbase_createTable_args__isset {
01087   _Hbase_createTable_args__isset() : tableName(false), columnFamilies(false) {}
01088   bool tableName;
01089   bool columnFamilies;
01090 } _Hbase_createTable_args__isset;
01091 
01092 class Hbase_createTable_args {
01093  public:
01094 
01095   Hbase_createTable_args() : tableName("") {
01096   }
01097 
01098   virtual ~Hbase_createTable_args() throw() {}
01099 
01100   Text tableName;
01101   std::vector<ColumnDescriptor>  columnFamilies;
01102 
01103   _Hbase_createTable_args__isset __isset;
01104 
01105   void __set_tableName(const Text& val) {
01106     tableName = val;
01107   }
01108 
01109   void __set_columnFamilies(const std::vector<ColumnDescriptor> & val) {
01110     columnFamilies = val;
01111   }
01112 
01113   bool operator == (const Hbase_createTable_args & rhs) const
01114   {
01115     if (!(tableName == rhs.tableName))
01116       return false;
01117     if (!(columnFamilies == rhs.columnFamilies))
01118       return false;
01119     return true;
01120   }
01121   bool operator != (const Hbase_createTable_args &rhs) const {
01122     return !(*this == rhs);
01123   }
01124 
01125   bool operator < (const Hbase_createTable_args & ) const;
01126 
01127   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01128   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01129 
01130 };
01131 
01132 
01133 class Hbase_createTable_pargs {
01134  public:
01135 
01136 
01137   virtual ~Hbase_createTable_pargs() throw() {}
01138 
01139   const Text* tableName;
01140   const std::vector<ColumnDescriptor> * columnFamilies;
01141 
01142   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01143 
01144 };
01145 
01146 typedef struct _Hbase_createTable_result__isset {
01147   _Hbase_createTable_result__isset() : io(false), ia(false), exist(false) {}
01148   bool io;
01149   bool ia;
01150   bool exist;
01151 } _Hbase_createTable_result__isset;
01152 
01153 class Hbase_createTable_result {
01154  public:
01155 
01156   Hbase_createTable_result() {
01157   }
01158 
01159   virtual ~Hbase_createTable_result() throw() {}
01160 
01161   IOError io;
01162   IllegalArgument ia;
01163   AlreadyExists exist;
01164 
01165   _Hbase_createTable_result__isset __isset;
01166 
01167   void __set_io(const IOError& val) {
01168     io = val;
01169   }
01170 
01171   void __set_ia(const IllegalArgument& val) {
01172     ia = val;
01173   }
01174 
01175   void __set_exist(const AlreadyExists& val) {
01176     exist = val;
01177   }
01178 
01179   bool operator == (const Hbase_createTable_result & rhs) const
01180   {
01181     if (!(io == rhs.io))
01182       return false;
01183     if (!(ia == rhs.ia))
01184       return false;
01185     if (!(exist == rhs.exist))
01186       return false;
01187     return true;
01188   }
01189   bool operator != (const Hbase_createTable_result &rhs) const {
01190     return !(*this == rhs);
01191   }
01192 
01193   bool operator < (const Hbase_createTable_result & ) const;
01194 
01195   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01196   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01197 
01198 };
01199 
01200 typedef struct _Hbase_createTable_presult__isset {
01201   _Hbase_createTable_presult__isset() : io(false), ia(false), exist(false) {}
01202   bool io;
01203   bool ia;
01204   bool exist;
01205 } _Hbase_createTable_presult__isset;
01206 
01207 class Hbase_createTable_presult {
01208  public:
01209 
01210 
01211   virtual ~Hbase_createTable_presult() throw() {}
01212 
01213   IOError io;
01214   IllegalArgument ia;
01215   AlreadyExists exist;
01216 
01217   _Hbase_createTable_presult__isset __isset;
01218 
01219   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01220 
01221 };
01222 
01223 typedef struct _Hbase_deleteTable_args__isset {
01224   _Hbase_deleteTable_args__isset() : tableName(false) {}
01225   bool tableName;
01226 } _Hbase_deleteTable_args__isset;
01227 
01228 class Hbase_deleteTable_args {
01229  public:
01230 
01231   Hbase_deleteTable_args() : tableName("") {
01232   }
01233 
01234   virtual ~Hbase_deleteTable_args() throw() {}
01235 
01236   Text tableName;
01237 
01238   _Hbase_deleteTable_args__isset __isset;
01239 
01240   void __set_tableName(const Text& val) {
01241     tableName = val;
01242   }
01243 
01244   bool operator == (const Hbase_deleteTable_args & rhs) const
01245   {
01246     if (!(tableName == rhs.tableName))
01247       return false;
01248     return true;
01249   }
01250   bool operator != (const Hbase_deleteTable_args &rhs) const {
01251     return !(*this == rhs);
01252   }
01253 
01254   bool operator < (const Hbase_deleteTable_args & ) const;
01255 
01256   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01257   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01258 
01259 };
01260 
01261 
01262 class Hbase_deleteTable_pargs {
01263  public:
01264 
01265 
01266   virtual ~Hbase_deleteTable_pargs() throw() {}
01267 
01268   const Text* tableName;
01269 
01270   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01271 
01272 };
01273 
01274 typedef struct _Hbase_deleteTable_result__isset {
01275   _Hbase_deleteTable_result__isset() : io(false) {}
01276   bool io;
01277 } _Hbase_deleteTable_result__isset;
01278 
01279 class Hbase_deleteTable_result {
01280  public:
01281 
01282   Hbase_deleteTable_result() {
01283   }
01284 
01285   virtual ~Hbase_deleteTable_result() throw() {}
01286 
01287   IOError io;
01288 
01289   _Hbase_deleteTable_result__isset __isset;
01290 
01291   void __set_io(const IOError& val) {
01292     io = val;
01293   }
01294 
01295   bool operator == (const Hbase_deleteTable_result & rhs) const
01296   {
01297     if (!(io == rhs.io))
01298       return false;
01299     return true;
01300   }
01301   bool operator != (const Hbase_deleteTable_result &rhs) const {
01302     return !(*this == rhs);
01303   }
01304 
01305   bool operator < (const Hbase_deleteTable_result & ) const;
01306 
01307   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01308   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01309 
01310 };
01311 
01312 typedef struct _Hbase_deleteTable_presult__isset {
01313   _Hbase_deleteTable_presult__isset() : io(false) {}
01314   bool io;
01315 } _Hbase_deleteTable_presult__isset;
01316 
01317 class Hbase_deleteTable_presult {
01318  public:
01319 
01320 
01321   virtual ~Hbase_deleteTable_presult() throw() {}
01322 
01323   IOError io;
01324 
01325   _Hbase_deleteTable_presult__isset __isset;
01326 
01327   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01328 
01329 };
01330 
01331 typedef struct _Hbase_get_args__isset {
01332   _Hbase_get_args__isset() : tableName(false), row(false), column(false) {}
01333   bool tableName;
01334   bool row;
01335   bool column;
01336 } _Hbase_get_args__isset;
01337 
01338 class Hbase_get_args {
01339  public:
01340 
01341   Hbase_get_args() : tableName(""), row(""), column("") {
01342   }
01343 
01344   virtual ~Hbase_get_args() throw() {}
01345 
01346   Text tableName;
01347   Text row;
01348   Text column;
01349 
01350   _Hbase_get_args__isset __isset;
01351 
01352   void __set_tableName(const Text& val) {
01353     tableName = val;
01354   }
01355 
01356   void __set_row(const Text& val) {
01357     row = val;
01358   }
01359 
01360   void __set_column(const Text& val) {
01361     column = val;
01362   }
01363 
01364   bool operator == (const Hbase_get_args & rhs) const
01365   {
01366     if (!(tableName == rhs.tableName))
01367       return false;
01368     if (!(row == rhs.row))
01369       return false;
01370     if (!(column == rhs.column))
01371       return false;
01372     return true;
01373   }
01374   bool operator != (const Hbase_get_args &rhs) const {
01375     return !(*this == rhs);
01376   }
01377 
01378   bool operator < (const Hbase_get_args & ) const;
01379 
01380   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01381   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01382 
01383 };
01384 
01385 
01386 class Hbase_get_pargs {
01387  public:
01388 
01389 
01390   virtual ~Hbase_get_pargs() throw() {}
01391 
01392   const Text* tableName;
01393   const Text* row;
01394   const Text* column;
01395 
01396   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01397 
01398 };
01399 
01400 typedef struct _Hbase_get_result__isset {
01401   _Hbase_get_result__isset() : success(false), io(false) {}
01402   bool success;
01403   bool io;
01404 } _Hbase_get_result__isset;
01405 
01406 class Hbase_get_result {
01407  public:
01408 
01409   Hbase_get_result() {
01410   }
01411 
01412   virtual ~Hbase_get_result() throw() {}
01413 
01414   std::vector<TCell>  success;
01415   IOError io;
01416 
01417   _Hbase_get_result__isset __isset;
01418 
01419   void __set_success(const std::vector<TCell> & val) {
01420     success = val;
01421   }
01422 
01423   void __set_io(const IOError& val) {
01424     io = val;
01425   }
01426 
01427   bool operator == (const Hbase_get_result & rhs) const
01428   {
01429     if (!(success == rhs.success))
01430       return false;
01431     if (!(io == rhs.io))
01432       return false;
01433     return true;
01434   }
01435   bool operator != (const Hbase_get_result &rhs) const {
01436     return !(*this == rhs);
01437   }
01438 
01439   bool operator < (const Hbase_get_result & ) const;
01440 
01441   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01442   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01443 
01444 };
01445 
01446 typedef struct _Hbase_get_presult__isset {
01447   _Hbase_get_presult__isset() : success(false), io(false) {}
01448   bool success;
01449   bool io;
01450 } _Hbase_get_presult__isset;
01451 
01452 class Hbase_get_presult {
01453  public:
01454 
01455 
01456   virtual ~Hbase_get_presult() throw() {}
01457 
01458   std::vector<TCell> * success;
01459   IOError io;
01460 
01461   _Hbase_get_presult__isset __isset;
01462 
01463   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01464 
01465 };
01466 
01467 typedef struct _Hbase_getVer_args__isset {
01468   _Hbase_getVer_args__isset() : tableName(false), row(false), column(false), numVersions(false) {}
01469   bool tableName;
01470   bool row;
01471   bool column;
01472   bool numVersions;
01473 } _Hbase_getVer_args__isset;
01474 
01475 class Hbase_getVer_args {
01476  public:
01477 
01478   Hbase_getVer_args() : tableName(""), row(""), column(""), numVersions(0) {
01479   }
01480 
01481   virtual ~Hbase_getVer_args() throw() {}
01482 
01483   Text tableName;
01484   Text row;
01485   Text column;
01486   int32_t numVersions;
01487 
01488   _Hbase_getVer_args__isset __isset;
01489 
01490   void __set_tableName(const Text& val) {
01491     tableName = val;
01492   }
01493 
01494   void __set_row(const Text& val) {
01495     row = val;
01496   }
01497 
01498   void __set_column(const Text& val) {
01499     column = val;
01500   }
01501 
01502   void __set_numVersions(const int32_t val) {
01503     numVersions = val;
01504   }
01505 
01506   bool operator == (const Hbase_getVer_args & rhs) const
01507   {
01508     if (!(tableName == rhs.tableName))
01509       return false;
01510     if (!(row == rhs.row))
01511       return false;
01512     if (!(column == rhs.column))
01513       return false;
01514     if (!(numVersions == rhs.numVersions))
01515       return false;
01516     return true;
01517   }
01518   bool operator != (const Hbase_getVer_args &rhs) const {
01519     return !(*this == rhs);
01520   }
01521 
01522   bool operator < (const Hbase_getVer_args & ) const;
01523 
01524   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01525   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01526 
01527 };
01528 
01529 
01530 class Hbase_getVer_pargs {
01531  public:
01532 
01533 
01534   virtual ~Hbase_getVer_pargs() throw() {}
01535 
01536   const Text* tableName;
01537   const Text* row;
01538   const Text* column;
01539   const int32_t* numVersions;
01540 
01541   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01542 
01543 };
01544 
01545 typedef struct _Hbase_getVer_result__isset {
01546   _Hbase_getVer_result__isset() : success(false), io(false) {}
01547   bool success;
01548   bool io;
01549 } _Hbase_getVer_result__isset;
01550 
01551 class Hbase_getVer_result {
01552  public:
01553 
01554   Hbase_getVer_result() {
01555   }
01556 
01557   virtual ~Hbase_getVer_result() throw() {}
01558 
01559   std::vector<TCell>  success;
01560   IOError io;
01561 
01562   _Hbase_getVer_result__isset __isset;
01563 
01564   void __set_success(const std::vector<TCell> & val) {
01565     success = val;
01566   }
01567 
01568   void __set_io(const IOError& val) {
01569     io = val;
01570   }
01571 
01572   bool operator == (const Hbase_getVer_result & rhs) const
01573   {
01574     if (!(success == rhs.success))
01575       return false;
01576     if (!(io == rhs.io))
01577       return false;
01578     return true;
01579   }
01580   bool operator != (const Hbase_getVer_result &rhs) const {
01581     return !(*this == rhs);
01582   }
01583 
01584   bool operator < (const Hbase_getVer_result & ) const;
01585 
01586   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01587   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01588 
01589 };
01590 
01591 typedef struct _Hbase_getVer_presult__isset {
01592   _Hbase_getVer_presult__isset() : success(false), io(false) {}
01593   bool success;
01594   bool io;
01595 } _Hbase_getVer_presult__isset;
01596 
01597 class Hbase_getVer_presult {
01598  public:
01599 
01600 
01601   virtual ~Hbase_getVer_presult() throw() {}
01602 
01603   std::vector<TCell> * success;
01604   IOError io;
01605 
01606   _Hbase_getVer_presult__isset __isset;
01607 
01608   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01609 
01610 };
01611 
01612 typedef struct _Hbase_getVerTs_args__isset {
01613   _Hbase_getVerTs_args__isset() : tableName(false), row(false), column(false), timestamp(false), numVersions(false) {}
01614   bool tableName;
01615   bool row;
01616   bool column;
01617   bool timestamp;
01618   bool numVersions;
01619 } _Hbase_getVerTs_args__isset;
01620 
01621 class Hbase_getVerTs_args {
01622  public:
01623 
01624   Hbase_getVerTs_args() : tableName(""), row(""), column(""), timestamp(0), numVersions(0) {
01625   }
01626 
01627   virtual ~Hbase_getVerTs_args() throw() {}
01628 
01629   Text tableName;
01630   Text row;
01631   Text column;
01632   int64_t timestamp;
01633   int32_t numVersions;
01634 
01635   _Hbase_getVerTs_args__isset __isset;
01636 
01637   void __set_tableName(const Text& val) {
01638     tableName = val;
01639   }
01640 
01641   void __set_row(const Text& val) {
01642     row = val;
01643   }
01644 
01645   void __set_column(const Text& val) {
01646     column = val;
01647   }
01648 
01649   void __set_timestamp(const int64_t val) {
01650     timestamp = val;
01651   }
01652 
01653   void __set_numVersions(const int32_t val) {
01654     numVersions = val;
01655   }
01656 
01657   bool operator == (const Hbase_getVerTs_args & rhs) const
01658   {
01659     if (!(tableName == rhs.tableName))
01660       return false;
01661     if (!(row == rhs.row))
01662       return false;
01663     if (!(column == rhs.column))
01664       return false;
01665     if (!(timestamp == rhs.timestamp))
01666       return false;
01667     if (!(numVersions == rhs.numVersions))
01668       return false;
01669     return true;
01670   }
01671   bool operator != (const Hbase_getVerTs_args &rhs) const {
01672     return !(*this == rhs);
01673   }
01674 
01675   bool operator < (const Hbase_getVerTs_args & ) const;
01676 
01677   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01678   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01679 
01680 };
01681 
01682 
01683 class Hbase_getVerTs_pargs {
01684  public:
01685 
01686 
01687   virtual ~Hbase_getVerTs_pargs() throw() {}
01688 
01689   const Text* tableName;
01690   const Text* row;
01691   const Text* column;
01692   const int64_t* timestamp;
01693   const int32_t* numVersions;
01694 
01695   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01696 
01697 };
01698 
01699 typedef struct _Hbase_getVerTs_result__isset {
01700   _Hbase_getVerTs_result__isset() : success(false), io(false) {}
01701   bool success;
01702   bool io;
01703 } _Hbase_getVerTs_result__isset;
01704 
01705 class Hbase_getVerTs_result {
01706  public:
01707 
01708   Hbase_getVerTs_result() {
01709   }
01710 
01711   virtual ~Hbase_getVerTs_result() throw() {}
01712 
01713   std::vector<TCell>  success;
01714   IOError io;
01715 
01716   _Hbase_getVerTs_result__isset __isset;
01717 
01718   void __set_success(const std::vector<TCell> & val) {
01719     success = val;
01720   }
01721 
01722   void __set_io(const IOError& val) {
01723     io = val;
01724   }
01725 
01726   bool operator == (const Hbase_getVerTs_result & rhs) const
01727   {
01728     if (!(success == rhs.success))
01729       return false;
01730     if (!(io == rhs.io))
01731       return false;
01732     return true;
01733   }
01734   bool operator != (const Hbase_getVerTs_result &rhs) const {
01735     return !(*this == rhs);
01736   }
01737 
01738   bool operator < (const Hbase_getVerTs_result & ) const;
01739 
01740   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01741   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01742 
01743 };
01744 
01745 typedef struct _Hbase_getVerTs_presult__isset {
01746   _Hbase_getVerTs_presult__isset() : success(false), io(false) {}
01747   bool success;
01748   bool io;
01749 } _Hbase_getVerTs_presult__isset;
01750 
01751 class Hbase_getVerTs_presult {
01752  public:
01753 
01754 
01755   virtual ~Hbase_getVerTs_presult() throw() {}
01756 
01757   std::vector<TCell> * success;
01758   IOError io;
01759 
01760   _Hbase_getVerTs_presult__isset __isset;
01761 
01762   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01763 
01764 };
01765 
01766 typedef struct _Hbase_getRow_args__isset {
01767   _Hbase_getRow_args__isset() : tableName(false), row(false) {}
01768   bool tableName;
01769   bool row;
01770 } _Hbase_getRow_args__isset;
01771 
01772 class Hbase_getRow_args {
01773  public:
01774 
01775   Hbase_getRow_args() : tableName(""), row("") {
01776   }
01777 
01778   virtual ~Hbase_getRow_args() throw() {}
01779 
01780   Text tableName;
01781   Text row;
01782 
01783   _Hbase_getRow_args__isset __isset;
01784 
01785   void __set_tableName(const Text& val) {
01786     tableName = val;
01787   }
01788 
01789   void __set_row(const Text& val) {
01790     row = val;
01791   }
01792 
01793   bool operator == (const Hbase_getRow_args & rhs) const
01794   {
01795     if (!(tableName == rhs.tableName))
01796       return false;
01797     if (!(row == rhs.row))
01798       return false;
01799     return true;
01800   }
01801   bool operator != (const Hbase_getRow_args &rhs) const {
01802     return !(*this == rhs);
01803   }
01804 
01805   bool operator < (const Hbase_getRow_args & ) const;
01806 
01807   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01808   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01809 
01810 };
01811 
01812 
01813 class Hbase_getRow_pargs {
01814  public:
01815 
01816 
01817   virtual ~Hbase_getRow_pargs() throw() {}
01818 
01819   const Text* tableName;
01820   const Text* row;
01821 
01822   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01823 
01824 };
01825 
01826 typedef struct _Hbase_getRow_result__isset {
01827   _Hbase_getRow_result__isset() : success(false), io(false) {}
01828   bool success;
01829   bool io;
01830 } _Hbase_getRow_result__isset;
01831 
01832 class Hbase_getRow_result {
01833  public:
01834 
01835   Hbase_getRow_result() {
01836   }
01837 
01838   virtual ~Hbase_getRow_result() throw() {}
01839 
01840   std::vector<TRowResult>  success;
01841   IOError io;
01842 
01843   _Hbase_getRow_result__isset __isset;
01844 
01845   void __set_success(const std::vector<TRowResult> & val) {
01846     success = val;
01847   }
01848 
01849   void __set_io(const IOError& val) {
01850     io = val;
01851   }
01852 
01853   bool operator == (const Hbase_getRow_result & rhs) const
01854   {
01855     if (!(success == rhs.success))
01856       return false;
01857     if (!(io == rhs.io))
01858       return false;
01859     return true;
01860   }
01861   bool operator != (const Hbase_getRow_result &rhs) const {
01862     return !(*this == rhs);
01863   }
01864 
01865   bool operator < (const Hbase_getRow_result & ) const;
01866 
01867   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01868   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01869 
01870 };
01871 
01872 typedef struct _Hbase_getRow_presult__isset {
01873   _Hbase_getRow_presult__isset() : success(false), io(false) {}
01874   bool success;
01875   bool io;
01876 } _Hbase_getRow_presult__isset;
01877 
01878 class Hbase_getRow_presult {
01879  public:
01880 
01881 
01882   virtual ~Hbase_getRow_presult() throw() {}
01883 
01884   std::vector<TRowResult> * success;
01885   IOError io;
01886 
01887   _Hbase_getRow_presult__isset __isset;
01888 
01889   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01890 
01891 };
01892 
01893 typedef struct _Hbase_getRowWithColumns_args__isset {
01894   _Hbase_getRowWithColumns_args__isset() : tableName(false), row(false), columns(false) {}
01895   bool tableName;
01896   bool row;
01897   bool columns;
01898 } _Hbase_getRowWithColumns_args__isset;
01899 
01900 class Hbase_getRowWithColumns_args {
01901  public:
01902 
01903   Hbase_getRowWithColumns_args() : tableName(""), row("") {
01904   }
01905 
01906   virtual ~Hbase_getRowWithColumns_args() throw() {}
01907 
01908   Text tableName;
01909   Text row;
01910   std::vector<Text>  columns;
01911 
01912   _Hbase_getRowWithColumns_args__isset __isset;
01913 
01914   void __set_tableName(const Text& val) {
01915     tableName = val;
01916   }
01917 
01918   void __set_row(const Text& val) {
01919     row = val;
01920   }
01921 
01922   void __set_columns(const std::vector<Text> & val) {
01923     columns = val;
01924   }
01925 
01926   bool operator == (const Hbase_getRowWithColumns_args & rhs) const
01927   {
01928     if (!(tableName == rhs.tableName))
01929       return false;
01930     if (!(row == rhs.row))
01931       return false;
01932     if (!(columns == rhs.columns))
01933       return false;
01934     return true;
01935   }
01936   bool operator != (const Hbase_getRowWithColumns_args &rhs) const {
01937     return !(*this == rhs);
01938   }
01939 
01940   bool operator < (const Hbase_getRowWithColumns_args & ) const;
01941 
01942   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01943   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01944 
01945 };
01946 
01947 
01948 class Hbase_getRowWithColumns_pargs {
01949  public:
01950 
01951 
01952   virtual ~Hbase_getRowWithColumns_pargs() throw() {}
01953 
01954   const Text* tableName;
01955   const Text* row;
01956   const std::vector<Text> * columns;
01957 
01958   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01959 
01960 };
01961 
01962 typedef struct _Hbase_getRowWithColumns_result__isset {
01963   _Hbase_getRowWithColumns_result__isset() : success(false), io(false) {}
01964   bool success;
01965   bool io;
01966 } _Hbase_getRowWithColumns_result__isset;
01967 
01968 class Hbase_getRowWithColumns_result {
01969  public:
01970 
01971   Hbase_getRowWithColumns_result() {
01972   }
01973 
01974   virtual ~Hbase_getRowWithColumns_result() throw() {}
01975 
01976   std::vector<TRowResult>  success;
01977   IOError io;
01978 
01979   _Hbase_getRowWithColumns_result__isset __isset;
01980 
01981   void __set_success(const std::vector<TRowResult> & val) {
01982     success = val;
01983   }
01984 
01985   void __set_io(const IOError& val) {
01986     io = val;
01987   }
01988 
01989   bool operator == (const Hbase_getRowWithColumns_result & rhs) const
01990   {
01991     if (!(success == rhs.success))
01992       return false;
01993     if (!(io == rhs.io))
01994       return false;
01995     return true;
01996   }
01997   bool operator != (const Hbase_getRowWithColumns_result &rhs) const {
01998     return !(*this == rhs);
01999   }
02000 
02001   bool operator < (const Hbase_getRowWithColumns_result & ) const;
02002 
02003   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02004   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02005 
02006 };
02007 
02008 typedef struct _Hbase_getRowWithColumns_presult__isset {
02009   _Hbase_getRowWithColumns_presult__isset() : success(false), io(false) {}
02010   bool success;
02011   bool io;
02012 } _Hbase_getRowWithColumns_presult__isset;
02013 
02014 class Hbase_getRowWithColumns_presult {
02015  public:
02016 
02017 
02018   virtual ~Hbase_getRowWithColumns_presult() throw() {}
02019 
02020   std::vector<TRowResult> * success;
02021   IOError io;
02022 
02023   _Hbase_getRowWithColumns_presult__isset __isset;
02024 
02025   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02026 
02027 };
02028 
02029 typedef struct _Hbase_getRowTs_args__isset {
02030   _Hbase_getRowTs_args__isset() : tableName(false), row(false), timestamp(false) {}
02031   bool tableName;
02032   bool row;
02033   bool timestamp;
02034 } _Hbase_getRowTs_args__isset;
02035 
02036 class Hbase_getRowTs_args {
02037  public:
02038 
02039   Hbase_getRowTs_args() : tableName(""), row(""), timestamp(0) {
02040   }
02041 
02042   virtual ~Hbase_getRowTs_args() throw() {}
02043 
02044   Text tableName;
02045   Text row;
02046   int64_t timestamp;
02047 
02048   _Hbase_getRowTs_args__isset __isset;
02049 
02050   void __set_tableName(const Text& val) {
02051     tableName = val;
02052   }
02053 
02054   void __set_row(const Text& val) {
02055     row = val;
02056   }
02057 
02058   void __set_timestamp(const int64_t val) {
02059     timestamp = val;
02060   }
02061 
02062   bool operator == (const Hbase_getRowTs_args & rhs) const
02063   {
02064     if (!(tableName == rhs.tableName))
02065       return false;
02066     if (!(row == rhs.row))
02067       return false;
02068     if (!(timestamp == rhs.timestamp))
02069       return false;
02070     return true;
02071   }
02072   bool operator != (const Hbase_getRowTs_args &rhs) const {
02073     return !(*this == rhs);
02074   }
02075 
02076   bool operator < (const Hbase_getRowTs_args & ) const;
02077 
02078   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02079   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02080 
02081 };
02082 
02083 
02084 class Hbase_getRowTs_pargs {
02085  public:
02086 
02087 
02088   virtual ~Hbase_getRowTs_pargs() throw() {}
02089 
02090   const Text* tableName;
02091   const Text* row;
02092   const int64_t* timestamp;
02093 
02094   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02095 
02096 };
02097 
02098 typedef struct _Hbase_getRowTs_result__isset {
02099   _Hbase_getRowTs_result__isset() : success(false), io(false) {}
02100   bool success;
02101   bool io;
02102 } _Hbase_getRowTs_result__isset;
02103 
02104 class Hbase_getRowTs_result {
02105  public:
02106 
02107   Hbase_getRowTs_result() {
02108   }
02109 
02110   virtual ~Hbase_getRowTs_result() throw() {}
02111 
02112   std::vector<TRowResult>  success;
02113   IOError io;
02114 
02115   _Hbase_getRowTs_result__isset __isset;
02116 
02117   void __set_success(const std::vector<TRowResult> & val) {
02118     success = val;
02119   }
02120 
02121   void __set_io(const IOError& val) {
02122     io = val;
02123   }
02124 
02125   bool operator == (const Hbase_getRowTs_result & rhs) const
02126   {
02127     if (!(success == rhs.success))
02128       return false;
02129     if (!(io == rhs.io))
02130       return false;
02131     return true;
02132   }
02133   bool operator != (const Hbase_getRowTs_result &rhs) const {
02134     return !(*this == rhs);
02135   }
02136 
02137   bool operator < (const Hbase_getRowTs_result & ) const;
02138 
02139   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02140   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02141 
02142 };
02143 
02144 typedef struct _Hbase_getRowTs_presult__isset {
02145   _Hbase_getRowTs_presult__isset() : success(false), io(false) {}
02146   bool success;
02147   bool io;
02148 } _Hbase_getRowTs_presult__isset;
02149 
02150 class Hbase_getRowTs_presult {
02151  public:
02152 
02153 
02154   virtual ~Hbase_getRowTs_presult() throw() {}
02155 
02156   std::vector<TRowResult> * success;
02157   IOError io;
02158 
02159   _Hbase_getRowTs_presult__isset __isset;
02160 
02161   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02162 
02163 };
02164 
02165 typedef struct _Hbase_getRowWithColumnsTs_args__isset {
02166   _Hbase_getRowWithColumnsTs_args__isset() : tableName(false), row(false), columns(false), timestamp(false) {}
02167   bool tableName;
02168   bool row;
02169   bool columns;
02170   bool timestamp;
02171 } _Hbase_getRowWithColumnsTs_args__isset;
02172 
02173 class Hbase_getRowWithColumnsTs_args {
02174  public:
02175 
02176   Hbase_getRowWithColumnsTs_args() : tableName(""), row(""), timestamp(0) {
02177   }
02178 
02179   virtual ~Hbase_getRowWithColumnsTs_args() throw() {}
02180 
02181   Text tableName;
02182   Text row;
02183   std::vector<Text>  columns;
02184   int64_t timestamp;
02185 
02186   _Hbase_getRowWithColumnsTs_args__isset __isset;
02187 
02188   void __set_tableName(const Text& val) {
02189     tableName = val;
02190   }
02191 
02192   void __set_row(const Text& val) {
02193     row = val;
02194   }
02195 
02196   void __set_columns(const std::vector<Text> & val) {
02197     columns = val;
02198   }
02199 
02200   void __set_timestamp(const int64_t val) {
02201     timestamp = val;
02202   }
02203 
02204   bool operator == (const Hbase_getRowWithColumnsTs_args & rhs) const
02205   {
02206     if (!(tableName == rhs.tableName))
02207       return false;
02208     if (!(row == rhs.row))
02209       return false;
02210     if (!(columns == rhs.columns))
02211       return false;
02212     if (!(timestamp == rhs.timestamp))
02213       return false;
02214     return true;
02215   }
02216   bool operator != (const Hbase_getRowWithColumnsTs_args &rhs) const {
02217     return !(*this == rhs);
02218   }
02219 
02220   bool operator < (const Hbase_getRowWithColumnsTs_args & ) const;
02221 
02222   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02223   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02224 
02225 };
02226 
02227 
02228 class Hbase_getRowWithColumnsTs_pargs {
02229  public:
02230 
02231 
02232   virtual ~Hbase_getRowWithColumnsTs_pargs() throw() {}
02233 
02234   const Text* tableName;
02235   const Text* row;
02236   const std::vector<Text> * columns;
02237   const int64_t* timestamp;
02238 
02239   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02240 
02241 };
02242 
02243 typedef struct _Hbase_getRowWithColumnsTs_result__isset {
02244   _Hbase_getRowWithColumnsTs_result__isset() : success(false), io(false) {}
02245   bool success;
02246   bool io;
02247 } _Hbase_getRowWithColumnsTs_result__isset;
02248 
02249 class Hbase_getRowWithColumnsTs_result {
02250  public:
02251 
02252   Hbase_getRowWithColumnsTs_result() {
02253   }
02254 
02255   virtual ~Hbase_getRowWithColumnsTs_result() throw() {}
02256 
02257   std::vector<TRowResult>  success;
02258   IOError io;
02259 
02260   _Hbase_getRowWithColumnsTs_result__isset __isset;
02261 
02262   void __set_success(const std::vector<TRowResult> & val) {
02263     success = val;
02264   }
02265 
02266   void __set_io(const IOError& val) {
02267     io = val;
02268   }
02269 
02270   bool operator == (const Hbase_getRowWithColumnsTs_result & rhs) const
02271   {
02272     if (!(success == rhs.success))
02273       return false;
02274     if (!(io == rhs.io))
02275       return false;
02276     return true;
02277   }
02278   bool operator != (const Hbase_getRowWithColumnsTs_result &rhs) const {
02279     return !(*this == rhs);
02280   }
02281 
02282   bool operator < (const Hbase_getRowWithColumnsTs_result & ) const;
02283 
02284   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02285   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02286 
02287 };
02288 
02289 typedef struct _Hbase_getRowWithColumnsTs_presult__isset {
02290   _Hbase_getRowWithColumnsTs_presult__isset() : success(false), io(false) {}
02291   bool success;
02292   bool io;
02293 } _Hbase_getRowWithColumnsTs_presult__isset;
02294 
02295 class Hbase_getRowWithColumnsTs_presult {
02296  public:
02297 
02298 
02299   virtual ~Hbase_getRowWithColumnsTs_presult() throw() {}
02300 
02301   std::vector<TRowResult> * success;
02302   IOError io;
02303 
02304   _Hbase_getRowWithColumnsTs_presult__isset __isset;
02305 
02306   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02307 
02308 };
02309 
02310 typedef struct _Hbase_getRows_args__isset {
02311   _Hbase_getRows_args__isset() : tableName(false), rows(false) {}
02312   bool tableName;
02313   bool rows;
02314 } _Hbase_getRows_args__isset;
02315 
02316 class Hbase_getRows_args {
02317  public:
02318 
02319   Hbase_getRows_args() : tableName("") {
02320   }
02321 
02322   virtual ~Hbase_getRows_args() throw() {}
02323 
02324   Text tableName;
02325   std::vector<Text>  rows;
02326 
02327   _Hbase_getRows_args__isset __isset;
02328 
02329   void __set_tableName(const Text& val) {
02330     tableName = val;
02331   }
02332 
02333   void __set_rows(const std::vector<Text> & val) {
02334     rows = val;
02335   }
02336 
02337   bool operator == (const Hbase_getRows_args & rhs) const
02338   {
02339     if (!(tableName == rhs.tableName))
02340       return false;
02341     if (!(rows == rhs.rows))
02342       return false;
02343     return true;
02344   }
02345   bool operator != (const Hbase_getRows_args &rhs) const {
02346     return !(*this == rhs);
02347   }
02348 
02349   bool operator < (const Hbase_getRows_args & ) const;
02350 
02351   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02352   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02353 
02354 };
02355 
02356 
02357 class Hbase_getRows_pargs {
02358  public:
02359 
02360 
02361   virtual ~Hbase_getRows_pargs() throw() {}
02362 
02363   const Text* tableName;
02364   const std::vector<Text> * rows;
02365 
02366   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02367 
02368 };
02369 
02370 typedef struct _Hbase_getRows_result__isset {
02371   _Hbase_getRows_result__isset() : success(false), io(false) {}
02372   bool success;
02373   bool io;
02374 } _Hbase_getRows_result__isset;
02375 
02376 class Hbase_getRows_result {
02377  public:
02378 
02379   Hbase_getRows_result() {
02380   }
02381 
02382   virtual ~Hbase_getRows_result() throw() {}
02383 
02384   std::vector<TRowResult>  success;
02385   IOError io;
02386 
02387   _Hbase_getRows_result__isset __isset;
02388 
02389   void __set_success(const std::vector<TRowResult> & val) {
02390     success = val;
02391   }
02392 
02393   void __set_io(const IOError& val) {
02394     io = val;
02395   }
02396 
02397   bool operator == (const Hbase_getRows_result & rhs) const
02398   {
02399     if (!(success == rhs.success))
02400       return false;
02401     if (!(io == rhs.io))
02402       return false;
02403     return true;
02404   }
02405   bool operator != (const Hbase_getRows_result &rhs) const {
02406     return !(*this == rhs);
02407   }
02408 
02409   bool operator < (const Hbase_getRows_result & ) const;
02410 
02411   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02412   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02413 
02414 };
02415 
02416 typedef struct _Hbase_getRows_presult__isset {
02417   _Hbase_getRows_presult__isset() : success(false), io(false) {}
02418   bool success;
02419   bool io;
02420 } _Hbase_getRows_presult__isset;
02421 
02422 class Hbase_getRows_presult {
02423  public:
02424 
02425 
02426   virtual ~Hbase_getRows_presult() throw() {}
02427 
02428   std::vector<TRowResult> * success;
02429   IOError io;
02430 
02431   _Hbase_getRows_presult__isset __isset;
02432 
02433   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02434 
02435 };
02436 
02437 typedef struct _Hbase_getRowsWithColumns_args__isset {
02438   _Hbase_getRowsWithColumns_args__isset() : tableName(false), rows(false), columns(false) {}
02439   bool tableName;
02440   bool rows;
02441   bool columns;
02442 } _Hbase_getRowsWithColumns_args__isset;
02443 
02444 class Hbase_getRowsWithColumns_args {
02445  public:
02446 
02447   Hbase_getRowsWithColumns_args() : tableName("") {
02448   }
02449 
02450   virtual ~Hbase_getRowsWithColumns_args() throw() {}
02451 
02452   Text tableName;
02453   std::vector<Text>  rows;
02454   std::vector<Text>  columns;
02455 
02456   _Hbase_getRowsWithColumns_args__isset __isset;
02457 
02458   void __set_tableName(const Text& val) {
02459     tableName = val;
02460   }
02461 
02462   void __set_rows(const std::vector<Text> & val) {
02463     rows = val;
02464   }
02465 
02466   void __set_columns(const std::vector<Text> & val) {
02467     columns = val;
02468   }
02469 
02470   bool operator == (const Hbase_getRowsWithColumns_args & rhs) const
02471   {
02472     if (!(tableName == rhs.tableName))
02473       return false;
02474     if (!(rows == rhs.rows))
02475       return false;
02476     if (!(columns == rhs.columns))
02477       return false;
02478     return true;
02479   }
02480   bool operator != (const Hbase_getRowsWithColumns_args &rhs) const {
02481     return !(*this == rhs);
02482   }
02483 
02484   bool operator < (const Hbase_getRowsWithColumns_args & ) const;
02485 
02486   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02487   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02488 
02489 };
02490 
02491 
02492 class Hbase_getRowsWithColumns_pargs {
02493  public:
02494 
02495 
02496   virtual ~Hbase_getRowsWithColumns_pargs() throw() {}
02497 
02498   const Text* tableName;
02499   const std::vector<Text> * rows;
02500   const std::vector<Text> * columns;
02501 
02502   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02503 
02504 };
02505 
02506 typedef struct _Hbase_getRowsWithColumns_result__isset {
02507   _Hbase_getRowsWithColumns_result__isset() : success(false), io(false) {}
02508   bool success;
02509   bool io;
02510 } _Hbase_getRowsWithColumns_result__isset;
02511 
02512 class Hbase_getRowsWithColumns_result {
02513  public:
02514 
02515   Hbase_getRowsWithColumns_result() {
02516   }
02517 
02518   virtual ~Hbase_getRowsWithColumns_result() throw() {}
02519 
02520   std::vector<TRowResult>  success;
02521   IOError io;
02522 
02523   _Hbase_getRowsWithColumns_result__isset __isset;
02524 
02525   void __set_success(const std::vector<TRowResult> & val) {
02526     success = val;
02527   }
02528 
02529   void __set_io(const IOError& val) {
02530     io = val;
02531   }
02532 
02533   bool operator == (const Hbase_getRowsWithColumns_result & rhs) const
02534   {
02535     if (!(success == rhs.success))
02536       return false;
02537     if (!(io == rhs.io))
02538       return false;
02539     return true;
02540   }
02541   bool operator != (const Hbase_getRowsWithColumns_result &rhs) const {
02542     return !(*this == rhs);
02543   }
02544 
02545   bool operator < (const Hbase_getRowsWithColumns_result & ) const;
02546 
02547   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02548   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02549 
02550 };
02551 
02552 typedef struct _Hbase_getRowsWithColumns_presult__isset {
02553   _Hbase_getRowsWithColumns_presult__isset() : success(false), io(false) {}
02554   bool success;
02555   bool io;
02556 } _Hbase_getRowsWithColumns_presult__isset;
02557 
02558 class Hbase_getRowsWithColumns_presult {
02559  public:
02560 
02561 
02562   virtual ~Hbase_getRowsWithColumns_presult() throw() {}
02563 
02564   std::vector<TRowResult> * success;
02565   IOError io;
02566 
02567   _Hbase_getRowsWithColumns_presult__isset __isset;
02568 
02569   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02570 
02571 };
02572 
02573 typedef struct _Hbase_getRowsTs_args__isset {
02574   _Hbase_getRowsTs_args__isset() : tableName(false), rows(false), timestamp(false) {}
02575   bool tableName;
02576   bool rows;
02577   bool timestamp;
02578 } _Hbase_getRowsTs_args__isset;
02579 
02580 class Hbase_getRowsTs_args {
02581  public:
02582 
02583   Hbase_getRowsTs_args() : tableName(""), timestamp(0) {
02584   }
02585 
02586   virtual ~Hbase_getRowsTs_args() throw() {}
02587 
02588   Text tableName;
02589   std::vector<Text>  rows;
02590   int64_t timestamp;
02591 
02592   _Hbase_getRowsTs_args__isset __isset;
02593 
02594   void __set_tableName(const Text& val) {
02595     tableName = val;
02596   }
02597 
02598   void __set_rows(const std::vector<Text> & val) {
02599     rows = val;
02600   }
02601 
02602   void __set_timestamp(const int64_t val) {
02603     timestamp = val;
02604   }
02605 
02606   bool operator == (const Hbase_getRowsTs_args & rhs) const
02607   {
02608     if (!(tableName == rhs.tableName))
02609       return false;
02610     if (!(rows == rhs.rows))
02611       return false;
02612     if (!(timestamp == rhs.timestamp))
02613       return false;
02614     return true;
02615   }
02616   bool operator != (const Hbase_getRowsTs_args &rhs) const {
02617     return !(*this == rhs);
02618   }
02619 
02620   bool operator < (const Hbase_getRowsTs_args & ) const;
02621 
02622   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02623   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02624 
02625 };
02626 
02627 
02628 class Hbase_getRowsTs_pargs {
02629  public:
02630 
02631 
02632   virtual ~Hbase_getRowsTs_pargs() throw() {}
02633 
02634   const Text* tableName;
02635   const std::vector<Text> * rows;
02636   const int64_t* timestamp;
02637 
02638   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02639 
02640 };
02641 
02642 typedef struct _Hbase_getRowsTs_result__isset {
02643   _Hbase_getRowsTs_result__isset() : success(false), io(false) {}
02644   bool success;
02645   bool io;
02646 } _Hbase_getRowsTs_result__isset;
02647 
02648 class Hbase_getRowsTs_result {
02649  public:
02650 
02651   Hbase_getRowsTs_result() {
02652   }
02653 
02654   virtual ~Hbase_getRowsTs_result() throw() {}
02655 
02656   std::vector<TRowResult>  success;
02657   IOError io;
02658 
02659   _Hbase_getRowsTs_result__isset __isset;
02660 
02661   void __set_success(const std::vector<TRowResult> & val) {
02662     success = val;
02663   }
02664 
02665   void __set_io(const IOError& val) {
02666     io = val;
02667   }
02668 
02669   bool operator == (const Hbase_getRowsTs_result & rhs) const
02670   {
02671     if (!(success == rhs.success))
02672       return false;
02673     if (!(io == rhs.io))
02674       return false;
02675     return true;
02676   }
02677   bool operator != (const Hbase_getRowsTs_result &rhs) const {
02678     return !(*this == rhs);
02679   }
02680 
02681   bool operator < (const Hbase_getRowsTs_result & ) const;
02682 
02683   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02684   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02685 
02686 };
02687 
02688 typedef struct _Hbase_getRowsTs_presult__isset {
02689   _Hbase_getRowsTs_presult__isset() : success(false), io(false) {}
02690   bool success;
02691   bool io;
02692 } _Hbase_getRowsTs_presult__isset;
02693 
02694 class Hbase_getRowsTs_presult {
02695  public:
02696 
02697 
02698   virtual ~Hbase_getRowsTs_presult() throw() {}
02699 
02700   std::vector<TRowResult> * success;
02701   IOError io;
02702 
02703   _Hbase_getRowsTs_presult__isset __isset;
02704 
02705   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02706 
02707 };
02708 
02709 typedef struct _Hbase_getRowsWithColumnsTs_args__isset {
02710   _Hbase_getRowsWithColumnsTs_args__isset() : tableName(false), rows(false), columns(false), timestamp(false) {}
02711   bool tableName;
02712   bool rows;
02713   bool columns;
02714   bool timestamp;
02715 } _Hbase_getRowsWithColumnsTs_args__isset;
02716 
02717 class Hbase_getRowsWithColumnsTs_args {
02718  public:
02719 
02720   Hbase_getRowsWithColumnsTs_args() : tableName(""), timestamp(0) {
02721   }
02722 
02723   virtual ~Hbase_getRowsWithColumnsTs_args() throw() {}
02724 
02725   Text tableName;
02726   std::vector<Text>  rows;
02727   std::vector<Text>  columns;
02728   int64_t timestamp;
02729 
02730   _Hbase_getRowsWithColumnsTs_args__isset __isset;
02731 
02732   void __set_tableName(const Text& val) {
02733     tableName = val;
02734   }
02735 
02736   void __set_rows(const std::vector<Text> & val) {
02737     rows = val;
02738   }
02739 
02740   void __set_columns(const std::vector<Text> & val) {
02741     columns = val;
02742   }
02743 
02744   void __set_timestamp(const int64_t val) {
02745     timestamp = val;
02746   }
02747 
02748   bool operator == (const Hbase_getRowsWithColumnsTs_args & rhs) const
02749   {
02750     if (!(tableName == rhs.tableName))
02751       return false;
02752     if (!(rows == rhs.rows))
02753       return false;
02754     if (!(columns == rhs.columns))
02755       return false;
02756     if (!(timestamp == rhs.timestamp))
02757       return false;
02758     return true;
02759   }
02760   bool operator != (const Hbase_getRowsWithColumnsTs_args &rhs) const {
02761     return !(*this == rhs);
02762   }
02763 
02764   bool operator < (const Hbase_getRowsWithColumnsTs_args & ) const;
02765 
02766   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02767   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02768 
02769 };
02770 
02771 
02772 class Hbase_getRowsWithColumnsTs_pargs {
02773  public:
02774 
02775 
02776   virtual ~Hbase_getRowsWithColumnsTs_pargs() throw() {}
02777 
02778   const Text* tableName;
02779   const std::vector<Text> * rows;
02780   const std::vector<Text> * columns;
02781   const int64_t* timestamp;
02782 
02783   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02784 
02785 };
02786 
02787 typedef struct _Hbase_getRowsWithColumnsTs_result__isset {
02788   _Hbase_getRowsWithColumnsTs_result__isset() : success(false), io(false) {}
02789   bool success;
02790   bool io;
02791 } _Hbase_getRowsWithColumnsTs_result__isset;
02792 
02793 class Hbase_getRowsWithColumnsTs_result {
02794  public:
02795 
02796   Hbase_getRowsWithColumnsTs_result() {
02797   }
02798 
02799   virtual ~Hbase_getRowsWithColumnsTs_result() throw() {}
02800 
02801   std::vector<TRowResult>  success;
02802   IOError io;
02803 
02804   _Hbase_getRowsWithColumnsTs_result__isset __isset;
02805 
02806   void __set_success(const std::vector<TRowResult> & val) {
02807     success = val;
02808   }
02809 
02810   void __set_io(const IOError& val) {
02811     io = val;
02812   }
02813 
02814   bool operator == (const Hbase_getRowsWithColumnsTs_result & rhs) const
02815   {
02816     if (!(success == rhs.success))
02817       return false;
02818     if (!(io == rhs.io))
02819       return false;
02820     return true;
02821   }
02822   bool operator != (const Hbase_getRowsWithColumnsTs_result &rhs) const {
02823     return !(*this == rhs);
02824   }
02825 
02826   bool operator < (const Hbase_getRowsWithColumnsTs_result & ) const;
02827 
02828   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02829   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02830 
02831 };
02832 
02833 typedef struct _Hbase_getRowsWithColumnsTs_presult__isset {
02834   _Hbase_getRowsWithColumnsTs_presult__isset() : success(false), io(false) {}
02835   bool success;
02836   bool io;
02837 } _Hbase_getRowsWithColumnsTs_presult__isset;
02838 
02839 class Hbase_getRowsWithColumnsTs_presult {
02840  public:
02841 
02842 
02843   virtual ~Hbase_getRowsWithColumnsTs_presult() throw() {}
02844 
02845   std::vector<TRowResult> * success;
02846   IOError io;
02847 
02848   _Hbase_getRowsWithColumnsTs_presult__isset __isset;
02849 
02850   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02851 
02852 };
02853 
02854 typedef struct _Hbase_mutateRow_args__isset {
02855   _Hbase_mutateRow_args__isset() : tableName(false), row(false), mutations(false) {}
02856   bool tableName;
02857   bool row;
02858   bool mutations;
02859 } _Hbase_mutateRow_args__isset;
02860 
02861 class Hbase_mutateRow_args {
02862  public:
02863 
02864   Hbase_mutateRow_args() : tableName(""), row("") {
02865   }
02866 
02867   virtual ~Hbase_mutateRow_args() throw() {}
02868 
02869   Text tableName;
02870   Text row;
02871   std::vector<Mutation>  mutations;
02872 
02873   _Hbase_mutateRow_args__isset __isset;
02874 
02875   void __set_tableName(const Text& val) {
02876     tableName = val;
02877   }
02878 
02879   void __set_row(const Text& val) {
02880     row = val;
02881   }
02882 
02883   void __set_mutations(const std::vector<Mutation> & val) {
02884     mutations = val;
02885   }
02886 
02887   bool operator == (const Hbase_mutateRow_args & rhs) const
02888   {
02889     if (!(tableName == rhs.tableName))
02890       return false;
02891     if (!(row == rhs.row))
02892       return false;
02893     if (!(mutations == rhs.mutations))
02894       return false;
02895     return true;
02896   }
02897   bool operator != (const Hbase_mutateRow_args &rhs) const {
02898     return !(*this == rhs);
02899   }
02900 
02901   bool operator < (const Hbase_mutateRow_args & ) const;
02902 
02903   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02904   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02905 
02906 };
02907 
02908 
02909 class Hbase_mutateRow_pargs {
02910  public:
02911 
02912 
02913   virtual ~Hbase_mutateRow_pargs() throw() {}
02914 
02915   const Text* tableName;
02916   const Text* row;
02917   const std::vector<Mutation> * mutations;
02918 
02919   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02920 
02921 };
02922 
02923 typedef struct _Hbase_mutateRow_result__isset {
02924   _Hbase_mutateRow_result__isset() : io(false), ia(false) {}
02925   bool io;
02926   bool ia;
02927 } _Hbase_mutateRow_result__isset;
02928 
02929 class Hbase_mutateRow_result {
02930  public:
02931 
02932   Hbase_mutateRow_result() {
02933   }
02934 
02935   virtual ~Hbase_mutateRow_result() throw() {}
02936 
02937   IOError io;
02938   IllegalArgument ia;
02939 
02940   _Hbase_mutateRow_result__isset __isset;
02941 
02942   void __set_io(const IOError& val) {
02943     io = val;
02944   }
02945 
02946   void __set_ia(const IllegalArgument& val) {
02947     ia = val;
02948   }
02949 
02950   bool operator == (const Hbase_mutateRow_result & rhs) const
02951   {
02952     if (!(io == rhs.io))
02953       return false;
02954     if (!(ia == rhs.ia))
02955       return false;
02956     return true;
02957   }
02958   bool operator != (const Hbase_mutateRow_result &rhs) const {
02959     return !(*this == rhs);
02960   }
02961 
02962   bool operator < (const Hbase_mutateRow_result & ) const;
02963 
02964   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02965   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02966 
02967 };
02968 
02969 typedef struct _Hbase_mutateRow_presult__isset {
02970   _Hbase_mutateRow_presult__isset() : io(false), ia(false) {}
02971   bool io;
02972   bool ia;
02973 } _Hbase_mutateRow_presult__isset;
02974 
02975 class Hbase_mutateRow_presult {
02976  public:
02977 
02978 
02979   virtual ~Hbase_mutateRow_presult() throw() {}
02980 
02981   IOError io;
02982   IllegalArgument ia;
02983 
02984   _Hbase_mutateRow_presult__isset __isset;
02985 
02986   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02987 
02988 };
02989 
02990 typedef struct _Hbase_mutateRowTs_args__isset {
02991   _Hbase_mutateRowTs_args__isset() : tableName(false), row(false), mutations(false), timestamp(false) {}
02992   bool tableName;
02993   bool row;
02994   bool mutations;
02995   bool timestamp;
02996 } _Hbase_mutateRowTs_args__isset;
02997 
02998 class Hbase_mutateRowTs_args {
02999  public:
03000 
03001   Hbase_mutateRowTs_args() : tableName(""), row(""), timestamp(0) {
03002   }
03003 
03004   virtual ~Hbase_mutateRowTs_args() throw() {}
03005 
03006   Text tableName;
03007   Text row;
03008   std::vector<Mutation>  mutations;
03009   int64_t timestamp;
03010 
03011   _Hbase_mutateRowTs_args__isset __isset;
03012 
03013   void __set_tableName(const Text& val) {
03014     tableName = val;
03015   }
03016 
03017   void __set_row(const Text& val) {
03018     row = val;
03019   }
03020 
03021   void __set_mutations(const std::vector<Mutation> & val) {
03022     mutations = val;
03023   }
03024 
03025   void __set_timestamp(const int64_t val) {
03026     timestamp = val;
03027   }
03028 
03029   bool operator == (const Hbase_mutateRowTs_args & rhs) const
03030   {
03031     if (!(tableName == rhs.tableName))
03032       return false;
03033     if (!(row == rhs.row))
03034       return false;
03035     if (!(mutations == rhs.mutations))
03036       return false;
03037     if (!(timestamp == rhs.timestamp))
03038       return false;
03039     return true;
03040   }
03041   bool operator != (const Hbase_mutateRowTs_args &rhs) const {
03042     return !(*this == rhs);
03043   }
03044 
03045   bool operator < (const Hbase_mutateRowTs_args & ) const;
03046 
03047   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03048   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03049 
03050 };
03051 
03052 
03053 class Hbase_mutateRowTs_pargs {
03054  public:
03055 
03056 
03057   virtual ~Hbase_mutateRowTs_pargs() throw() {}
03058 
03059   const Text* tableName;
03060   const Text* row;
03061   const std::vector<Mutation> * mutations;
03062   const int64_t* timestamp;
03063 
03064   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03065 
03066 };
03067 
03068 typedef struct _Hbase_mutateRowTs_result__isset {
03069   _Hbase_mutateRowTs_result__isset() : io(false), ia(false) {}
03070   bool io;
03071   bool ia;
03072 } _Hbase_mutateRowTs_result__isset;
03073 
03074 class Hbase_mutateRowTs_result {
03075  public:
03076 
03077   Hbase_mutateRowTs_result() {
03078   }
03079 
03080   virtual ~Hbase_mutateRowTs_result() throw() {}
03081 
03082   IOError io;
03083   IllegalArgument ia;
03084 
03085   _Hbase_mutateRowTs_result__isset __isset;
03086 
03087   void __set_io(const IOError& val) {
03088     io = val;
03089   }
03090 
03091   void __set_ia(const IllegalArgument& val) {
03092     ia = val;
03093   }
03094 
03095   bool operator == (const Hbase_mutateRowTs_result & rhs) const
03096   {
03097     if (!(io == rhs.io))
03098       return false;
03099     if (!(ia == rhs.ia))
03100       return false;
03101     return true;
03102   }
03103   bool operator != (const Hbase_mutateRowTs_result &rhs) const {
03104     return !(*this == rhs);
03105   }
03106 
03107   bool operator < (const Hbase_mutateRowTs_result & ) const;
03108 
03109   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03110   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03111 
03112 };
03113 
03114 typedef struct _Hbase_mutateRowTs_presult__isset {
03115   _Hbase_mutateRowTs_presult__isset() : io(false), ia(false) {}
03116   bool io;
03117   bool ia;
03118 } _Hbase_mutateRowTs_presult__isset;
03119 
03120 class Hbase_mutateRowTs_presult {
03121  public:
03122 
03123 
03124   virtual ~Hbase_mutateRowTs_presult() throw() {}
03125 
03126   IOError io;
03127   IllegalArgument ia;
03128 
03129   _Hbase_mutateRowTs_presult__isset __isset;
03130 
03131   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03132 
03133 };
03134 
03135 typedef struct _Hbase_mutateRows_args__isset {
03136   _Hbase_mutateRows_args__isset() : tableName(false), rowBatches(false) {}
03137   bool tableName;
03138   bool rowBatches;
03139 } _Hbase_mutateRows_args__isset;
03140 
03141 class Hbase_mutateRows_args {
03142  public:
03143 
03144   Hbase_mutateRows_args() : tableName("") {
03145   }
03146 
03147   virtual ~Hbase_mutateRows_args() throw() {}
03148 
03149   Text tableName;
03150   std::vector<BatchMutation>  rowBatches;
03151 
03152   _Hbase_mutateRows_args__isset __isset;
03153 
03154   void __set_tableName(const Text& val) {
03155     tableName = val;
03156   }
03157 
03158   void __set_rowBatches(const std::vector<BatchMutation> & val) {
03159     rowBatches = val;
03160   }
03161 
03162   bool operator == (const Hbase_mutateRows_args & rhs) const
03163   {
03164     if (!(tableName == rhs.tableName))
03165       return false;
03166     if (!(rowBatches == rhs.rowBatches))
03167       return false;
03168     return true;
03169   }
03170   bool operator != (const Hbase_mutateRows_args &rhs) const {
03171     return !(*this == rhs);
03172   }
03173 
03174   bool operator < (const Hbase_mutateRows_args & ) const;
03175 
03176   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03177   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03178 
03179 };
03180 
03181 
03182 class Hbase_mutateRows_pargs {
03183  public:
03184 
03185 
03186   virtual ~Hbase_mutateRows_pargs() throw() {}
03187 
03188   const Text* tableName;
03189   const std::vector<BatchMutation> * rowBatches;
03190 
03191   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03192 
03193 };
03194 
03195 typedef struct _Hbase_mutateRows_result__isset {
03196   _Hbase_mutateRows_result__isset() : io(false), ia(false) {}
03197   bool io;
03198   bool ia;
03199 } _Hbase_mutateRows_result__isset;
03200 
03201 class Hbase_mutateRows_result {
03202  public:
03203 
03204   Hbase_mutateRows_result() {
03205   }
03206 
03207   virtual ~Hbase_mutateRows_result() throw() {}
03208 
03209   IOError io;
03210   IllegalArgument ia;
03211 
03212   _Hbase_mutateRows_result__isset __isset;
03213 
03214   void __set_io(const IOError& val) {
03215     io = val;
03216   }
03217 
03218   void __set_ia(const IllegalArgument& val) {
03219     ia = val;
03220   }
03221 
03222   bool operator == (const Hbase_mutateRows_result & rhs) const
03223   {
03224     if (!(io == rhs.io))
03225       return false;
03226     if (!(ia == rhs.ia))
03227       return false;
03228     return true;
03229   }
03230   bool operator != (const Hbase_mutateRows_result &rhs) const {
03231     return !(*this == rhs);
03232   }
03233 
03234   bool operator < (const Hbase_mutateRows_result & ) const;
03235 
03236   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03237   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03238 
03239 };
03240 
03241 typedef struct _Hbase_mutateRows_presult__isset {
03242   _Hbase_mutateRows_presult__isset() : io(false), ia(false) {}
03243   bool io;
03244   bool ia;
03245 } _Hbase_mutateRows_presult__isset;
03246 
03247 class Hbase_mutateRows_presult {
03248  public:
03249 
03250 
03251   virtual ~Hbase_mutateRows_presult() throw() {}
03252 
03253   IOError io;
03254   IllegalArgument ia;
03255 
03256   _Hbase_mutateRows_presult__isset __isset;
03257 
03258   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03259 
03260 };
03261 
03262 typedef struct _Hbase_mutateRowsTs_args__isset {
03263   _Hbase_mutateRowsTs_args__isset() : tableName(false), rowBatches(false), timestamp(false) {}
03264   bool tableName;
03265   bool rowBatches;
03266   bool timestamp;
03267 } _Hbase_mutateRowsTs_args__isset;
03268 
03269 class Hbase_mutateRowsTs_args {
03270  public:
03271 
03272   Hbase_mutateRowsTs_args() : tableName(""), timestamp(0) {
03273   }
03274 
03275   virtual ~Hbase_mutateRowsTs_args() throw() {}
03276 
03277   Text tableName;
03278   std::vector<BatchMutation>  rowBatches;
03279   int64_t timestamp;
03280 
03281   _Hbase_mutateRowsTs_args__isset __isset;
03282 
03283   void __set_tableName(const Text& val) {
03284     tableName = val;
03285   }
03286 
03287   void __set_rowBatches(const std::vector<BatchMutation> & val) {
03288     rowBatches = val;
03289   }
03290 
03291   void __set_timestamp(const int64_t val) {
03292     timestamp = val;
03293   }
03294 
03295   bool operator == (const Hbase_mutateRowsTs_args & rhs) const
03296   {
03297     if (!(tableName == rhs.tableName))
03298       return false;
03299     if (!(rowBatches == rhs.rowBatches))
03300       return false;
03301     if (!(timestamp == rhs.timestamp))
03302       return false;
03303     return true;
03304   }
03305   bool operator != (const Hbase_mutateRowsTs_args &rhs) const {
03306     return !(*this == rhs);
03307   }
03308 
03309   bool operator < (const Hbase_mutateRowsTs_args & ) const;
03310 
03311   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03312   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03313 
03314 };
03315 
03316 
03317 class Hbase_mutateRowsTs_pargs {
03318  public:
03319 
03320 
03321   virtual ~Hbase_mutateRowsTs_pargs() throw() {}
03322 
03323   const Text* tableName;
03324   const std::vector<BatchMutation> * rowBatches;
03325   const int64_t* timestamp;
03326 
03327   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03328 
03329 };
03330 
03331 typedef struct _Hbase_mutateRowsTs_result__isset {
03332   _Hbase_mutateRowsTs_result__isset() : io(false), ia(false) {}
03333   bool io;
03334   bool ia;
03335 } _Hbase_mutateRowsTs_result__isset;
03336 
03337 class Hbase_mutateRowsTs_result {
03338  public:
03339 
03340   Hbase_mutateRowsTs_result() {
03341   }
03342 
03343   virtual ~Hbase_mutateRowsTs_result() throw() {}
03344 
03345   IOError io;
03346   IllegalArgument ia;
03347 
03348   _Hbase_mutateRowsTs_result__isset __isset;
03349 
03350   void __set_io(const IOError& val) {
03351     io = val;
03352   }
03353 
03354   void __set_ia(const IllegalArgument& val) {
03355     ia = val;
03356   }
03357 
03358   bool operator == (const Hbase_mutateRowsTs_result & rhs) const
03359   {
03360     if (!(io == rhs.io))
03361       return false;
03362     if (!(ia == rhs.ia))
03363       return false;
03364     return true;
03365   }
03366   bool operator != (const Hbase_mutateRowsTs_result &rhs) const {
03367     return !(*this == rhs);
03368   }
03369 
03370   bool operator < (const Hbase_mutateRowsTs_result & ) const;
03371 
03372   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03373   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03374 
03375 };
03376 
03377 typedef struct _Hbase_mutateRowsTs_presult__isset {
03378   _Hbase_mutateRowsTs_presult__isset() : io(false), ia(false) {}
03379   bool io;
03380   bool ia;
03381 } _Hbase_mutateRowsTs_presult__isset;
03382 
03383 class Hbase_mutateRowsTs_presult {
03384  public:
03385 
03386 
03387   virtual ~Hbase_mutateRowsTs_presult() throw() {}
03388 
03389   IOError io;
03390   IllegalArgument ia;
03391 
03392   _Hbase_mutateRowsTs_presult__isset __isset;
03393 
03394   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03395 
03396 };
03397 
03398 typedef struct _Hbase_atomicIncrement_args__isset {
03399   _Hbase_atomicIncrement_args__isset() : tableName(false), row(false), column(false), value(false) {}
03400   bool tableName;
03401   bool row;
03402   bool column;
03403   bool value;
03404 } _Hbase_atomicIncrement_args__isset;
03405 
03406 class Hbase_atomicIncrement_args {
03407  public:
03408 
03409   Hbase_atomicIncrement_args() : tableName(""), row(""), column(""), value(0) {
03410   }
03411 
03412   virtual ~Hbase_atomicIncrement_args() throw() {}
03413 
03414   Text tableName;
03415   Text row;
03416   Text column;
03417   int64_t value;
03418 
03419   _Hbase_atomicIncrement_args__isset __isset;
03420 
03421   void __set_tableName(const Text& val) {
03422     tableName = val;
03423   }
03424 
03425   void __set_row(const Text& val) {
03426     row = val;
03427   }
03428 
03429   void __set_column(const Text& val) {
03430     column = val;
03431   }
03432 
03433   void __set_value(const int64_t val) {
03434     value = val;
03435   }
03436 
03437   bool operator == (const Hbase_atomicIncrement_args & rhs) const
03438   {
03439     if (!(tableName == rhs.tableName))
03440       return false;
03441     if (!(row == rhs.row))
03442       return false;
03443     if (!(column == rhs.column))
03444       return false;
03445     if (!(value == rhs.value))
03446       return false;
03447     return true;
03448   }
03449   bool operator != (const Hbase_atomicIncrement_args &rhs) const {
03450     return !(*this == rhs);
03451   }
03452 
03453   bool operator < (const Hbase_atomicIncrement_args & ) const;
03454 
03455   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03456   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03457 
03458 };
03459 
03460 
03461 class Hbase_atomicIncrement_pargs {
03462  public:
03463 
03464 
03465   virtual ~Hbase_atomicIncrement_pargs() throw() {}
03466 
03467   const Text* tableName;
03468   const Text* row;
03469   const Text* column;
03470   const int64_t* value;
03471 
03472   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03473 
03474 };
03475 
03476 typedef struct _Hbase_atomicIncrement_result__isset {
03477   _Hbase_atomicIncrement_result__isset() : success(false), io(false), ia(false) {}
03478   bool success;
03479   bool io;
03480   bool ia;
03481 } _Hbase_atomicIncrement_result__isset;
03482 
03483 class Hbase_atomicIncrement_result {
03484  public:
03485 
03486   Hbase_atomicIncrement_result() : success(0) {
03487   }
03488 
03489   virtual ~Hbase_atomicIncrement_result() throw() {}
03490 
03491   int64_t success;
03492   IOError io;
03493   IllegalArgument ia;
03494 
03495   _Hbase_atomicIncrement_result__isset __isset;
03496 
03497   void __set_success(const int64_t val) {
03498     success = val;
03499   }
03500 
03501   void __set_io(const IOError& val) {
03502     io = val;
03503   }
03504 
03505   void __set_ia(const IllegalArgument& val) {
03506     ia = val;
03507   }
03508 
03509   bool operator == (const Hbase_atomicIncrement_result & rhs) const
03510   {
03511     if (!(success == rhs.success))
03512       return false;
03513     if (!(io == rhs.io))
03514       return false;
03515     if (!(ia == rhs.ia))
03516       return false;
03517     return true;
03518   }
03519   bool operator != (const Hbase_atomicIncrement_result &rhs) const {
03520     return !(*this == rhs);
03521   }
03522 
03523   bool operator < (const Hbase_atomicIncrement_result & ) const;
03524 
03525   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03526   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03527 
03528 };
03529 
03530 typedef struct _Hbase_atomicIncrement_presult__isset {
03531   _Hbase_atomicIncrement_presult__isset() : success(false), io(false), ia(false) {}
03532   bool success;
03533   bool io;
03534   bool ia;
03535 } _Hbase_atomicIncrement_presult__isset;
03536 
03537 class Hbase_atomicIncrement_presult {
03538  public:
03539 
03540 
03541   virtual ~Hbase_atomicIncrement_presult() throw() {}
03542 
03543   int64_t* success;
03544   IOError io;
03545   IllegalArgument ia;
03546 
03547   _Hbase_atomicIncrement_presult__isset __isset;
03548 
03549   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03550 
03551 };
03552 
03553 typedef struct _Hbase_deleteAll_args__isset {
03554   _Hbase_deleteAll_args__isset() : tableName(false), row(false), column(false) {}
03555   bool tableName;
03556   bool row;
03557   bool column;
03558 } _Hbase_deleteAll_args__isset;
03559 
03560 class Hbase_deleteAll_args {
03561  public:
03562 
03563   Hbase_deleteAll_args() : tableName(""), row(""), column("") {
03564   }
03565 
03566   virtual ~Hbase_deleteAll_args() throw() {}
03567 
03568   Text tableName;
03569   Text row;
03570   Text column;
03571 
03572   _Hbase_deleteAll_args__isset __isset;
03573 
03574   void __set_tableName(const Text& val) {
03575     tableName = val;
03576   }
03577 
03578   void __set_row(const Text& val) {
03579     row = val;
03580   }
03581 
03582   void __set_column(const Text& val) {
03583     column = val;
03584   }
03585 
03586   bool operator == (const Hbase_deleteAll_args & rhs) const
03587   {
03588     if (!(tableName == rhs.tableName))
03589       return false;
03590     if (!(row == rhs.row))
03591       return false;
03592     if (!(column == rhs.column))
03593       return false;
03594     return true;
03595   }
03596   bool operator != (const Hbase_deleteAll_args &rhs) const {
03597     return !(*this == rhs);
03598   }
03599 
03600   bool operator < (const Hbase_deleteAll_args & ) const;
03601 
03602   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03603   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03604 
03605 };
03606 
03607 
03608 class Hbase_deleteAll_pargs {
03609  public:
03610 
03611 
03612   virtual ~Hbase_deleteAll_pargs() throw() {}
03613 
03614   const Text* tableName;
03615   const Text* row;
03616   const Text* column;
03617 
03618   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03619 
03620 };
03621 
03622 typedef struct _Hbase_deleteAll_result__isset {
03623   _Hbase_deleteAll_result__isset() : io(false) {}
03624   bool io;
03625 } _Hbase_deleteAll_result__isset;
03626 
03627 class Hbase_deleteAll_result {
03628  public:
03629 
03630   Hbase_deleteAll_result() {
03631   }
03632 
03633   virtual ~Hbase_deleteAll_result() throw() {}
03634 
03635   IOError io;
03636 
03637   _Hbase_deleteAll_result__isset __isset;
03638 
03639   void __set_io(const IOError& val) {
03640     io = val;
03641   }
03642 
03643   bool operator == (const Hbase_deleteAll_result & rhs) const
03644   {
03645     if (!(io == rhs.io))
03646       return false;
03647     return true;
03648   }
03649   bool operator != (const Hbase_deleteAll_result &rhs) const {
03650     return !(*this == rhs);
03651   }
03652 
03653   bool operator < (const Hbase_deleteAll_result & ) const;
03654 
03655   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03656   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03657 
03658 };
03659 
03660 typedef struct _Hbase_deleteAll_presult__isset {
03661   _Hbase_deleteAll_presult__isset() : io(false) {}
03662   bool io;
03663 } _Hbase_deleteAll_presult__isset;
03664 
03665 class Hbase_deleteAll_presult {
03666  public:
03667 
03668 
03669   virtual ~Hbase_deleteAll_presult() throw() {}
03670 
03671   IOError io;
03672 
03673   _Hbase_deleteAll_presult__isset __isset;
03674 
03675   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03676 
03677 };
03678 
03679 typedef struct _Hbase_deleteAllTs_args__isset {
03680   _Hbase_deleteAllTs_args__isset() : tableName(false), row(false), column(false), timestamp(false) {}
03681   bool tableName;
03682   bool row;
03683   bool column;
03684   bool timestamp;
03685 } _Hbase_deleteAllTs_args__isset;
03686 
03687 class Hbase_deleteAllTs_args {
03688  public:
03689 
03690   Hbase_deleteAllTs_args() : tableName(""), row(""), column(""), timestamp(0) {
03691   }
03692 
03693   virtual ~Hbase_deleteAllTs_args() throw() {}
03694 
03695   Text tableName;
03696   Text row;
03697   Text column;
03698   int64_t timestamp;
03699 
03700   _Hbase_deleteAllTs_args__isset __isset;
03701 
03702   void __set_tableName(const Text& val) {
03703     tableName = val;
03704   }
03705 
03706   void __set_row(const Text& val) {
03707     row = val;
03708   }
03709 
03710   void __set_column(const Text& val) {
03711     column = val;
03712   }
03713 
03714   void __set_timestamp(const int64_t val) {
03715     timestamp = val;
03716   }
03717 
03718   bool operator == (const Hbase_deleteAllTs_args & rhs) const
03719   {
03720     if (!(tableName == rhs.tableName))
03721       return false;
03722     if (!(row == rhs.row))
03723       return false;
03724     if (!(column == rhs.column))
03725       return false;
03726     if (!(timestamp == rhs.timestamp))
03727       return false;
03728     return true;
03729   }
03730   bool operator != (const Hbase_deleteAllTs_args &rhs) const {
03731     return !(*this == rhs);
03732   }
03733 
03734   bool operator < (const Hbase_deleteAllTs_args & ) const;
03735 
03736   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03737   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03738 
03739 };
03740 
03741 
03742 class Hbase_deleteAllTs_pargs {
03743  public:
03744 
03745 
03746   virtual ~Hbase_deleteAllTs_pargs() throw() {}
03747 
03748   const Text* tableName;
03749   const Text* row;
03750   const Text* column;
03751   const int64_t* timestamp;
03752 
03753   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03754 
03755 };
03756 
03757 typedef struct _Hbase_deleteAllTs_result__isset {
03758   _Hbase_deleteAllTs_result__isset() : io(false) {}
03759   bool io;
03760 } _Hbase_deleteAllTs_result__isset;
03761 
03762 class Hbase_deleteAllTs_result {
03763  public:
03764 
03765   Hbase_deleteAllTs_result() {
03766   }
03767 
03768   virtual ~Hbase_deleteAllTs_result() throw() {}
03769 
03770   IOError io;
03771 
03772   _Hbase_deleteAllTs_result__isset __isset;
03773 
03774   void __set_io(const IOError& val) {
03775     io = val;
03776   }
03777 
03778   bool operator == (const Hbase_deleteAllTs_result & rhs) const
03779   {
03780     if (!(io == rhs.io))
03781       return false;
03782     return true;
03783   }
03784   bool operator != (const Hbase_deleteAllTs_result &rhs) const {
03785     return !(*this == rhs);
03786   }
03787 
03788   bool operator < (const Hbase_deleteAllTs_result & ) const;
03789 
03790   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03791   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03792 
03793 };
03794 
03795 typedef struct _Hbase_deleteAllTs_presult__isset {
03796   _Hbase_deleteAllTs_presult__isset() : io(false) {}
03797   bool io;
03798 } _Hbase_deleteAllTs_presult__isset;
03799 
03800 class Hbase_deleteAllTs_presult {
03801  public:
03802 
03803 
03804   virtual ~Hbase_deleteAllTs_presult() throw() {}
03805 
03806   IOError io;
03807 
03808   _Hbase_deleteAllTs_presult__isset __isset;
03809 
03810   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03811 
03812 };
03813 
03814 typedef struct _Hbase_deleteAllRow_args__isset {
03815   _Hbase_deleteAllRow_args__isset() : tableName(false), row(false) {}
03816   bool tableName;
03817   bool row;
03818 } _Hbase_deleteAllRow_args__isset;
03819 
03820 class Hbase_deleteAllRow_args {
03821  public:
03822 
03823   Hbase_deleteAllRow_args() : tableName(""), row("") {
03824   }
03825 
03826   virtual ~Hbase_deleteAllRow_args() throw() {}
03827 
03828   Text tableName;
03829   Text row;
03830 
03831   _Hbase_deleteAllRow_args__isset __isset;
03832 
03833   void __set_tableName(const Text& val) {
03834     tableName = val;
03835   }
03836 
03837   void __set_row(const Text& val) {
03838     row = val;
03839   }
03840 
03841   bool operator == (const Hbase_deleteAllRow_args & rhs) const
03842   {
03843     if (!(tableName == rhs.tableName))
03844       return false;
03845     if (!(row == rhs.row))
03846       return false;
03847     return true;
03848   }
03849   bool operator != (const Hbase_deleteAllRow_args &rhs) const {
03850     return !(*this == rhs);
03851   }
03852 
03853   bool operator < (const Hbase_deleteAllRow_args & ) const;
03854 
03855   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03856   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03857 
03858 };
03859 
03860 
03861 class Hbase_deleteAllRow_pargs {
03862  public:
03863 
03864 
03865   virtual ~Hbase_deleteAllRow_pargs() throw() {}
03866 
03867   const Text* tableName;
03868   const Text* row;
03869 
03870   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03871 
03872 };
03873 
03874 typedef struct _Hbase_deleteAllRow_result__isset {
03875   _Hbase_deleteAllRow_result__isset() : io(false) {}
03876   bool io;
03877 } _Hbase_deleteAllRow_result__isset;
03878 
03879 class Hbase_deleteAllRow_result {
03880  public:
03881 
03882   Hbase_deleteAllRow_result() {
03883   }
03884 
03885   virtual ~Hbase_deleteAllRow_result() throw() {}
03886 
03887   IOError io;
03888 
03889   _Hbase_deleteAllRow_result__isset __isset;
03890 
03891   void __set_io(const IOError& val) {
03892     io = val;
03893   }
03894 
03895   bool operator == (const Hbase_deleteAllRow_result & rhs) const
03896   {
03897     if (!(io == rhs.io))
03898       return false;
03899     return true;
03900   }
03901   bool operator != (const Hbase_deleteAllRow_result &rhs) const {
03902     return !(*this == rhs);
03903   }
03904 
03905   bool operator < (const Hbase_deleteAllRow_result & ) const;
03906 
03907   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03908   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03909 
03910 };
03911 
03912 typedef struct _Hbase_deleteAllRow_presult__isset {
03913   _Hbase_deleteAllRow_presult__isset() : io(false) {}
03914   bool io;
03915 } _Hbase_deleteAllRow_presult__isset;
03916 
03917 class Hbase_deleteAllRow_presult {
03918  public:
03919 
03920 
03921   virtual ~Hbase_deleteAllRow_presult() throw() {}
03922 
03923   IOError io;
03924 
03925   _Hbase_deleteAllRow_presult__isset __isset;
03926 
03927   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03928 
03929 };
03930 
03931 typedef struct _Hbase_deleteAllRowTs_args__isset {
03932   _Hbase_deleteAllRowTs_args__isset() : tableName(false), row(false), timestamp(false) {}
03933   bool tableName;
03934   bool row;
03935   bool timestamp;
03936 } _Hbase_deleteAllRowTs_args__isset;
03937 
03938 class Hbase_deleteAllRowTs_args {
03939  public:
03940 
03941   Hbase_deleteAllRowTs_args() : tableName(""), row(""), timestamp(0) {
03942   }
03943 
03944   virtual ~Hbase_deleteAllRowTs_args() throw() {}
03945 
03946   Text tableName;
03947   Text row;
03948   int64_t timestamp;
03949 
03950   _Hbase_deleteAllRowTs_args__isset __isset;
03951 
03952   void __set_tableName(const Text& val) {
03953     tableName = val;
03954   }
03955 
03956   void __set_row(const Text& val) {
03957     row = val;
03958   }
03959 
03960   void __set_timestamp(const int64_t val) {
03961     timestamp = val;
03962   }
03963 
03964   bool operator == (const Hbase_deleteAllRowTs_args & rhs) const
03965   {
03966     if (!(tableName == rhs.tableName))
03967       return false;
03968     if (!(row == rhs.row))
03969       return false;
03970     if (!(timestamp == rhs.timestamp))
03971       return false;
03972     return true;
03973   }
03974   bool operator != (const Hbase_deleteAllRowTs_args &rhs) const {
03975     return !(*this == rhs);
03976   }
03977 
03978   bool operator < (const Hbase_deleteAllRowTs_args & ) const;
03979 
03980   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03981   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03982 
03983 };
03984 
03985 
03986 class Hbase_deleteAllRowTs_pargs {
03987  public:
03988 
03989 
03990   virtual ~Hbase_deleteAllRowTs_pargs() throw() {}
03991 
03992   const Text* tableName;
03993   const Text* row;
03994   const int64_t* timestamp;
03995 
03996   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03997 
03998 };
03999 
04000 typedef struct _Hbase_deleteAllRowTs_result__isset {
04001   _Hbase_deleteAllRowTs_result__isset() : io(false) {}
04002   bool io;
04003 } _Hbase_deleteAllRowTs_result__isset;
04004 
04005 class Hbase_deleteAllRowTs_result {
04006  public:
04007 
04008   Hbase_deleteAllRowTs_result() {
04009   }
04010 
04011   virtual ~Hbase_deleteAllRowTs_result() throw() {}
04012 
04013   IOError io;
04014 
04015   _Hbase_deleteAllRowTs_result__isset __isset;
04016 
04017   void __set_io(const IOError& val) {
04018     io = val;
04019   }
04020 
04021   bool operator == (const Hbase_deleteAllRowTs_result & rhs) const
04022   {
04023     if (!(io == rhs.io))
04024       return false;
04025     return true;
04026   }
04027   bool operator != (const Hbase_deleteAllRowTs_result &rhs) const {
04028     return !(*this == rhs);
04029   }
04030 
04031   bool operator < (const Hbase_deleteAllRowTs_result & ) const;
04032 
04033   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04034   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04035 
04036 };
04037 
04038 typedef struct _Hbase_deleteAllRowTs_presult__isset {
04039   _Hbase_deleteAllRowTs_presult__isset() : io(false) {}
04040   bool io;
04041 } _Hbase_deleteAllRowTs_presult__isset;
04042 
04043 class Hbase_deleteAllRowTs_presult {
04044  public:
04045 
04046 
04047   virtual ~Hbase_deleteAllRowTs_presult() throw() {}
04048 
04049   IOError io;
04050 
04051   _Hbase_deleteAllRowTs_presult__isset __isset;
04052 
04053   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04054 
04055 };
04056 
04057 typedef struct _Hbase_scannerOpenWithScan_args__isset {
04058   _Hbase_scannerOpenWithScan_args__isset() : tableName(false), scan(false) {}
04059   bool tableName;
04060   bool scan;
04061 } _Hbase_scannerOpenWithScan_args__isset;
04062 
04063 class Hbase_scannerOpenWithScan_args {
04064  public:
04065 
04066   Hbase_scannerOpenWithScan_args() : tableName("") {
04067   }
04068 
04069   virtual ~Hbase_scannerOpenWithScan_args() throw() {}
04070 
04071   Text tableName;
04072   TScan scan;
04073 
04074   _Hbase_scannerOpenWithScan_args__isset __isset;
04075 
04076   void __set_tableName(const Text& val) {
04077     tableName = val;
04078   }
04079 
04080   void __set_scan(const TScan& val) {
04081     scan = val;
04082   }
04083 
04084   bool operator == (const Hbase_scannerOpenWithScan_args & rhs) const
04085   {
04086     if (!(tableName == rhs.tableName))
04087       return false;
04088     if (!(scan == rhs.scan))
04089       return false;
04090     return true;
04091   }
04092   bool operator != (const Hbase_scannerOpenWithScan_args &rhs) const {
04093     return !(*this == rhs);
04094   }
04095 
04096   bool operator < (const Hbase_scannerOpenWithScan_args & ) const;
04097 
04098   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04099   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04100 
04101 };
04102 
04103 
04104 class Hbase_scannerOpenWithScan_pargs {
04105  public:
04106 
04107 
04108   virtual ~Hbase_scannerOpenWithScan_pargs() throw() {}
04109 
04110   const Text* tableName;
04111   const TScan* scan;
04112 
04113   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04114 
04115 };
04116 
04117 typedef struct _Hbase_scannerOpenWithScan_result__isset {
04118   _Hbase_scannerOpenWithScan_result__isset() : success(false), io(false) {}
04119   bool success;
04120   bool io;
04121 } _Hbase_scannerOpenWithScan_result__isset;
04122 
04123 class Hbase_scannerOpenWithScan_result {
04124  public:
04125 
04126   Hbase_scannerOpenWithScan_result() : success(0) {
04127   }
04128 
04129   virtual ~Hbase_scannerOpenWithScan_result() throw() {}
04130 
04131   ScannerID success;
04132   IOError io;
04133 
04134   _Hbase_scannerOpenWithScan_result__isset __isset;
04135 
04136   void __set_success(const ScannerID val) {
04137     success = val;
04138   }
04139 
04140   void __set_io(const IOError& val) {
04141     io = val;
04142   }
04143 
04144   bool operator == (const Hbase_scannerOpenWithScan_result & rhs) const
04145   {
04146     if (!(success == rhs.success))
04147       return false;
04148     if (!(io == rhs.io))
04149       return false;
04150     return true;
04151   }
04152   bool operator != (const Hbase_scannerOpenWithScan_result &rhs) const {
04153     return !(*this == rhs);
04154   }
04155 
04156   bool operator < (const Hbase_scannerOpenWithScan_result & ) const;
04157 
04158   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04159   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04160 
04161 };
04162 
04163 typedef struct _Hbase_scannerOpenWithScan_presult__isset {
04164   _Hbase_scannerOpenWithScan_presult__isset() : success(false), io(false) {}
04165   bool success;
04166   bool io;
04167 } _Hbase_scannerOpenWithScan_presult__isset;
04168 
04169 class Hbase_scannerOpenWithScan_presult {
04170  public:
04171 
04172 
04173   virtual ~Hbase_scannerOpenWithScan_presult() throw() {}
04174 
04175   ScannerID* success;
04176   IOError io;
04177 
04178   _Hbase_scannerOpenWithScan_presult__isset __isset;
04179 
04180   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04181 
04182 };
04183 
04184 typedef struct _Hbase_scannerOpen_args__isset {
04185   _Hbase_scannerOpen_args__isset() : tableName(false), startRow(false), columns(false) {}
04186   bool tableName;
04187   bool startRow;
04188   bool columns;
04189 } _Hbase_scannerOpen_args__isset;
04190 
04191 class Hbase_scannerOpen_args {
04192  public:
04193 
04194   Hbase_scannerOpen_args() : tableName(""), startRow("") {
04195   }
04196 
04197   virtual ~Hbase_scannerOpen_args() throw() {}
04198 
04199   Text tableName;
04200   Text startRow;
04201   std::vector<Text>  columns;
04202 
04203   _Hbase_scannerOpen_args__isset __isset;
04204 
04205   void __set_tableName(const Text& val) {
04206     tableName = val;
04207   }
04208 
04209   void __set_startRow(const Text& val) {
04210     startRow = val;
04211   }
04212 
04213   void __set_columns(const std::vector<Text> & val) {
04214     columns = val;
04215   }
04216 
04217   bool operator == (const Hbase_scannerOpen_args & rhs) const
04218   {
04219     if (!(tableName == rhs.tableName))
04220       return false;
04221     if (!(startRow == rhs.startRow))
04222       return false;
04223     if (!(columns == rhs.columns))
04224       return false;
04225     return true;
04226   }
04227   bool operator != (const Hbase_scannerOpen_args &rhs) const {
04228     return !(*this == rhs);
04229   }
04230 
04231   bool operator < (const Hbase_scannerOpen_args & ) const;
04232 
04233   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04234   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04235 
04236 };
04237 
04238 
04239 class Hbase_scannerOpen_pargs {
04240  public:
04241 
04242 
04243   virtual ~Hbase_scannerOpen_pargs() throw() {}
04244 
04245   const Text* tableName;
04246   const Text* startRow;
04247   const std::vector<Text> * columns;
04248 
04249   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04250 
04251 };
04252 
04253 typedef struct _Hbase_scannerOpen_result__isset {
04254   _Hbase_scannerOpen_result__isset() : success(false), io(false) {}
04255   bool success;
04256   bool io;
04257 } _Hbase_scannerOpen_result__isset;
04258 
04259 class Hbase_scannerOpen_result {
04260  public:
04261 
04262   Hbase_scannerOpen_result() : success(0) {
04263   }
04264 
04265   virtual ~Hbase_scannerOpen_result() throw() {}
04266 
04267   ScannerID success;
04268   IOError io;
04269 
04270   _Hbase_scannerOpen_result__isset __isset;
04271 
04272   void __set_success(const ScannerID val) {
04273     success = val;
04274   }
04275 
04276   void __set_io(const IOError& val) {
04277     io = val;
04278   }
04279 
04280   bool operator == (const Hbase_scannerOpen_result & rhs) const
04281   {
04282     if (!(success == rhs.success))
04283       return false;
04284     if (!(io == rhs.io))
04285       return false;
04286     return true;
04287   }
04288   bool operator != (const Hbase_scannerOpen_result &rhs) const {
04289     return !(*this == rhs);
04290   }
04291 
04292   bool operator < (const Hbase_scannerOpen_result & ) const;
04293 
04294   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04295   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04296 
04297 };
04298 
04299 typedef struct _Hbase_scannerOpen_presult__isset {
04300   _Hbase_scannerOpen_presult__isset() : success(false), io(false) {}
04301   bool success;
04302   bool io;
04303 } _Hbase_scannerOpen_presult__isset;
04304 
04305 class Hbase_scannerOpen_presult {
04306  public:
04307 
04308 
04309   virtual ~Hbase_scannerOpen_presult() throw() {}
04310 
04311   ScannerID* success;
04312   IOError io;
04313 
04314   _Hbase_scannerOpen_presult__isset __isset;
04315 
04316   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04317 
04318 };
04319 
04320 typedef struct _Hbase_scannerOpenWithStop_args__isset {
04321   _Hbase_scannerOpenWithStop_args__isset() : tableName(false), startRow(false), stopRow(false), columns(false) {}
04322   bool tableName;
04323   bool startRow;
04324   bool stopRow;
04325   bool columns;
04326 } _Hbase_scannerOpenWithStop_args__isset;
04327 
04328 class Hbase_scannerOpenWithStop_args {
04329  public:
04330 
04331   Hbase_scannerOpenWithStop_args() : tableName(""), startRow(""), stopRow("") {
04332   }
04333 
04334   virtual ~Hbase_scannerOpenWithStop_args() throw() {}
04335 
04336   Text tableName;
04337   Text startRow;
04338   Text stopRow;
04339   std::vector<Text>  columns;
04340 
04341   _Hbase_scannerOpenWithStop_args__isset __isset;
04342 
04343   void __set_tableName(const Text& val) {
04344     tableName = val;
04345   }
04346 
04347   void __set_startRow(const Text& val) {
04348     startRow = val;
04349   }
04350 
04351   void __set_stopRow(const Text& val) {
04352     stopRow = val;
04353   }
04354 
04355   void __set_columns(const std::vector<Text> & val) {
04356     columns = val;
04357   }
04358 
04359   bool operator == (const Hbase_scannerOpenWithStop_args & rhs) const
04360   {
04361     if (!(tableName == rhs.tableName))
04362       return false;
04363     if (!(startRow == rhs.startRow))
04364       return false;
04365     if (!(stopRow == rhs.stopRow))
04366       return false;
04367     if (!(columns == rhs.columns))
04368       return false;
04369     return true;
04370   }
04371   bool operator != (const Hbase_scannerOpenWithStop_args &rhs) const {
04372     return !(*this == rhs);
04373   }
04374 
04375   bool operator < (const Hbase_scannerOpenWithStop_args & ) const;
04376 
04377   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04378   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04379 
04380 };
04381 
04382 
04383 class Hbase_scannerOpenWithStop_pargs {
04384  public:
04385 
04386 
04387   virtual ~Hbase_scannerOpenWithStop_pargs() throw() {}
04388 
04389   const Text* tableName;
04390   const Text* startRow;
04391   const Text* stopRow;
04392   const std::vector<Text> * columns;
04393 
04394   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04395 
04396 };
04397 
04398 typedef struct _Hbase_scannerOpenWithStop_result__isset {
04399   _Hbase_scannerOpenWithStop_result__isset() : success(false), io(false) {}
04400   bool success;
04401   bool io;
04402 } _Hbase_scannerOpenWithStop_result__isset;
04403 
04404 class Hbase_scannerOpenWithStop_result {
04405  public:
04406 
04407   Hbase_scannerOpenWithStop_result() : success(0) {
04408   }
04409 
04410   virtual ~Hbase_scannerOpenWithStop_result() throw() {}
04411 
04412   ScannerID success;
04413   IOError io;
04414 
04415   _Hbase_scannerOpenWithStop_result__isset __isset;
04416 
04417   void __set_success(const ScannerID val) {
04418     success = val;
04419   }
04420 
04421   void __set_io(const IOError& val) {
04422     io = val;
04423   }
04424 
04425   bool operator == (const Hbase_scannerOpenWithStop_result & rhs) const
04426   {
04427     if (!(success == rhs.success))
04428       return false;
04429     if (!(io == rhs.io))
04430       return false;
04431     return true;
04432   }
04433   bool operator != (const Hbase_scannerOpenWithStop_result &rhs) const {
04434     return !(*this == rhs);
04435   }
04436 
04437   bool operator < (const Hbase_scannerOpenWithStop_result & ) const;
04438 
04439   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04440   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04441 
04442 };
04443 
04444 typedef struct _Hbase_scannerOpenWithStop_presult__isset {
04445   _Hbase_scannerOpenWithStop_presult__isset() : success(false), io(false) {}
04446   bool success;
04447   bool io;
04448 } _Hbase_scannerOpenWithStop_presult__isset;
04449 
04450 class Hbase_scannerOpenWithStop_presult {
04451  public:
04452 
04453 
04454   virtual ~Hbase_scannerOpenWithStop_presult() throw() {}
04455 
04456   ScannerID* success;
04457   IOError io;
04458 
04459   _Hbase_scannerOpenWithStop_presult__isset __isset;
04460 
04461   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04462 
04463 };
04464 
04465 typedef struct _Hbase_scannerOpenWithPrefix_args__isset {
04466   _Hbase_scannerOpenWithPrefix_args__isset() : tableName(false), startAndPrefix(false), columns(false) {}
04467   bool tableName;
04468   bool startAndPrefix;
04469   bool columns;
04470 } _Hbase_scannerOpenWithPrefix_args__isset;
04471 
04472 class Hbase_scannerOpenWithPrefix_args {
04473  public:
04474 
04475   Hbase_scannerOpenWithPrefix_args() : tableName(""), startAndPrefix("") {
04476   }
04477 
04478   virtual ~Hbase_scannerOpenWithPrefix_args() throw() {}
04479 
04480   Text tableName;
04481   Text startAndPrefix;
04482   std::vector<Text>  columns;
04483 
04484   _Hbase_scannerOpenWithPrefix_args__isset __isset;
04485 
04486   void __set_tableName(const Text& val) {
04487     tableName = val;
04488   }
04489 
04490   void __set_startAndPrefix(const Text& val) {
04491     startAndPrefix = val;
04492   }
04493 
04494   void __set_columns(const std::vector<Text> & val) {
04495     columns = val;
04496   }
04497 
04498   bool operator == (const Hbase_scannerOpenWithPrefix_args & rhs) const
04499   {
04500     if (!(tableName == rhs.tableName))
04501       return false;
04502     if (!(startAndPrefix == rhs.startAndPrefix))
04503       return false;
04504     if (!(columns == rhs.columns))
04505       return false;
04506     return true;
04507   }
04508   bool operator != (const Hbase_scannerOpenWithPrefix_args &rhs) const {
04509     return !(*this == rhs);
04510   }
04511 
04512   bool operator < (const Hbase_scannerOpenWithPrefix_args & ) const;
04513 
04514   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04515   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04516 
04517 };
04518 
04519 
04520 class Hbase_scannerOpenWithPrefix_pargs {
04521  public:
04522 
04523 
04524   virtual ~Hbase_scannerOpenWithPrefix_pargs() throw() {}
04525 
04526   const Text* tableName;
04527   const Text* startAndPrefix;
04528   const std::vector<Text> * columns;
04529 
04530   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04531 
04532 };
04533 
04534 typedef struct _Hbase_scannerOpenWithPrefix_result__isset {
04535   _Hbase_scannerOpenWithPrefix_result__isset() : success(false), io(false) {}
04536   bool success;
04537   bool io;
04538 } _Hbase_scannerOpenWithPrefix_result__isset;
04539 
04540 class Hbase_scannerOpenWithPrefix_result {
04541  public:
04542 
04543   Hbase_scannerOpenWithPrefix_result() : success(0) {
04544   }
04545 
04546   virtual ~Hbase_scannerOpenWithPrefix_result() throw() {}
04547 
04548   ScannerID success;
04549   IOError io;
04550 
04551   _Hbase_scannerOpenWithPrefix_result__isset __isset;
04552 
04553   void __set_success(const ScannerID val) {
04554     success = val;
04555   }
04556 
04557   void __set_io(const IOError& val) {
04558     io = val;
04559   }
04560 
04561   bool operator == (const Hbase_scannerOpenWithPrefix_result & rhs) const
04562   {
04563     if (!(success == rhs.success))
04564       return false;
04565     if (!(io == rhs.io))
04566       return false;
04567     return true;
04568   }
04569   bool operator != (const Hbase_scannerOpenWithPrefix_result &rhs) const {
04570     return !(*this == rhs);
04571   }
04572 
04573   bool operator < (const Hbase_scannerOpenWithPrefix_result & ) const;
04574 
04575   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04576   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04577 
04578 };
04579 
04580 typedef struct _Hbase_scannerOpenWithPrefix_presult__isset {
04581   _Hbase_scannerOpenWithPrefix_presult__isset() : success(false), io(false) {}
04582   bool success;
04583   bool io;
04584 } _Hbase_scannerOpenWithPrefix_presult__isset;
04585 
04586 class Hbase_scannerOpenWithPrefix_presult {
04587  public:
04588 
04589 
04590   virtual ~Hbase_scannerOpenWithPrefix_presult() throw() {}
04591 
04592   ScannerID* success;
04593   IOError io;
04594 
04595   _Hbase_scannerOpenWithPrefix_presult__isset __isset;
04596 
04597   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04598 
04599 };
04600 
04601 typedef struct _Hbase_scannerOpenTs_args__isset {
04602   _Hbase_scannerOpenTs_args__isset() : tableName(false), startRow(false), columns(false), timestamp(false) {}
04603   bool tableName;
04604   bool startRow;
04605   bool columns;
04606   bool timestamp;
04607 } _Hbase_scannerOpenTs_args__isset;
04608 
04609 class Hbase_scannerOpenTs_args {
04610  public:
04611 
04612   Hbase_scannerOpenTs_args() : tableName(""), startRow(""), timestamp(0) {
04613   }
04614 
04615   virtual ~Hbase_scannerOpenTs_args() throw() {}
04616 
04617   Text tableName;
04618   Text startRow;
04619   std::vector<Text>  columns;
04620   int64_t timestamp;
04621 
04622   _Hbase_scannerOpenTs_args__isset __isset;
04623 
04624   void __set_tableName(const Text& val) {
04625     tableName = val;
04626   }
04627 
04628   void __set_startRow(const Text& val) {
04629     startRow = val;
04630   }
04631 
04632   void __set_columns(const std::vector<Text> & val) {
04633     columns = val;
04634   }
04635 
04636   void __set_timestamp(const int64_t val) {
04637     timestamp = val;
04638   }
04639 
04640   bool operator == (const Hbase_scannerOpenTs_args & rhs) const
04641   {
04642     if (!(tableName == rhs.tableName))
04643       return false;
04644     if (!(startRow == rhs.startRow))
04645       return false;
04646     if (!(columns == rhs.columns))
04647       return false;
04648     if (!(timestamp == rhs.timestamp))
04649       return false;
04650     return true;
04651   }
04652   bool operator != (const Hbase_scannerOpenTs_args &rhs) const {
04653     return !(*this == rhs);
04654   }
04655 
04656   bool operator < (const Hbase_scannerOpenTs_args & ) const;
04657 
04658   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04659   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04660 
04661 };
04662 
04663 
04664 class Hbase_scannerOpenTs_pargs {
04665  public:
04666 
04667 
04668   virtual ~Hbase_scannerOpenTs_pargs() throw() {}
04669 
04670   const Text* tableName;
04671   const Text* startRow;
04672   const std::vector<Text> * columns;
04673   const int64_t* timestamp;
04674 
04675   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04676 
04677 };
04678 
04679 typedef struct _Hbase_scannerOpenTs_result__isset {
04680   _Hbase_scannerOpenTs_result__isset() : success(false), io(false) {}
04681   bool success;
04682   bool io;
04683 } _Hbase_scannerOpenTs_result__isset;
04684 
04685 class Hbase_scannerOpenTs_result {
04686  public:
04687 
04688   Hbase_scannerOpenTs_result() : success(0) {
04689   }
04690 
04691   virtual ~Hbase_scannerOpenTs_result() throw() {}
04692 
04693   ScannerID success;
04694   IOError io;
04695 
04696   _Hbase_scannerOpenTs_result__isset __isset;
04697 
04698   void __set_success(const ScannerID val) {
04699     success = val;
04700   }
04701 
04702   void __set_io(const IOError& val) {
04703     io = val;
04704   }
04705 
04706   bool operator == (const Hbase_scannerOpenTs_result & rhs) const
04707   {
04708     if (!(success == rhs.success))
04709       return false;
04710     if (!(io == rhs.io))
04711       return false;
04712     return true;
04713   }
04714   bool operator != (const Hbase_scannerOpenTs_result &rhs) const {
04715     return !(*this == rhs);
04716   }
04717 
04718   bool operator < (const Hbase_scannerOpenTs_result & ) const;
04719 
04720   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04721   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04722 
04723 };
04724 
04725 typedef struct _Hbase_scannerOpenTs_presult__isset {
04726   _Hbase_scannerOpenTs_presult__isset() : success(false), io(false) {}
04727   bool success;
04728   bool io;
04729 } _Hbase_scannerOpenTs_presult__isset;
04730 
04731 class Hbase_scannerOpenTs_presult {
04732  public:
04733 
04734 
04735   virtual ~Hbase_scannerOpenTs_presult() throw() {}
04736 
04737   ScannerID* success;
04738   IOError io;
04739 
04740   _Hbase_scannerOpenTs_presult__isset __isset;
04741 
04742   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04743 
04744 };
04745 
04746 typedef struct _Hbase_scannerOpenWithStopTs_args__isset {
04747   _Hbase_scannerOpenWithStopTs_args__isset() : tableName(false), startRow(false), stopRow(false), columns(false), timestamp(false) {}
04748   bool tableName;
04749   bool startRow;
04750   bool stopRow;
04751   bool columns;
04752   bool timestamp;
04753 } _Hbase_scannerOpenWithStopTs_args__isset;
04754 
04755 class Hbase_scannerOpenWithStopTs_args {
04756  public:
04757 
04758   Hbase_scannerOpenWithStopTs_args() : tableName(""), startRow(""), stopRow(""), timestamp(0) {
04759   }
04760 
04761   virtual ~Hbase_scannerOpenWithStopTs_args() throw() {}
04762 
04763   Text tableName;
04764   Text startRow;
04765   Text stopRow;
04766   std::vector<Text>  columns;
04767   int64_t timestamp;
04768 
04769   _Hbase_scannerOpenWithStopTs_args__isset __isset;
04770 
04771   void __set_tableName(const Text& val) {
04772     tableName = val;
04773   }
04774 
04775   void __set_startRow(const Text& val) {
04776     startRow = val;
04777   }
04778 
04779   void __set_stopRow(const Text& val) {
04780     stopRow = val;
04781   }
04782 
04783   void __set_columns(const std::vector<Text> & val) {
04784     columns = val;
04785   }
04786 
04787   void __set_timestamp(const int64_t val) {
04788     timestamp = val;
04789   }
04790 
04791   bool operator == (const Hbase_scannerOpenWithStopTs_args & rhs) const
04792   {
04793     if (!(tableName == rhs.tableName))
04794       return false;
04795     if (!(startRow == rhs.startRow))
04796       return false;
04797     if (!(stopRow == rhs.stopRow))
04798       return false;
04799     if (!(columns == rhs.columns))
04800       return false;
04801     if (!(timestamp == rhs.timestamp))
04802       return false;
04803     return true;
04804   }
04805   bool operator != (const Hbase_scannerOpenWithStopTs_args &rhs) const {
04806     return !(*this == rhs);
04807   }
04808 
04809   bool operator < (const Hbase_scannerOpenWithStopTs_args & ) const;
04810 
04811   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04812   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04813 
04814 };
04815 
04816 
04817 class Hbase_scannerOpenWithStopTs_pargs {
04818  public:
04819 
04820 
04821   virtual ~Hbase_scannerOpenWithStopTs_pargs() throw() {}
04822 
04823   const Text* tableName;
04824   const Text* startRow;
04825   const Text* stopRow;
04826   const std::vector<Text> * columns;
04827   const int64_t* timestamp;
04828 
04829   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04830 
04831 };
04832 
04833 typedef struct _Hbase_scannerOpenWithStopTs_result__isset {
04834   _Hbase_scannerOpenWithStopTs_result__isset() : success(false), io(false) {}
04835   bool success;
04836   bool io;
04837 } _Hbase_scannerOpenWithStopTs_result__isset;
04838 
04839 class Hbase_scannerOpenWithStopTs_result {
04840  public:
04841 
04842   Hbase_scannerOpenWithStopTs_result() : success(0) {
04843   }
04844 
04845   virtual ~Hbase_scannerOpenWithStopTs_result() throw() {}
04846 
04847   ScannerID success;
04848   IOError io;
04849 
04850   _Hbase_scannerOpenWithStopTs_result__isset __isset;
04851 
04852   void __set_success(const ScannerID val) {
04853     success = val;
04854   }
04855 
04856   void __set_io(const IOError& val) {
04857     io = val;
04858   }
04859 
04860   bool operator == (const Hbase_scannerOpenWithStopTs_result & rhs) const
04861   {
04862     if (!(success == rhs.success))
04863       return false;
04864     if (!(io == rhs.io))
04865       return false;
04866     return true;
04867   }
04868   bool operator != (const Hbase_scannerOpenWithStopTs_result &rhs) const {
04869     return !(*this == rhs);
04870   }
04871 
04872   bool operator < (const Hbase_scannerOpenWithStopTs_result & ) const;
04873 
04874   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04875   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04876 
04877 };
04878 
04879 typedef struct _Hbase_scannerOpenWithStopTs_presult__isset {
04880   _Hbase_scannerOpenWithStopTs_presult__isset() : success(false), io(false) {}
04881   bool success;
04882   bool io;
04883 } _Hbase_scannerOpenWithStopTs_presult__isset;
04884 
04885 class Hbase_scannerOpenWithStopTs_presult {
04886  public:
04887 
04888 
04889   virtual ~Hbase_scannerOpenWithStopTs_presult() throw() {}
04890 
04891   ScannerID* success;
04892   IOError io;
04893 
04894   _Hbase_scannerOpenWithStopTs_presult__isset __isset;
04895 
04896   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04897 
04898 };
04899 
04900 typedef struct _Hbase_scannerGet_args__isset {
04901   _Hbase_scannerGet_args__isset() : id(false) {}
04902   bool id;
04903 } _Hbase_scannerGet_args__isset;
04904 
04905 class Hbase_scannerGet_args {
04906  public:
04907 
04908   Hbase_scannerGet_args() : id(0) {
04909   }
04910 
04911   virtual ~Hbase_scannerGet_args() throw() {}
04912 
04913   ScannerID id;
04914 
04915   _Hbase_scannerGet_args__isset __isset;
04916 
04917   void __set_id(const ScannerID val) {
04918     id = val;
04919   }
04920 
04921   bool operator == (const Hbase_scannerGet_args & rhs) const
04922   {
04923     if (!(id == rhs.id))
04924       return false;
04925     return true;
04926   }
04927   bool operator != (const Hbase_scannerGet_args &rhs) const {
04928     return !(*this == rhs);
04929   }
04930 
04931   bool operator < (const Hbase_scannerGet_args & ) const;
04932 
04933   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
04934   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04935 
04936 };
04937 
04938 
04939 class Hbase_scannerGet_pargs {
04940  public:
04941 
04942 
04943   virtual ~Hbase_scannerGet_pargs() throw() {}
04944 
04945   const ScannerID* id;
04946 
04947   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
04948 
04949 };
04950 
04951 typedef struct _Hbase_scannerGet_result__isset {
04952   _Hbase_scannerGet_result__isset() : success(false), io(false), ia(false) {}
04953   bool success;
04954   bool io;
04955   bool ia;
04956 } _Hbase_scannerGet_result__isset;
04957 
04958 class Hbase_scannerGet_result {
04959  public:
04960 
04961   Hbase_scannerGet_result() {
04962   }
04963 
04964   virtual ~Hbase_scannerGet_result() throw() {}
04965 
04966   std::vector<TRowResult>  success;
04967   IOError io;
04968   IllegalArgument ia;
04969 
04970   _Hbase_scannerGet_result__isset __isset;
04971 
04972   void __set_success(const std::vector<TRowResult> & val) {
04973     success = val;
04974   }
04975 
04976   void __set_io(const IOError& val) {
04977     io = val;
04978   }
04979 
04980   void __set_ia(const IllegalArgument& val) {
04981     ia = val;
04982   }
04983 
04984   bool operator == (const Hbase_scannerGet_result & rhs) const
04985   {
04986     if (!(success == rhs.success))
04987       return false;
04988     if (!(io == rhs.io))
04989       return false;
04990     if (!(ia == rhs.ia))
04991       return false;
04992     return true;
04993   }
04994   bool operator != (const Hbase_scannerGet_result &rhs) const {
04995     return !(*this == rhs);
04996   }
04997 
04998   bool operator < (const Hbase_scannerGet_result & ) const;
04999 
05000   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05001   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05002 
05003 };
05004 
05005 typedef struct _Hbase_scannerGet_presult__isset {
05006   _Hbase_scannerGet_presult__isset() : success(false), io(false), ia(false) {}
05007   bool success;
05008   bool io;
05009   bool ia;
05010 } _Hbase_scannerGet_presult__isset;
05011 
05012 class Hbase_scannerGet_presult {
05013  public:
05014 
05015 
05016   virtual ~Hbase_scannerGet_presult() throw() {}
05017 
05018   std::vector<TRowResult> * success;
05019   IOError io;
05020   IllegalArgument ia;
05021 
05022   _Hbase_scannerGet_presult__isset __isset;
05023 
05024   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05025 
05026 };
05027 
05028 typedef struct _Hbase_scannerGetList_args__isset {
05029   _Hbase_scannerGetList_args__isset() : id(false), nbRows(false) {}
05030   bool id;
05031   bool nbRows;
05032 } _Hbase_scannerGetList_args__isset;
05033 
05034 class Hbase_scannerGetList_args {
05035  public:
05036 
05037   Hbase_scannerGetList_args() : id(0), nbRows(0) {
05038   }
05039 
05040   virtual ~Hbase_scannerGetList_args() throw() {}
05041 
05042   ScannerID id;
05043   int32_t nbRows;
05044 
05045   _Hbase_scannerGetList_args__isset __isset;
05046 
05047   void __set_id(const ScannerID val) {
05048     id = val;
05049   }
05050 
05051   void __set_nbRows(const int32_t val) {
05052     nbRows = val;
05053   }
05054 
05055   bool operator == (const Hbase_scannerGetList_args & rhs) const
05056   {
05057     if (!(id == rhs.id))
05058       return false;
05059     if (!(nbRows == rhs.nbRows))
05060       return false;
05061     return true;
05062   }
05063   bool operator != (const Hbase_scannerGetList_args &rhs) const {
05064     return !(*this == rhs);
05065   }
05066 
05067   bool operator < (const Hbase_scannerGetList_args & ) const;
05068 
05069   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05070   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05071 
05072 };
05073 
05074 
05075 class Hbase_scannerGetList_pargs {
05076  public:
05077 
05078 
05079   virtual ~Hbase_scannerGetList_pargs() throw() {}
05080 
05081   const ScannerID* id;
05082   const int32_t* nbRows;
05083 
05084   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05085 
05086 };
05087 
05088 typedef struct _Hbase_scannerGetList_result__isset {
05089   _Hbase_scannerGetList_result__isset() : success(false), io(false), ia(false) {}
05090   bool success;
05091   bool io;
05092   bool ia;
05093 } _Hbase_scannerGetList_result__isset;
05094 
05095 class Hbase_scannerGetList_result {
05096  public:
05097 
05098   Hbase_scannerGetList_result() {
05099   }
05100 
05101   virtual ~Hbase_scannerGetList_result() throw() {}
05102 
05103   std::vector<TRowResult>  success;
05104   IOError io;
05105   IllegalArgument ia;
05106 
05107   _Hbase_scannerGetList_result__isset __isset;
05108 
05109   void __set_success(const std::vector<TRowResult> & val) {
05110     success = val;
05111   }
05112 
05113   void __set_io(const IOError& val) {
05114     io = val;
05115   }
05116 
05117   void __set_ia(const IllegalArgument& val) {
05118     ia = val;
05119   }
05120 
05121   bool operator == (const Hbase_scannerGetList_result & rhs) const
05122   {
05123     if (!(success == rhs.success))
05124       return false;
05125     if (!(io == rhs.io))
05126       return false;
05127     if (!(ia == rhs.ia))
05128       return false;
05129     return true;
05130   }
05131   bool operator != (const Hbase_scannerGetList_result &rhs) const {
05132     return !(*this == rhs);
05133   }
05134 
05135   bool operator < (const Hbase_scannerGetList_result & ) const;
05136 
05137   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05138   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05139 
05140 };
05141 
05142 typedef struct _Hbase_scannerGetList_presult__isset {
05143   _Hbase_scannerGetList_presult__isset() : success(false), io(false), ia(false) {}
05144   bool success;
05145   bool io;
05146   bool ia;
05147 } _Hbase_scannerGetList_presult__isset;
05148 
05149 class Hbase_scannerGetList_presult {
05150  public:
05151 
05152 
05153   virtual ~Hbase_scannerGetList_presult() throw() {}
05154 
05155   std::vector<TRowResult> * success;
05156   IOError io;
05157   IllegalArgument ia;
05158 
05159   _Hbase_scannerGetList_presult__isset __isset;
05160 
05161   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05162 
05163 };
05164 
05165 typedef struct _Hbase_scannerClose_args__isset {
05166   _Hbase_scannerClose_args__isset() : id(false) {}
05167   bool id;
05168 } _Hbase_scannerClose_args__isset;
05169 
05170 class Hbase_scannerClose_args {
05171  public:
05172 
05173   Hbase_scannerClose_args() : id(0) {
05174   }
05175 
05176   virtual ~Hbase_scannerClose_args() throw() {}
05177 
05178   ScannerID id;
05179 
05180   _Hbase_scannerClose_args__isset __isset;
05181 
05182   void __set_id(const ScannerID val) {
05183     id = val;
05184   }
05185 
05186   bool operator == (const Hbase_scannerClose_args & rhs) const
05187   {
05188     if (!(id == rhs.id))
05189       return false;
05190     return true;
05191   }
05192   bool operator != (const Hbase_scannerClose_args &rhs) const {
05193     return !(*this == rhs);
05194   }
05195 
05196   bool operator < (const Hbase_scannerClose_args & ) const;
05197 
05198   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05199   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05200 
05201 };
05202 
05203 
05204 class Hbase_scannerClose_pargs {
05205  public:
05206 
05207 
05208   virtual ~Hbase_scannerClose_pargs() throw() {}
05209 
05210   const ScannerID* id;
05211 
05212   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05213 
05214 };
05215 
05216 typedef struct _Hbase_scannerClose_result__isset {
05217   _Hbase_scannerClose_result__isset() : io(false), ia(false) {}
05218   bool io;
05219   bool ia;
05220 } _Hbase_scannerClose_result__isset;
05221 
05222 class Hbase_scannerClose_result {
05223  public:
05224 
05225   Hbase_scannerClose_result() {
05226   }
05227 
05228   virtual ~Hbase_scannerClose_result() throw() {}
05229 
05230   IOError io;
05231   IllegalArgument ia;
05232 
05233   _Hbase_scannerClose_result__isset __isset;
05234 
05235   void __set_io(const IOError& val) {
05236     io = val;
05237   }
05238 
05239   void __set_ia(const IllegalArgument& val) {
05240     ia = val;
05241   }
05242 
05243   bool operator == (const Hbase_scannerClose_result & rhs) const
05244   {
05245     if (!(io == rhs.io))
05246       return false;
05247     if (!(ia == rhs.ia))
05248       return false;
05249     return true;
05250   }
05251   bool operator != (const Hbase_scannerClose_result &rhs) const {
05252     return !(*this == rhs);
05253   }
05254 
05255   bool operator < (const Hbase_scannerClose_result & ) const;
05256 
05257   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05258   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05259 
05260 };
05261 
05262 typedef struct _Hbase_scannerClose_presult__isset {
05263   _Hbase_scannerClose_presult__isset() : io(false), ia(false) {}
05264   bool io;
05265   bool ia;
05266 } _Hbase_scannerClose_presult__isset;
05267 
05268 class Hbase_scannerClose_presult {
05269  public:
05270 
05271 
05272   virtual ~Hbase_scannerClose_presult() throw() {}
05273 
05274   IOError io;
05275   IllegalArgument ia;
05276 
05277   _Hbase_scannerClose_presult__isset __isset;
05278 
05279   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05280 
05281 };
05282 
05283 typedef struct _Hbase_getRowOrBefore_args__isset {
05284   _Hbase_getRowOrBefore_args__isset() : tableName(false), row(false), family(false) {}
05285   bool tableName;
05286   bool row;
05287   bool family;
05288 } _Hbase_getRowOrBefore_args__isset;
05289 
05290 class Hbase_getRowOrBefore_args {
05291  public:
05292 
05293   Hbase_getRowOrBefore_args() : tableName(""), row(""), family("") {
05294   }
05295 
05296   virtual ~Hbase_getRowOrBefore_args() throw() {}
05297 
05298   Text tableName;
05299   Text row;
05300   Text family;
05301 
05302   _Hbase_getRowOrBefore_args__isset __isset;
05303 
05304   void __set_tableName(const Text& val) {
05305     tableName = val;
05306   }
05307 
05308   void __set_row(const Text& val) {
05309     row = val;
05310   }
05311 
05312   void __set_family(const Text& val) {
05313     family = val;
05314   }
05315 
05316   bool operator == (const Hbase_getRowOrBefore_args & rhs) const
05317   {
05318     if (!(tableName == rhs.tableName))
05319       return false;
05320     if (!(row == rhs.row))
05321       return false;
05322     if (!(family == rhs.family))
05323       return false;
05324     return true;
05325   }
05326   bool operator != (const Hbase_getRowOrBefore_args &rhs) const {
05327     return !(*this == rhs);
05328   }
05329 
05330   bool operator < (const Hbase_getRowOrBefore_args & ) const;
05331 
05332   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05333   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05334 
05335 };
05336 
05337 
05338 class Hbase_getRowOrBefore_pargs {
05339  public:
05340 
05341 
05342   virtual ~Hbase_getRowOrBefore_pargs() throw() {}
05343 
05344   const Text* tableName;
05345   const Text* row;
05346   const Text* family;
05347 
05348   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05349 
05350 };
05351 
05352 typedef struct _Hbase_getRowOrBefore_result__isset {
05353   _Hbase_getRowOrBefore_result__isset() : success(false), io(false) {}
05354   bool success;
05355   bool io;
05356 } _Hbase_getRowOrBefore_result__isset;
05357 
05358 class Hbase_getRowOrBefore_result {
05359  public:
05360 
05361   Hbase_getRowOrBefore_result() {
05362   }
05363 
05364   virtual ~Hbase_getRowOrBefore_result() throw() {}
05365 
05366   std::vector<TCell>  success;
05367   IOError io;
05368 
05369   _Hbase_getRowOrBefore_result__isset __isset;
05370 
05371   void __set_success(const std::vector<TCell> & val) {
05372     success = val;
05373   }
05374 
05375   void __set_io(const IOError& val) {
05376     io = val;
05377   }
05378 
05379   bool operator == (const Hbase_getRowOrBefore_result & rhs) const
05380   {
05381     if (!(success == rhs.success))
05382       return false;
05383     if (!(io == rhs.io))
05384       return false;
05385     return true;
05386   }
05387   bool operator != (const Hbase_getRowOrBefore_result &rhs) const {
05388     return !(*this == rhs);
05389   }
05390 
05391   bool operator < (const Hbase_getRowOrBefore_result & ) const;
05392 
05393   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05394   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05395 
05396 };
05397 
05398 typedef struct _Hbase_getRowOrBefore_presult__isset {
05399   _Hbase_getRowOrBefore_presult__isset() : success(false), io(false) {}
05400   bool success;
05401   bool io;
05402 } _Hbase_getRowOrBefore_presult__isset;
05403 
05404 class Hbase_getRowOrBefore_presult {
05405  public:
05406 
05407 
05408   virtual ~Hbase_getRowOrBefore_presult() throw() {}
05409 
05410   std::vector<TCell> * success;
05411   IOError io;
05412 
05413   _Hbase_getRowOrBefore_presult__isset __isset;
05414 
05415   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05416 
05417 };
05418 
05419 typedef struct _Hbase_getRegionInfo_args__isset {
05420   _Hbase_getRegionInfo_args__isset() : row(false) {}
05421   bool row;
05422 } _Hbase_getRegionInfo_args__isset;
05423 
05424 class Hbase_getRegionInfo_args {
05425  public:
05426 
05427   Hbase_getRegionInfo_args() : row("") {
05428   }
05429 
05430   virtual ~Hbase_getRegionInfo_args() throw() {}
05431 
05432   Text row;
05433 
05434   _Hbase_getRegionInfo_args__isset __isset;
05435 
05436   void __set_row(const Text& val) {
05437     row = val;
05438   }
05439 
05440   bool operator == (const Hbase_getRegionInfo_args & rhs) const
05441   {
05442     if (!(row == rhs.row))
05443       return false;
05444     return true;
05445   }
05446   bool operator != (const Hbase_getRegionInfo_args &rhs) const {
05447     return !(*this == rhs);
05448   }
05449 
05450   bool operator < (const Hbase_getRegionInfo_args & ) const;
05451 
05452   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05453   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05454 
05455 };
05456 
05457 
05458 class Hbase_getRegionInfo_pargs {
05459  public:
05460 
05461 
05462   virtual ~Hbase_getRegionInfo_pargs() throw() {}
05463 
05464   const Text* row;
05465 
05466   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05467 
05468 };
05469 
05470 typedef struct _Hbase_getRegionInfo_result__isset {
05471   _Hbase_getRegionInfo_result__isset() : success(false), io(false) {}
05472   bool success;
05473   bool io;
05474 } _Hbase_getRegionInfo_result__isset;
05475 
05476 class Hbase_getRegionInfo_result {
05477  public:
05478 
05479   Hbase_getRegionInfo_result() {
05480   }
05481 
05482   virtual ~Hbase_getRegionInfo_result() throw() {}
05483 
05484   TRegionInfo success;
05485   IOError io;
05486 
05487   _Hbase_getRegionInfo_result__isset __isset;
05488 
05489   void __set_success(const TRegionInfo& val) {
05490     success = val;
05491   }
05492 
05493   void __set_io(const IOError& val) {
05494     io = val;
05495   }
05496 
05497   bool operator == (const Hbase_getRegionInfo_result & rhs) const
05498   {
05499     if (!(success == rhs.success))
05500       return false;
05501     if (!(io == rhs.io))
05502       return false;
05503     return true;
05504   }
05505   bool operator != (const Hbase_getRegionInfo_result &rhs) const {
05506     return !(*this == rhs);
05507   }
05508 
05509   bool operator < (const Hbase_getRegionInfo_result & ) const;
05510 
05511   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05512   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
05513 
05514 };
05515 
05516 typedef struct _Hbase_getRegionInfo_presult__isset {
05517   _Hbase_getRegionInfo_presult__isset() : success(false), io(false) {}
05518   bool success;
05519   bool io;
05520 } _Hbase_getRegionInfo_presult__isset;
05521 
05522 class Hbase_getRegionInfo_presult {
05523  public:
05524 
05525 
05526   virtual ~Hbase_getRegionInfo_presult() throw() {}
05527 
05528   TRegionInfo* success;
05529   IOError io;
05530 
05531   _Hbase_getRegionInfo_presult__isset __isset;
05532 
05533   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
05534 
05535 };
05536 
05537 class HbaseClient : virtual public HbaseIf {
05538  public:
05539   HbaseClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
05540     piprot_(prot),
05541     poprot_(prot) {
05542     iprot_ = prot.get();
05543     oprot_ = prot.get();
05544   }
05545   HbaseClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
05546     piprot_(iprot),
05547     poprot_(oprot) {
05548     iprot_ = iprot.get();
05549     oprot_ = oprot.get();
05550   }
05551   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
05552     return piprot_;
05553   }
05554   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
05555     return poprot_;
05556   }
05557   void enableTable(const Bytes& tableName);
05558   void send_enableTable(const Bytes& tableName);
05559   void recv_enableTable();
05560   void disableTable(const Bytes& tableName);
05561   void send_disableTable(const Bytes& tableName);
05562   void recv_disableTable();
05563   bool isTableEnabled(const Bytes& tableName);
05564   void send_isTableEnabled(const Bytes& tableName);
05565   bool recv_isTableEnabled();
05566   void compact(const Bytes& tableNameOrRegionName);
05567   void send_compact(const Bytes& tableNameOrRegionName);
05568   void recv_compact();
05569   void majorCompact(const Bytes& tableNameOrRegionName);
05570   void send_majorCompact(const Bytes& tableNameOrRegionName);
05571   void recv_majorCompact();
05572   void getTableNames(std::vector<Text> & _return);
05573   void send_getTableNames();
05574   void recv_getTableNames(std::vector<Text> & _return);
05575   void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName);
05576   void send_getColumnDescriptors(const Text& tableName);
05577   void recv_getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return);
05578   void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName);
05579   void send_getTableRegions(const Text& tableName);
05580   void recv_getTableRegions(std::vector<TRegionInfo> & _return);
05581   void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies);
05582   void send_createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies);
05583   void recv_createTable();
05584   void deleteTable(const Text& tableName);
05585   void send_deleteTable(const Text& tableName);
05586   void recv_deleteTable();
05587   void get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column);
05588   void send_get(const Text& tableName, const Text& row, const Text& column);
05589   void recv_get(std::vector<TCell> & _return);
05590   void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions);
05591   void send_getVer(const Text& tableName, const Text& row, const Text& column, const int32_t numVersions);
05592   void recv_getVer(std::vector<TCell> & _return);
05593   void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions);
05594   void send_getVerTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions);
05595   void recv_getVerTs(std::vector<TCell> & _return);
05596   void getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row);
05597   void send_getRow(const Text& tableName, const Text& row);
05598   void recv_getRow(std::vector<TRowResult> & _return);
05599   void getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns);
05600   void send_getRowWithColumns(const Text& tableName, const Text& row, const std::vector<Text> & columns);
05601   void recv_getRowWithColumns(std::vector<TRowResult> & _return);
05602   void getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp);
05603   void send_getRowTs(const Text& tableName, const Text& row, const int64_t timestamp);
05604   void recv_getRowTs(std::vector<TRowResult> & _return);
05605   void getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp);
05606   void send_getRowWithColumnsTs(const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp);
05607   void recv_getRowWithColumnsTs(std::vector<TRowResult> & _return);
05608   void getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows);
05609   void send_getRows(const Text& tableName, const std::vector<Text> & rows);
05610   void recv_getRows(std::vector<TRowResult> & _return);
05611   void getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns);
05612   void send_getRowsWithColumns(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns);
05613   void recv_getRowsWithColumns(std::vector<TRowResult> & _return);
05614   void getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp);
05615   void send_getRowsTs(const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp);
05616   void recv_getRowsTs(std::vector<TRowResult> & _return);
05617   void getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp);
05618   void send_getRowsWithColumnsTs(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp);
05619   void recv_getRowsWithColumnsTs(std::vector<TRowResult> & _return);
05620   void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations);
05621   void send_mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations);
05622   void recv_mutateRow();
05623   void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp);
05624   void send_mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp);
05625   void recv_mutateRowTs();
05626   void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches);
05627   void send_mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches);
05628   void recv_mutateRows();
05629   void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp);
05630   void send_mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp);
05631   void recv_mutateRowsTs();
05632   int64_t atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value);
05633   void send_atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value);
05634   int64_t recv_atomicIncrement();
05635   void deleteAll(const Text& tableName, const Text& row, const Text& column);
05636   void send_deleteAll(const Text& tableName, const Text& row, const Text& column);
05637   void recv_deleteAll();
05638   void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp);
05639   void send_deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp);
05640   void recv_deleteAllTs();
05641   void deleteAllRow(const Text& tableName, const Text& row);
05642   void send_deleteAllRow(const Text& tableName, const Text& row);
05643   void recv_deleteAllRow();
05644   void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp);
05645   void send_deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp);
05646   void recv_deleteAllRowTs();
05647   ScannerID scannerOpenWithScan(const Text& tableName, const TScan& scan);
05648   void send_scannerOpenWithScan(const Text& tableName, const TScan& scan);
05649   ScannerID recv_scannerOpenWithScan();
05650   ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns);
05651   void send_scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns);
05652   ScannerID recv_scannerOpen();
05653   ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns);
05654   void send_scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns);
05655   ScannerID recv_scannerOpenWithStop();
05656   ScannerID scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns);
05657   void send_scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns);
05658   ScannerID recv_scannerOpenWithPrefix();
05659   ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp);
05660   void send_scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp);
05661   ScannerID recv_scannerOpenTs();
05662   ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp);
05663   void send_scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp);
05664   ScannerID recv_scannerOpenWithStopTs();
05665   void scannerGet(std::vector<TRowResult> & _return, const ScannerID id);
05666   void send_scannerGet(const ScannerID id);
05667   void recv_scannerGet(std::vector<TRowResult> & _return);
05668   void scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows);
05669   void send_scannerGetList(const ScannerID id, const int32_t nbRows);
05670   void recv_scannerGetList(std::vector<TRowResult> & _return);
05671   void scannerClose(const ScannerID id);
05672   void send_scannerClose(const ScannerID id);
05673   void recv_scannerClose();
05674   void getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family);
05675   void send_getRowOrBefore(const Text& tableName, const Text& row, const Text& family);
05676   void recv_getRowOrBefore(std::vector<TCell> & _return);
05677   void getRegionInfo(TRegionInfo& _return, const Text& row);
05678   void send_getRegionInfo(const Text& row);
05679   void recv_getRegionInfo(TRegionInfo& _return);
05680  protected:
05681   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
05682   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
05683   ::apache::thrift::protocol::TProtocol* iprot_;
05684   ::apache::thrift::protocol::TProtocol* oprot_;
05685 };
05686 
05687 class HbaseProcessor : virtual public ::apache::thrift::TProcessor {
05688  protected:
05689   boost::shared_ptr<HbaseIf> iface_;
05690   virtual bool process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid, void* callContext);
05691  private:
05692   std::map<std::string, void (HbaseProcessor::*)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*)> processMap_;
05693   void process_enableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05694   void process_disableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05695   void process_isTableEnabled(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05696   void process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05697   void process_majorCompact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05698   void process_getTableNames(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05699   void process_getColumnDescriptors(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05700   void process_getTableRegions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05701   void process_createTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05702   void process_deleteTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05703   void process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05704   void process_getVer(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05705   void process_getVerTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05706   void process_getRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05707   void process_getRowWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05708   void process_getRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05709   void process_getRowWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05710   void process_getRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05711   void process_getRowsWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05712   void process_getRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05713   void process_getRowsWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05714   void process_mutateRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05715   void process_mutateRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05716   void process_mutateRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05717   void process_mutateRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05718   void process_atomicIncrement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05719   void process_deleteAll(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05720   void process_deleteAllTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05721   void process_deleteAllRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05722   void process_deleteAllRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05723   void process_scannerOpenWithScan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05724   void process_scannerOpen(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05725   void process_scannerOpenWithStop(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05726   void process_scannerOpenWithPrefix(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05727   void process_scannerOpenTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05728   void process_scannerOpenWithStopTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05729   void process_scannerGet(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05730   void process_scannerGetList(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05731   void process_scannerClose(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05732   void process_getRowOrBefore(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05733   void process_getRegionInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
05734  public:
05735   HbaseProcessor(boost::shared_ptr<HbaseIf> iface) :
05736     iface_(iface) {
05737     processMap_["enableTable"] = &HbaseProcessor::process_enableTable;
05738     processMap_["disableTable"] = &HbaseProcessor::process_disableTable;
05739     processMap_["isTableEnabled"] = &HbaseProcessor::process_isTableEnabled;
05740     processMap_["compact"] = &HbaseProcessor::process_compact;
05741     processMap_["majorCompact"] = &HbaseProcessor::process_majorCompact;
05742     processMap_["getTableNames"] = &HbaseProcessor::process_getTableNames;
05743     processMap_["getColumnDescriptors"] = &HbaseProcessor::process_getColumnDescriptors;
05744     processMap_["getTableRegions"] = &HbaseProcessor::process_getTableRegions;
05745     processMap_["createTable"] = &HbaseProcessor::process_createTable;
05746     processMap_["deleteTable"] = &HbaseProcessor::process_deleteTable;
05747     processMap_["get"] = &HbaseProcessor::process_get;
05748     processMap_["getVer"] = &HbaseProcessor::process_getVer;
05749     processMap_["getVerTs"] = &HbaseProcessor::process_getVerTs;
05750     processMap_["getRow"] = &HbaseProcessor::process_getRow;
05751     processMap_["getRowWithColumns"] = &HbaseProcessor::process_getRowWithColumns;
05752     processMap_["getRowTs"] = &HbaseProcessor::process_getRowTs;
05753     processMap_["getRowWithColumnsTs"] = &HbaseProcessor::process_getRowWithColumnsTs;
05754     processMap_["getRows"] = &HbaseProcessor::process_getRows;
05755     processMap_["getRowsWithColumns"] = &HbaseProcessor::process_getRowsWithColumns;
05756     processMap_["getRowsTs"] = &HbaseProcessor::process_getRowsTs;
05757     processMap_["getRowsWithColumnsTs"] = &HbaseProcessor::process_getRowsWithColumnsTs;
05758     processMap_["mutateRow"] = &HbaseProcessor::process_mutateRow;
05759     processMap_["mutateRowTs"] = &HbaseProcessor::process_mutateRowTs;
05760     processMap_["mutateRows"] = &HbaseProcessor::process_mutateRows;
05761     processMap_["mutateRowsTs"] = &HbaseProcessor::process_mutateRowsTs;
05762     processMap_["atomicIncrement"] = &HbaseProcessor::process_atomicIncrement;
05763     processMap_["deleteAll"] = &HbaseProcessor::process_deleteAll;
05764     processMap_["deleteAllTs"] = &HbaseProcessor::process_deleteAllTs;
05765     processMap_["deleteAllRow"] = &HbaseProcessor::process_deleteAllRow;
05766     processMap_["deleteAllRowTs"] = &HbaseProcessor::process_deleteAllRowTs;
05767     processMap_["scannerOpenWithScan"] = &HbaseProcessor::process_scannerOpenWithScan;
05768     processMap_["scannerOpen"] = &HbaseProcessor::process_scannerOpen;
05769     processMap_["scannerOpenWithStop"] = &HbaseProcessor::process_scannerOpenWithStop;
05770     processMap_["scannerOpenWithPrefix"] = &HbaseProcessor::process_scannerOpenWithPrefix;
05771     processMap_["scannerOpenTs"] = &HbaseProcessor::process_scannerOpenTs;
05772     processMap_["scannerOpenWithStopTs"] = &HbaseProcessor::process_scannerOpenWithStopTs;
05773     processMap_["scannerGet"] = &HbaseProcessor::process_scannerGet;
05774     processMap_["scannerGetList"] = &HbaseProcessor::process_scannerGetList;
05775     processMap_["scannerClose"] = &HbaseProcessor::process_scannerClose;
05776     processMap_["getRowOrBefore"] = &HbaseProcessor::process_getRowOrBefore;
05777     processMap_["getRegionInfo"] = &HbaseProcessor::process_getRegionInfo;
05778   }
05779 
05780   virtual bool process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot, void* callContext);
05781   virtual ~HbaseProcessor() {}
05782 };
05783 
05784 class HbaseMultiface : virtual public HbaseIf {
05785  public:
05786   HbaseMultiface(std::vector<boost::shared_ptr<HbaseIf> >& ifaces) : ifaces_(ifaces) {
05787   }
05788   virtual ~HbaseMultiface() {}
05789  protected:
05790   std::vector<boost::shared_ptr<HbaseIf> > ifaces_;
05791   HbaseMultiface() {}
05792   void add(boost::shared_ptr<HbaseIf> iface) {
05793     ifaces_.push_back(iface);
05794   }
05795  public:
05796   void enableTable(const Bytes& tableName) {
05797     size_t sz = ifaces_.size();
05798     for (size_t i = 0; i < sz; ++i) {
05799       ifaces_[i]->enableTable(tableName);
05800     }
05801   }
05802 
05803   void disableTable(const Bytes& tableName) {
05804     size_t sz = ifaces_.size();
05805     for (size_t i = 0; i < sz; ++i) {
05806       ifaces_[i]->disableTable(tableName);
05807     }
05808   }
05809 
05810   bool isTableEnabled(const Bytes& tableName) {
05811     size_t sz = ifaces_.size();
05812     for (size_t i = 0; i < sz; ++i) {
05813       if (i == sz - 1) {
05814         return ifaces_[i]->isTableEnabled(tableName);
05815       } else {
05816         ifaces_[i]->isTableEnabled(tableName);
05817       }
05818     }
05819   }
05820 
05821   void compact(const Bytes& tableNameOrRegionName) {
05822     size_t sz = ifaces_.size();
05823     for (size_t i = 0; i < sz; ++i) {
05824       ifaces_[i]->compact(tableNameOrRegionName);
05825     }
05826   }
05827 
05828   void majorCompact(const Bytes& tableNameOrRegionName) {
05829     size_t sz = ifaces_.size();
05830     for (size_t i = 0; i < sz; ++i) {
05831       ifaces_[i]->majorCompact(tableNameOrRegionName);
05832     }
05833   }
05834 
05835   void getTableNames(std::vector<Text> & _return) {
05836     size_t sz = ifaces_.size();
05837     for (size_t i = 0; i < sz; ++i) {
05838       if (i == sz - 1) {
05839         ifaces_[i]->getTableNames(_return);
05840         return;
05841       } else {
05842         ifaces_[i]->getTableNames(_return);
05843       }
05844     }
05845   }
05846 
05847   void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName) {
05848     size_t sz = ifaces_.size();
05849     for (size_t i = 0; i < sz; ++i) {
05850       if (i == sz - 1) {
05851         ifaces_[i]->getColumnDescriptors(_return, tableName);
05852         return;
05853       } else {
05854         ifaces_[i]->getColumnDescriptors(_return, tableName);
05855       }
05856     }
05857   }
05858 
05859   void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName) {
05860     size_t sz = ifaces_.size();
05861     for (size_t i = 0; i < sz; ++i) {
05862       if (i == sz - 1) {
05863         ifaces_[i]->getTableRegions(_return, tableName);
05864         return;
05865       } else {
05866         ifaces_[i]->getTableRegions(_return, tableName);
05867       }
05868     }
05869   }
05870 
05871   void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies) {
05872     size_t sz = ifaces_.size();
05873     for (size_t i = 0; i < sz; ++i) {
05874       ifaces_[i]->createTable(tableName, columnFamilies);
05875     }
05876   }
05877 
05878   void deleteTable(const Text& tableName) {
05879     size_t sz = ifaces_.size();
05880     for (size_t i = 0; i < sz; ++i) {
05881       ifaces_[i]->deleteTable(tableName);
05882     }
05883   }
05884 
05885   void get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column) {
05886     size_t sz = ifaces_.size();
05887     for (size_t i = 0; i < sz; ++i) {
05888       if (i == sz - 1) {
05889         ifaces_[i]->get(_return, tableName, row, column);
05890         return;
05891       } else {
05892         ifaces_[i]->get(_return, tableName, row, column);
05893       }
05894     }
05895   }
05896 
05897   void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions) {
05898     size_t sz = ifaces_.size();
05899     for (size_t i = 0; i < sz; ++i) {
05900       if (i == sz - 1) {
05901         ifaces_[i]->getVer(_return, tableName, row, column, numVersions);
05902         return;
05903       } else {
05904         ifaces_[i]->getVer(_return, tableName, row, column, numVersions);
05905       }
05906     }
05907   }
05908 
05909   void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions) {
05910     size_t sz = ifaces_.size();
05911     for (size_t i = 0; i < sz; ++i) {
05912       if (i == sz - 1) {
05913         ifaces_[i]->getVerTs(_return, tableName, row, column, timestamp, numVersions);
05914         return;
05915       } else {
05916         ifaces_[i]->getVerTs(_return, tableName, row, column, timestamp, numVersions);
05917       }
05918     }
05919   }
05920 
05921   void getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row) {
05922     size_t sz = ifaces_.size();
05923     for (size_t i = 0; i < sz; ++i) {
05924       if (i == sz - 1) {
05925         ifaces_[i]->getRow(_return, tableName, row);
05926         return;
05927       } else {
05928         ifaces_[i]->getRow(_return, tableName, row);
05929       }
05930     }
05931   }
05932 
05933   void getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns) {
05934     size_t sz = ifaces_.size();
05935     for (size_t i = 0; i < sz; ++i) {
05936       if (i == sz - 1) {
05937         ifaces_[i]->getRowWithColumns(_return, tableName, row, columns);
05938         return;
05939       } else {
05940         ifaces_[i]->getRowWithColumns(_return, tableName, row, columns);
05941       }
05942     }
05943   }
05944 
05945   void getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp) {
05946     size_t sz = ifaces_.size();
05947     for (size_t i = 0; i < sz; ++i) {
05948       if (i == sz - 1) {
05949         ifaces_[i]->getRowTs(_return, tableName, row, timestamp);
05950         return;
05951       } else {
05952         ifaces_[i]->getRowTs(_return, tableName, row, timestamp);
05953       }
05954     }
05955   }
05956 
05957   void getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp) {
05958     size_t sz = ifaces_.size();
05959     for (size_t i = 0; i < sz; ++i) {
05960       if (i == sz - 1) {
05961         ifaces_[i]->getRowWithColumnsTs(_return, tableName, row, columns, timestamp);
05962         return;
05963       } else {
05964         ifaces_[i]->getRowWithColumnsTs(_return, tableName, row, columns, timestamp);
05965       }
05966     }
05967   }
05968 
05969   void getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows) {
05970     size_t sz = ifaces_.size();
05971     for (size_t i = 0; i < sz; ++i) {
05972       if (i == sz - 1) {
05973         ifaces_[i]->getRows(_return, tableName, rows);
05974         return;
05975       } else {
05976         ifaces_[i]->getRows(_return, tableName, rows);
05977       }
05978     }
05979   }
05980 
05981   void getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns) {
05982     size_t sz = ifaces_.size();
05983     for (size_t i = 0; i < sz; ++i) {
05984       if (i == sz - 1) {
05985         ifaces_[i]->getRowsWithColumns(_return, tableName, rows, columns);
05986         return;
05987       } else {
05988         ifaces_[i]->getRowsWithColumns(_return, tableName, rows, columns);
05989       }
05990     }
05991   }
05992 
05993   void getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp) {
05994     size_t sz = ifaces_.size();
05995     for (size_t i = 0; i < sz; ++i) {
05996       if (i == sz - 1) {
05997         ifaces_[i]->getRowsTs(_return, tableName, rows, timestamp);
05998         return;
05999       } else {
06000         ifaces_[i]->getRowsTs(_return, tableName, rows, timestamp);
06001       }
06002     }
06003   }
06004 
06005   void getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp) {
06006     size_t sz = ifaces_.size();
06007     for (size_t i = 0; i < sz; ++i) {
06008       if (i == sz - 1) {
06009         ifaces_[i]->getRowsWithColumnsTs(_return, tableName, rows, columns, timestamp);
06010         return;
06011       } else {
06012         ifaces_[i]->getRowsWithColumnsTs(_return, tableName, rows, columns, timestamp);
06013       }
06014     }
06015   }
06016 
06017   void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations) {
06018     size_t sz = ifaces_.size();
06019     for (size_t i = 0; i < sz; ++i) {
06020       ifaces_[i]->mutateRow(tableName, row, mutations);
06021     }
06022   }
06023 
06024   void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp) {
06025     size_t sz = ifaces_.size();
06026     for (size_t i = 0; i < sz; ++i) {
06027       ifaces_[i]->mutateRowTs(tableName, row, mutations, timestamp);
06028     }
06029   }
06030 
06031   void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches) {
06032     size_t sz = ifaces_.size();
06033     for (size_t i = 0; i < sz; ++i) {
06034       ifaces_[i]->mutateRows(tableName, rowBatches);
06035     }
06036   }
06037 
06038   void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp) {
06039     size_t sz = ifaces_.size();
06040     for (size_t i = 0; i < sz; ++i) {
06041       ifaces_[i]->mutateRowsTs(tableName, rowBatches, timestamp);
06042     }
06043   }
06044 
06045   int64_t atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value) {
06046     size_t sz = ifaces_.size();
06047     for (size_t i = 0; i < sz; ++i) {
06048       if (i == sz - 1) {
06049         return ifaces_[i]->atomicIncrement(tableName, row, column, value);
06050       } else {
06051         ifaces_[i]->atomicIncrement(tableName, row, column, value);
06052       }
06053     }
06054   }
06055 
06056   void deleteAll(const Text& tableName, const Text& row, const Text& column) {
06057     size_t sz = ifaces_.size();
06058     for (size_t i = 0; i < sz; ++i) {
06059       ifaces_[i]->deleteAll(tableName, row, column);
06060     }
06061   }
06062 
06063   void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp) {
06064     size_t sz = ifaces_.size();
06065     for (size_t i = 0; i < sz; ++i) {
06066       ifaces_[i]->deleteAllTs(tableName, row, column, timestamp);
06067     }
06068   }
06069 
06070   void deleteAllRow(const Text& tableName, const Text& row) {
06071     size_t sz = ifaces_.size();
06072     for (size_t i = 0; i < sz; ++i) {
06073       ifaces_[i]->deleteAllRow(tableName, row);
06074     }
06075   }
06076 
06077   void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp) {
06078     size_t sz = ifaces_.size();
06079     for (size_t i = 0; i < sz; ++i) {
06080       ifaces_[i]->deleteAllRowTs(tableName, row, timestamp);
06081     }
06082   }
06083 
06084   ScannerID scannerOpenWithScan(const Text& tableName, const TScan& scan) {
06085     size_t sz = ifaces_.size();
06086     for (size_t i = 0; i < sz; ++i) {
06087       if (i == sz - 1) {
06088         return ifaces_[i]->scannerOpenWithScan(tableName, scan);
06089       } else {
06090         ifaces_[i]->scannerOpenWithScan(tableName, scan);
06091       }
06092     }
06093   }
06094 
06095   ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns) {
06096     size_t sz = ifaces_.size();
06097     for (size_t i = 0; i < sz; ++i) {
06098       if (i == sz - 1) {
06099         return ifaces_[i]->scannerOpen(tableName, startRow, columns);
06100       } else {
06101         ifaces_[i]->scannerOpen(tableName, startRow, columns);
06102       }
06103     }
06104   }
06105 
06106   ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns) {
06107     size_t sz = ifaces_.size();
06108     for (size_t i = 0; i < sz; ++i) {
06109       if (i == sz - 1) {
06110         return ifaces_[i]->scannerOpenWithStop(tableName, startRow, stopRow, columns);
06111       } else {
06112         ifaces_[i]->scannerOpenWithStop(tableName, startRow, stopRow, columns);
06113       }
06114     }
06115   }
06116 
06117   ScannerID scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns) {
06118     size_t sz = ifaces_.size();
06119     for (size_t i = 0; i < sz; ++i) {
06120       if (i == sz - 1) {
06121         return ifaces_[i]->scannerOpenWithPrefix(tableName, startAndPrefix, columns);
06122       } else {
06123         ifaces_[i]->scannerOpenWithPrefix(tableName, startAndPrefix, columns);
06124       }
06125     }
06126   }
06127 
06128   ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp) {
06129     size_t sz = ifaces_.size();
06130     for (size_t i = 0; i < sz; ++i) {
06131       if (i == sz - 1) {
06132         return ifaces_[i]->scannerOpenTs(tableName, startRow, columns, timestamp);
06133       } else {
06134         ifaces_[i]->scannerOpenTs(tableName, startRow, columns, timestamp);
06135       }
06136     }
06137   }
06138 
06139   ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp) {
06140     size_t sz = ifaces_.size();
06141     for (size_t i = 0; i < sz; ++i) {
06142       if (i == sz - 1) {
06143         return ifaces_[i]->scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp);
06144       } else {
06145         ifaces_[i]->scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp);
06146       }
06147     }
06148   }
06149 
06150   void scannerGet(std::vector<TRowResult> & _return, const ScannerID id) {
06151     size_t sz = ifaces_.size();
06152     for (size_t i = 0; i < sz; ++i) {
06153       if (i == sz - 1) {
06154         ifaces_[i]->scannerGet(_return, id);
06155         return;
06156       } else {
06157         ifaces_[i]->scannerGet(_return, id);
06158       }
06159     }
06160   }
06161 
06162   void scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows) {
06163     size_t sz = ifaces_.size();
06164     for (size_t i = 0; i < sz; ++i) {
06165       if (i == sz - 1) {
06166         ifaces_[i]->scannerGetList(_return, id, nbRows);
06167         return;
06168       } else {
06169         ifaces_[i]->scannerGetList(_return, id, nbRows);
06170       }
06171     }
06172   }
06173 
06174   void scannerClose(const ScannerID id) {
06175     size_t sz = ifaces_.size();
06176     for (size_t i = 0; i < sz; ++i) {
06177       ifaces_[i]->scannerClose(id);
06178     }
06179   }
06180 
06181   void getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family) {
06182     size_t sz = ifaces_.size();
06183     for (size_t i = 0; i < sz; ++i) {
06184       if (i == sz - 1) {
06185         ifaces_[i]->getRowOrBefore(_return, tableName, row, family);
06186         return;
06187       } else {
06188         ifaces_[i]->getRowOrBefore(_return, tableName, row, family);
06189       }
06190     }
06191   }
06192 
06193   void getRegionInfo(TRegionInfo& _return, const Text& row) {
06194     size_t sz = ifaces_.size();
06195     for (size_t i = 0; i < sz; ++i) {
06196       if (i == sz - 1) {
06197         ifaces_[i]->getRegionInfo(_return, row);
06198         return;
06199       } else {
06200         ifaces_[i]->getRegionInfo(_return, row);
06201       }
06202     }
06203   }
06204 
06205 };
06206 
06207 }}}} // namespace
06208 
06209 #endif


megatree_storage
Author(s): Wim Meeussen
autogenerated on Mon Dec 2 2013 13:01:19