hbase-examples/src/main/cpp/gen-cpp/Hbase.h

   1 /**
   2  * Autogenerated by Thrift Compiler (0.9.0)
   3  *
   4  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   5  *  @generated
   6  */
   7 #ifndef Hbase_H
   8 #define Hbase_H
   9
  10 #include <thrift/TDispatchProcessor.h>
  11 #include "Hbase_types.h"
  12
  13 namespace apache { namespace hadoop { namespace hbase { namespace thrift {
  14
  15 class HbaseIf {
  16  public:
  17   virtual ~HbaseIf() {}
  18   virtual void enableTable(const Bytes& tableName) = 0;
  19   virtual void disableTable(const Bytes& tableName) = 0;
  20   virtual bool isTableEnabled(const Bytes& tableName) = 0;
  21   virtual void compact(const Bytes& tableNameOrRegionName) = 0;
  22   virtual void majorCompact(const Bytes& tableNameOrRegionName) = 0;
  23   virtual void getTableNames(std::vector<Text> & _return) = 0;
  24   virtual void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName) = 0;
  25   virtual void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName) = 0;
  26   virtual void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies) = 0;
  27   virtual void deleteTable(const Text& tableName) = 0;
  28   virtual void get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes) = 0;
  29   virtual void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes) = 0;
  30   virtual void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes) = 0;
  31   virtual void getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::map<Text, Text> & attributes) = 0;
  32   virtual void getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
  33   virtual void getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
  34   virtual void getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
  35   virtual void getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes) = 0;
  36   virtual void getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
  37   virtual void getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
  38   virtual void getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
  39   virtual void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes) = 0;
  40   virtual void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
  41   virtual void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes) = 0;
  42   virtual void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
  43   virtual int64_t atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value) = 0;
  44   virtual void deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes) = 0;
  45   virtual void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
  46   virtual void deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes) = 0;
  47   virtual void increment(const TIncrement& increment) = 0;
  48   virtual void incrementRows(const std::vector<TIncrement> & increments) = 0;
  49   virtual void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
  50   virtual ScannerID scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes) = 0;
  51   virtual ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
  52   virtual ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
  53   virtual ScannerID scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
  54   virtual ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
  55   virtual ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
  56   virtual void scannerGet(std::vector<TRowResult> & _return, const ScannerID id) = 0;
  57   virtual void scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows) = 0;
  58   virtual void scannerClose(const ScannerID id) = 0;
  59   virtual void getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family) = 0;
  60   virtual void getRegionInfo(TRegionInfo& _return, const Text& row) = 0;
  61 };
  62
  63 class HbaseIfFactory {
  64  public:
  65   typedef HbaseIf Handler;
  66
  67   virtual ~HbaseIfFactory() {}
  68
  69   virtual HbaseIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
  70   virtual void releaseHandler(HbaseIf* /* handler */) = 0;
  71 };
  72
  73 class HbaseIfSingletonFactory : virtual public HbaseIfFactory {
  74  public:
  75   HbaseIfSingletonFactory(const std::shared_ptr<HbaseIf>& iface) : iface_(iface) {}
  76   virtual ~HbaseIfSingletonFactory() {}
  77
  78   virtual HbaseIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
  79     return iface_.get();
  80   }
  81   virtual void releaseHandler(HbaseIf* /* handler */) {}
  82
  83  protected:
  84   std::shared_ptr<HbaseIf> iface_;
  85 };
  86
  87 class HbaseNull : virtual public HbaseIf {
  88  public:
  89   virtual ~HbaseNull() {}
  90   void enableTable(const Bytes& /* tableName */) {
  91     return;
  92   }
  93   void disableTable(const Bytes& /* tableName */) {
  94     return;
  95   }
  96   bool isTableEnabled(const Bytes& /* tableName */) {
  97     bool _return = false;
  98     return _return;
  99   }
 100   void compact(const Bytes& /* tableNameOrRegionName */) {
 101     return;
 102   }
 103   void majorCompact(const Bytes& /* tableNameOrRegionName */) {
 104     return;
 105   }
 106   void getTableNames(std::vector<Text> & /* _return */) {
 107     return;
 108   }
 109   void getColumnDescriptors(std::map<Text, ColumnDescriptor> & /* _return */, const Text& /* tableName */) {
 110     return;
 111   }
 112   void getTableRegions(std::vector<TRegionInfo> & /* _return */, const Text& /* tableName */) {
 113     return;
 114   }
 115   void createTable(const Text& /* tableName */, const std::vector<ColumnDescriptor> & /* columnFamilies */) {
 116     return;
 117   }
 118   void deleteTable(const Text& /* tableName */) {
 119     return;
 120   }
 121   void get(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const std::map<Text, Text> & /* attributes */) {
 122     return;
 123   }
 124   void getVer(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int32_t /* numVersions */, const std::map<Text, Text> & /* attributes */) {
 125     return;
 126   }
 127   void getVerTs(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* timestamp */, const int32_t /* numVersions */, const std::map<Text, Text> & /* attributes */) {
 128     return;
 129   }
 130   void getRow(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const std::map<Text, Text> & /* attributes */) {
 131     return;
 132   }
 133   void getRowWithColumns(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
 134     return;
 135   }
 136   void getRowTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
 137     return;
 138   }
 139   void getRowWithColumnsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
 140     return;
 141   }
 142   void getRows(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const std::map<Text, Text> & /* attributes */) {
 143     return;
 144   }
 145   void getRowsWithColumns(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
 146     return;
 147   }
 148   void getRowsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
 149     return;
 150   }
 151   void getRowsWithColumnsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
 152     return;
 153   }
 154   void mutateRow(const Text& /* tableName */, const Text& /* row */, const std::vector<Mutation> & /* mutations */, const std::map<Text, Text> & /* attributes */) {
 155     return;
 156   }
 157   void mutateRowTs(const Text& /* tableName */, const Text& /* row */, const std::vector<Mutation> & /* mutations */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
 158     return;
 159   }
 160   void mutateRows(const Text& /* tableName */, const std::vector<BatchMutation> & /* rowBatches */, const std::map<Text, Text> & /* attributes */) {
 161     return;
 162   }
 163   void mutateRowsTs(const Text& /* tableName */, const std::vector<BatchMutation> & /* rowBatches */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
 164     return;
 165   }
 166   int64_t atomicIncrement(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* value */) {
 167     int64_t _return = 0;
 168     return _return;
 169   }
 170   void deleteAll(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const std::map<Text, Text> & /* attributes */) {
 171     return;
 172   }
 173   void deleteAllTs(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
 174     return;
 175   }
 176   void deleteAllRow(const Text& /* tableName */, const Text& /* row */, const std::map<Text, Text> & /* attributes */) {
 177     return;
 178   }
 179   void increment(const TIncrement& /* increment */) {
 180     return;
 181   }
 182   void incrementRows(const std::vector<TIncrement> & /* increments */) {
 183     return;
 184   }
 185   void deleteAllRowTs(const Text& /* tableName */, const Text& /* row */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
 186     return;
 187   }
 188   ScannerID scannerOpenWithScan(const Text& /* tableName */, const TScan& /* scan */, const std::map<Text, Text> & /* attributes */) {
 189     ScannerID _return = 0;
 190     return _return;
 191   }
 192   ScannerID scannerOpen(const Text& /* tableName */, const Text& /* startRow */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
 193     ScannerID _return = 0;
 194     return _return;
 195   }
 196   ScannerID scannerOpenWithStop(const Text& /* tableName */, const Text& /* startRow */, const Text& /* stopRow */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
 197     ScannerID _return = 0;
 198     return _return;
 199   }
 200   ScannerID scannerOpenWithPrefix(const Text& /* tableName */, const Text& /* startAndPrefix */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
 201     ScannerID _return = 0;
 202     return _return;
 203   }
 204   ScannerID scannerOpenTs(const Text& /* tableName */, const Text& /* startRow */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
 205     ScannerID _return = 0;
 206     return _return;
 207   }
 208   ScannerID scannerOpenWithStopTs(const Text& /* tableName */, const Text& /* startRow */, const Text& /* stopRow */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
 209     ScannerID _return = 0;
 210     return _return;
 211   }
 212   void scannerGet(std::vector<TRowResult> & /* _return */, const ScannerID /* id */) {
 213     return;
 214   }
 215   void scannerGetList(std::vector<TRowResult> & /* _return */, const ScannerID /* id */, const int32_t /* nbRows */) {
 216     return;
 217   }
 218   void scannerClose(const ScannerID /* id */) {
 219     return;
 220   }
 221   void getRowOrBefore(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* family */) {
 222     return;
 223   }
 224   void getRegionInfo(TRegionInfo& /* _return */, const Text& /* row */) {
 225     return;
 226   }
 227 };
 228
 229 typedef struct _Hbase_enableTable_args__isset {
 230   _Hbase_enableTable_args__isset() : tableName(false) {}
 231   bool tableName;
 232 } _Hbase_enableTable_args__isset;
 233
 234 class Hbase_enableTable_args {
 235  public:
 236
 237   Hbase_enableTable_args() : tableName() {
 238   }
 239
 240   virtual ~Hbase_enableTable_args() throw() {}
 241
 242   Bytes tableName;
 243
 244   _Hbase_enableTable_args__isset __isset;
 245
 246   void __set_tableName(const Bytes& val) {
 247     tableName = val;
 248   }
 249
 250   bool operator == (const Hbase_enableTable_args & rhs) const
 251   {
 252     if (!(tableName == rhs.tableName))
 253       return false;
 254     return true;
 255   }
 256   bool operator != (const Hbase_enableTable_args &rhs) const {
 257     return !(*this == rhs);
 258   }
 259
 260   bool operator < (const Hbase_enableTable_args & ) const;
 261
 262   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 263   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 264
 265 };
 266
 267
 268 class Hbase_enableTable_pargs {
 269  public:
 270
 271
 272   virtual ~Hbase_enableTable_pargs() throw() {}
 273
 274   const Bytes* tableName;
 275
 276   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 277
 278 };
 279
 280 typedef struct _Hbase_enableTable_result__isset {
 281   _Hbase_enableTable_result__isset() : io(false) {}
 282   bool io;
 283 } _Hbase_enableTable_result__isset;
 284
 285 class Hbase_enableTable_result {
 286  public:
 287
 288   Hbase_enableTable_result() {
 289   }
 290
 291   virtual ~Hbase_enableTable_result() throw() {}
 292
 293   IOError io;
 294
 295   _Hbase_enableTable_result__isset __isset;
 296
 297   void __set_io(const IOError& val) {
 298     io = val;
 299   }
 300
 301   bool operator == (const Hbase_enableTable_result & rhs) const
 302   {
 303     if (!(io == rhs.io))
 304       return false;
 305     return true;
 306   }
 307   bool operator != (const Hbase_enableTable_result &rhs) const {
 308     return !(*this == rhs);
 309   }
 310
 311   bool operator < (const Hbase_enableTable_result & ) const;
 312
 313   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 314   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 315
 316 };
 317
 318 typedef struct _Hbase_enableTable_presult__isset {
 319   _Hbase_enableTable_presult__isset() : io(false) {}
 320   bool io;
 321 } _Hbase_enableTable_presult__isset;
 322
 323 class Hbase_enableTable_presult {
 324  public:
 325
 326
 327   virtual ~Hbase_enableTable_presult() throw() {}
 328
 329   IOError io;
 330
 331   _Hbase_enableTable_presult__isset __isset;
 332
 333   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 334
 335 };
 336
 337 typedef struct _Hbase_disableTable_args__isset {
 338   _Hbase_disableTable_args__isset() : tableName(false) {}
 339   bool tableName;
 340 } _Hbase_disableTable_args__isset;
 341
 342 class Hbase_disableTable_args {
 343  public:
 344
 345   Hbase_disableTable_args() : tableName() {
 346   }
 347
 348   virtual ~Hbase_disableTable_args() throw() {}
 349
 350   Bytes tableName;
 351
 352   _Hbase_disableTable_args__isset __isset;
 353
 354   void __set_tableName(const Bytes& val) {
 355     tableName = val;
 356   }
 357
 358   bool operator == (const Hbase_disableTable_args & rhs) const
 359   {
 360     if (!(tableName == rhs.tableName))
 361       return false;
 362     return true;
 363   }
 364   bool operator != (const Hbase_disableTable_args &rhs) const {
 365     return !(*this == rhs);
 366   }
 367
 368   bool operator < (const Hbase_disableTable_args & ) const;
 369
 370   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 371   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 372
 373 };
 374
 375
 376 class Hbase_disableTable_pargs {
 377  public:
 378
 379
 380   virtual ~Hbase_disableTable_pargs() throw() {}
 381
 382   const Bytes* tableName;
 383
 384   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 385
 386 };
 387
 388 typedef struct _Hbase_disableTable_result__isset {
 389   _Hbase_disableTable_result__isset() : io(false) {}
 390   bool io;
 391 } _Hbase_disableTable_result__isset;
 392
 393 class Hbase_disableTable_result {
 394  public:
 395
 396   Hbase_disableTable_result() {
 397   }
 398
 399   virtual ~Hbase_disableTable_result() throw() {}
 400
 401   IOError io;
 402
 403   _Hbase_disableTable_result__isset __isset;
 404
 405   void __set_io(const IOError& val) {
 406     io = val;
 407   }
 408
 409   bool operator == (const Hbase_disableTable_result & rhs) const
 410   {
 411     if (!(io == rhs.io))
 412       return false;
 413     return true;
 414   }
 415   bool operator != (const Hbase_disableTable_result &rhs) const {
 416     return !(*this == rhs);
 417   }
 418
 419   bool operator < (const Hbase_disableTable_result & ) const;
 420
 421   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 422   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 423
 424 };
 425
 426 typedef struct _Hbase_disableTable_presult__isset {
 427   _Hbase_disableTable_presult__isset() : io(false) {}
 428   bool io;
 429 } _Hbase_disableTable_presult__isset;
 430
 431 class Hbase_disableTable_presult {
 432  public:
 433
 434
 435   virtual ~Hbase_disableTable_presult() throw() {}
 436
 437   IOError io;
 438
 439   _Hbase_disableTable_presult__isset __isset;
 440
 441   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 442
 443 };
 444
 445 typedef struct _Hbase_isTableEnabled_args__isset {
 446   _Hbase_isTableEnabled_args__isset() : tableName(false) {}
 447   bool tableName;
 448 } _Hbase_isTableEnabled_args__isset;
 449
 450 class Hbase_isTableEnabled_args {
 451  public:
 452
 453   Hbase_isTableEnabled_args() : tableName() {
 454   }
 455
 456   virtual ~Hbase_isTableEnabled_args() throw() {}
 457
 458   Bytes tableName;
 459
 460   _Hbase_isTableEnabled_args__isset __isset;
 461
 462   void __set_tableName(const Bytes& val) {
 463     tableName = val;
 464   }
 465
 466   bool operator == (const Hbase_isTableEnabled_args & rhs) const
 467   {
 468     if (!(tableName == rhs.tableName))
 469       return false;
 470     return true;
 471   }
 472   bool operator != (const Hbase_isTableEnabled_args &rhs) const {
 473     return !(*this == rhs);
 474   }
 475
 476   bool operator < (const Hbase_isTableEnabled_args & ) const;
 477
 478   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 479   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 480
 481 };
 482
 483
 484 class Hbase_isTableEnabled_pargs {
 485  public:
 486
 487
 488   virtual ~Hbase_isTableEnabled_pargs() throw() {}
 489
 490   const Bytes* tableName;
 491
 492   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 493
 494 };
 495
 496 typedef struct _Hbase_isTableEnabled_result__isset {
 497   _Hbase_isTableEnabled_result__isset() : success(false), io(false) {}
 498   bool success;
 499   bool io;
 500 } _Hbase_isTableEnabled_result__isset;
 501
 502 class Hbase_isTableEnabled_result {
 503  public:
 504
 505   Hbase_isTableEnabled_result() : success(0) {
 506   }
 507
 508   virtual ~Hbase_isTableEnabled_result() throw() {}
 509
 510   bool success;
 511   IOError io;
 512
 513   _Hbase_isTableEnabled_result__isset __isset;
 514
 515   void __set_success(const bool val) {
 516     success = val;
 517   }
 518
 519   void __set_io(const IOError& val) {
 520     io = val;
 521   }
 522
 523   bool operator == (const Hbase_isTableEnabled_result & rhs) const
 524   {
 525     if (!(success == rhs.success))
 526       return false;
 527     if (!(io == rhs.io))
 528       return false;
 529     return true;
 530   }
 531   bool operator != (const Hbase_isTableEnabled_result &rhs) const {
 532     return !(*this == rhs);
 533   }
 534
 535   bool operator < (const Hbase_isTableEnabled_result & ) const;
 536
 537   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 538   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 539
 540 };
 541
 542 typedef struct _Hbase_isTableEnabled_presult__isset {
 543   _Hbase_isTableEnabled_presult__isset() : success(false), io(false) {}
 544   bool success;
 545   bool io;
 546 } _Hbase_isTableEnabled_presult__isset;
 547
 548 class Hbase_isTableEnabled_presult {
 549  public:
 550
 551
 552   virtual ~Hbase_isTableEnabled_presult() throw() {}
 553
 554   bool* success;
 555   IOError io;
 556
 557   _Hbase_isTableEnabled_presult__isset __isset;
 558
 559   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 560
 561 };
 562
 563 typedef struct _Hbase_compact_args__isset {
 564   _Hbase_compact_args__isset() : tableNameOrRegionName(false) {}
 565   bool tableNameOrRegionName;
 566 } _Hbase_compact_args__isset;
 567
 568 class Hbase_compact_args {
 569  public:
 570
 571   Hbase_compact_args() : tableNameOrRegionName() {
 572   }
 573
 574   virtual ~Hbase_compact_args() throw() {}
 575
 576   Bytes tableNameOrRegionName;
 577
 578   _Hbase_compact_args__isset __isset;
 579
 580   void __set_tableNameOrRegionName(const Bytes& val) {
 581     tableNameOrRegionName = val;
 582   }
 583
 584   bool operator == (const Hbase_compact_args & rhs) const
 585   {
 586     if (!(tableNameOrRegionName == rhs.tableNameOrRegionName))
 587       return false;
 588     return true;
 589   }
 590   bool operator != (const Hbase_compact_args &rhs) const {
 591     return !(*this == rhs);
 592   }
 593
 594   bool operator < (const Hbase_compact_args & ) const;
 595
 596   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 597   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 598
 599 };
 600
 601
 602 class Hbase_compact_pargs {
 603  public:
 604
 605
 606   virtual ~Hbase_compact_pargs() throw() {}
 607
 608   const Bytes* tableNameOrRegionName;
 609
 610   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 611
 612 };
 613
 614 typedef struct _Hbase_compact_result__isset {
 615   _Hbase_compact_result__isset() : io(false) {}
 616   bool io;
 617 } _Hbase_compact_result__isset;
 618
 619 class Hbase_compact_result {
 620  public:
 621
 622   Hbase_compact_result() {
 623   }
 624
 625   virtual ~Hbase_compact_result() throw() {}
 626
 627   IOError io;
 628
 629   _Hbase_compact_result__isset __isset;
 630
 631   void __set_io(const IOError& val) {
 632     io = val;
 633   }
 634
 635   bool operator == (const Hbase_compact_result & rhs) const
 636   {
 637     if (!(io == rhs.io))
 638       return false;
 639     return true;
 640   }
 641   bool operator != (const Hbase_compact_result &rhs) const {
 642     return !(*this == rhs);
 643   }
 644
 645   bool operator < (const Hbase_compact_result & ) const;
 646
 647   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 648   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 649
 650 };
 651
 652 typedef struct _Hbase_compact_presult__isset {
 653   _Hbase_compact_presult__isset() : io(false) {}
 654   bool io;
 655 } _Hbase_compact_presult__isset;
 656
 657 class Hbase_compact_presult {
 658  public:
 659
 660
 661   virtual ~Hbase_compact_presult() throw() {}
 662
 663   IOError io;
 664
 665   _Hbase_compact_presult__isset __isset;
 666
 667   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 668
 669 };
 670
 671 typedef struct _Hbase_majorCompact_args__isset {
 672   _Hbase_majorCompact_args__isset() : tableNameOrRegionName(false) {}
 673   bool tableNameOrRegionName;
 674 } _Hbase_majorCompact_args__isset;
 675
 676 class Hbase_majorCompact_args {
 677  public:
 678
 679   Hbase_majorCompact_args() : tableNameOrRegionName() {
 680   }
 681
 682   virtual ~Hbase_majorCompact_args() throw() {}
 683
 684   Bytes tableNameOrRegionName;
 685
 686   _Hbase_majorCompact_args__isset __isset;
 687
 688   void __set_tableNameOrRegionName(const Bytes& val) {
 689     tableNameOrRegionName = val;
 690   }
 691
 692   bool operator == (const Hbase_majorCompact_args & rhs) const
 693   {
 694     if (!(tableNameOrRegionName == rhs.tableNameOrRegionName))
 695       return false;
 696     return true;
 697   }
 698   bool operator != (const Hbase_majorCompact_args &rhs) const {
 699     return !(*this == rhs);
 700   }
 701
 702   bool operator < (const Hbase_majorCompact_args & ) const;
 703
 704   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 705   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 706
 707 };
 708
 709
 710 class Hbase_majorCompact_pargs {
 711  public:
 712
 713
 714   virtual ~Hbase_majorCompact_pargs() throw() {}
 715
 716   const Bytes* tableNameOrRegionName;
 717
 718   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 719
 720 };
 721
 722 typedef struct _Hbase_majorCompact_result__isset {
 723   _Hbase_majorCompact_result__isset() : io(false) {}
 724   bool io;
 725 } _Hbase_majorCompact_result__isset;
 726
 727 class Hbase_majorCompact_result {
 728  public:
 729
 730   Hbase_majorCompact_result() {
 731   }
 732
 733   virtual ~Hbase_majorCompact_result() throw() {}
 734
 735   IOError io;
 736
 737   _Hbase_majorCompact_result__isset __isset;
 738
 739   void __set_io(const IOError& val) {
 740     io = val;
 741   }
 742
 743   bool operator == (const Hbase_majorCompact_result & rhs) const
 744   {
 745     if (!(io == rhs.io))
 746       return false;
 747     return true;
 748   }
 749   bool operator != (const Hbase_majorCompact_result &rhs) const {
 750     return !(*this == rhs);
 751   }
 752
 753   bool operator < (const Hbase_majorCompact_result & ) const;
 754
 755   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 756   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 757
 758 };
 759
 760 typedef struct _Hbase_majorCompact_presult__isset {
 761   _Hbase_majorCompact_presult__isset() : io(false) {}
 762   bool io;
 763 } _Hbase_majorCompact_presult__isset;
 764
 765 class Hbase_majorCompact_presult {
 766  public:
 767
 768
 769   virtual ~Hbase_majorCompact_presult() throw() {}
 770
 771   IOError io;
 772
 773   _Hbase_majorCompact_presult__isset __isset;
 774
 775   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 776
 777 };
 778
 779
 780 class Hbase_getTableNames_args {
 781  public:
 782
 783   Hbase_getTableNames_args() {
 784   }
 785
 786   virtual ~Hbase_getTableNames_args() throw() {}
 787
 788
 789   bool operator == (const Hbase_getTableNames_args & /* rhs */) const
 790   {
 791     return true;
 792   }
 793   bool operator != (const Hbase_getTableNames_args &rhs) const {
 794     return !(*this == rhs);
 795   }
 796
 797   bool operator < (const Hbase_getTableNames_args & ) const;
 798
 799   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 800   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 801
 802 };
 803
 804
 805 class Hbase_getTableNames_pargs {
 806  public:
 807
 808
 809   virtual ~Hbase_getTableNames_pargs() throw() {}
 810
 811
 812   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 813
 814 };
 815
 816 typedef struct _Hbase_getTableNames_result__isset {
 817   _Hbase_getTableNames_result__isset() : success(false), io(false) {}
 818   bool success;
 819   bool io;
 820 } _Hbase_getTableNames_result__isset;
 821
 822 class Hbase_getTableNames_result {
 823  public:
 824
 825   Hbase_getTableNames_result() {
 826   }
 827
 828   virtual ~Hbase_getTableNames_result() throw() {}
 829
 830   std::vector<Text>  success;
 831   IOError io;
 832
 833   _Hbase_getTableNames_result__isset __isset;
 834
 835   void __set_success(const std::vector<Text> & val) {
 836     success = val;
 837   }
 838
 839   void __set_io(const IOError& val) {
 840     io = val;
 841   }
 842
 843   bool operator == (const Hbase_getTableNames_result & rhs) const
 844   {
 845     if (!(success == rhs.success))
 846       return false;
 847     if (!(io == rhs.io))
 848       return false;
 849     return true;
 850   }
 851   bool operator != (const Hbase_getTableNames_result &rhs) const {
 852     return !(*this == rhs);
 853   }
 854
 855   bool operator < (const Hbase_getTableNames_result & ) const;
 856
 857   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 858   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 859
 860 };
 861
 862 typedef struct _Hbase_getTableNames_presult__isset {
 863   _Hbase_getTableNames_presult__isset() : success(false), io(false) {}
 864   bool success;
 865   bool io;
 866 } _Hbase_getTableNames_presult__isset;
 867
 868 class Hbase_getTableNames_presult {
 869  public:
 870
 871
 872   virtual ~Hbase_getTableNames_presult() throw() {}
 873
 874   std::vector<Text> * success;
 875   IOError io;
 876
 877   _Hbase_getTableNames_presult__isset __isset;
 878
 879   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 880
 881 };
 882
 883 typedef struct _Hbase_getColumnDescriptors_args__isset {
 884   _Hbase_getColumnDescriptors_args__isset() : tableName(false) {}
 885   bool tableName;
 886 } _Hbase_getColumnDescriptors_args__isset;
 887
 888 class Hbase_getColumnDescriptors_args {
 889  public:
 890
 891   Hbase_getColumnDescriptors_args() : tableName() {
 892   }
 893
 894   virtual ~Hbase_getColumnDescriptors_args() throw() {}
 895
 896   Text tableName;
 897
 898   _Hbase_getColumnDescriptors_args__isset __isset;
 899
 900   void __set_tableName(const Text& val) {
 901     tableName = val;
 902   }
 903
 904   bool operator == (const Hbase_getColumnDescriptors_args & rhs) const
 905   {
 906     if (!(tableName == rhs.tableName))
 907       return false;
 908     return true;
 909   }
 910   bool operator != (const Hbase_getColumnDescriptors_args &rhs) const {
 911     return !(*this == rhs);
 912   }
 913
 914   bool operator < (const Hbase_getColumnDescriptors_args & ) const;
 915
 916   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 917   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 918
 919 };
 920
 921
 922 class Hbase_getColumnDescriptors_pargs {
 923  public:
 924
 925
 926   virtual ~Hbase_getColumnDescriptors_pargs() throw() {}
 927
 928   const Text* tableName;
 929
 930   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 931
 932 };
 933
 934 typedef struct _Hbase_getColumnDescriptors_result__isset {
 935   _Hbase_getColumnDescriptors_result__isset() : success(false), io(false) {}
 936   bool success;
 937   bool io;
 938 } _Hbase_getColumnDescriptors_result__isset;
 939
 940 class Hbase_getColumnDescriptors_result {
 941  public:
 942
 943   Hbase_getColumnDescriptors_result() {
 944   }
 945
 946   virtual ~Hbase_getColumnDescriptors_result() throw() {}
 947
 948   std::map<Text, ColumnDescriptor>  success;
 949   IOError io;
 950
 951   _Hbase_getColumnDescriptors_result__isset __isset;
 952
 953   void __set_success(const std::map<Text, ColumnDescriptor> & val) {
 954     success = val;
 955   }
 956
 957   void __set_io(const IOError& val) {
 958     io = val;
 959   }
 960
 961   bool operator == (const Hbase_getColumnDescriptors_result & rhs) const
 962   {
 963     if (!(success == rhs.success))
 964       return false;
 965     if (!(io == rhs.io))
 966       return false;
 967     return true;
 968   }
 969   bool operator != (const Hbase_getColumnDescriptors_result &rhs) const {
 970     return !(*this == rhs);
 971   }
 972
 973   bool operator < (const Hbase_getColumnDescriptors_result & ) const;
 974
 975   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 976   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 977
 978 };
 979
 980 typedef struct _Hbase_getColumnDescriptors_presult__isset {
 981   _Hbase_getColumnDescriptors_presult__isset() : success(false), io(false) {}
 982   bool success;
 983   bool io;
 984 } _Hbase_getColumnDescriptors_presult__isset;
 985
 986 class Hbase_getColumnDescriptors_presult {
 987  public:
 988
 989
 990   virtual ~Hbase_getColumnDescriptors_presult() throw() {}
 991
 992   std::map<Text, ColumnDescriptor> * success;
 993   IOError io;
 994
 995   _Hbase_getColumnDescriptors_presult__isset __isset;
 996
 997   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 998
 999 };
1000
1001 typedef struct _Hbase_getTableRegions_args__isset {
1002   _Hbase_getTableRegions_args__isset() : tableName(false) {}
1003   bool tableName;
1004 } _Hbase_getTableRegions_args__isset;
1005
1006 class Hbase_getTableRegions_args {
1007  public:
1008
1009   Hbase_getTableRegions_args() : tableName() {
1010   }
1011
1012   virtual ~Hbase_getTableRegions_args() throw() {}
1013
1014   Text tableName;
1015
1016   _Hbase_getTableRegions_args__isset __isset;
1017
1018   void __set_tableName(const Text& val) {
1019     tableName = val;
1020   }
1021
1022   bool operator == (const Hbase_getTableRegions_args & rhs) const
1023   {
1024     if (!(tableName == rhs.tableName))
1025       return false;
1026     return true;
1027   }
1028   bool operator != (const Hbase_getTableRegions_args &rhs) const {
1029     return !(*this == rhs);
1030   }
1031
1032   bool operator < (const Hbase_getTableRegions_args & ) const;
1033
1034   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1035   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1036
1037 };
1038
1039
1040 class Hbase_getTableRegions_pargs {
1041  public:
1042
1043
1044   virtual ~Hbase_getTableRegions_pargs() throw() {}
1045
1046   const Text* tableName;
1047
1048   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1049
1050 };
1051
1052 typedef struct _Hbase_getTableRegions_result__isset {
1053   _Hbase_getTableRegions_result__isset() : success(false), io(false) {}
1054   bool success;
1055   bool io;
1056 } _Hbase_getTableRegions_result__isset;
1057
1058 class Hbase_getTableRegions_result {
1059  public:
1060
1061   Hbase_getTableRegions_result() {
1062   }
1063
1064   virtual ~Hbase_getTableRegions_result() throw() {}
1065
1066   std::vector<TRegionInfo>  success;
1067   IOError io;
1068
1069   _Hbase_getTableRegions_result__isset __isset;
1070
1071   void __set_success(const std::vector<TRegionInfo> & val) {
1072     success = val;
1073   }
1074
1075   void __set_io(const IOError& val) {
1076     io = val;
1077   }
1078
1079   bool operator == (const Hbase_getTableRegions_result & rhs) const
1080   {
1081     if (!(success == rhs.success))
1082       return false;
1083     if (!(io == rhs.io))
1084       return false;
1085     return true;
1086   }
1087   bool operator != (const Hbase_getTableRegions_result &rhs) const {
1088     return !(*this == rhs);
1089   }
1090
1091   bool operator < (const Hbase_getTableRegions_result & ) const;
1092
1093   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1094   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1095
1096 };
1097
1098 typedef struct _Hbase_getTableRegions_presult__isset {
1099   _Hbase_getTableRegions_presult__isset() : success(false), io(false) {}
1100   bool success;
1101   bool io;
1102 } _Hbase_getTableRegions_presult__isset;
1103
1104 class Hbase_getTableRegions_presult {
1105  public:
1106
1107
1108   virtual ~Hbase_getTableRegions_presult() throw() {}
1109
1110   std::vector<TRegionInfo> * success;
1111   IOError io;
1112
1113   _Hbase_getTableRegions_presult__isset __isset;
1114
1115   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1116
1117 };
1118
1119 typedef struct _Hbase_createTable_args__isset {
1120   _Hbase_createTable_args__isset() : tableName(false), columnFamilies(false) {}
1121   bool tableName;
1122   bool columnFamilies;
1123 } _Hbase_createTable_args__isset;
1124
1125 class Hbase_createTable_args {
1126  public:
1127
1128   Hbase_createTable_args() : tableName() {
1129   }
1130
1131   virtual ~Hbase_createTable_args() throw() {}
1132
1133   Text tableName;
1134   std::vector<ColumnDescriptor>  columnFamilies;
1135
1136   _Hbase_createTable_args__isset __isset;
1137
1138   void __set_tableName(const Text& val) {
1139     tableName = val;
1140   }
1141
1142   void __set_columnFamilies(const std::vector<ColumnDescriptor> & val) {
1143     columnFamilies = val;
1144   }
1145
1146   bool operator == (const Hbase_createTable_args & rhs) const
1147   {
1148     if (!(tableName == rhs.tableName))
1149       return false;
1150     if (!(columnFamilies == rhs.columnFamilies))
1151       return false;
1152     return true;
1153   }
1154   bool operator != (const Hbase_createTable_args &rhs) const {
1155     return !(*this == rhs);
1156   }
1157
1158   bool operator < (const Hbase_createTable_args & ) const;
1159
1160   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1161   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1162
1163 };
1164
1165
1166 class Hbase_createTable_pargs {
1167  public:
1168
1169
1170   virtual ~Hbase_createTable_pargs() throw() {}
1171
1172   const Text* tableName;
1173   const std::vector<ColumnDescriptor> * columnFamilies;
1174
1175   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1176
1177 };
1178
1179 typedef struct _Hbase_createTable_result__isset {
1180   _Hbase_createTable_result__isset() : io(false), ia(false), exist(false) {}
1181   bool io;
1182   bool ia;
1183   bool exist;
1184 } _Hbase_createTable_result__isset;
1185
1186 class Hbase_createTable_result {
1187  public:
1188
1189   Hbase_createTable_result() {
1190   }
1191
1192   virtual ~Hbase_createTable_result() throw() {}
1193
1194   IOError io;
1195   IllegalArgument ia;
1196   AlreadyExists exist;
1197
1198   _Hbase_createTable_result__isset __isset;
1199
1200   void __set_io(const IOError& val) {
1201     io = val;
1202   }
1203
1204   void __set_ia(const IllegalArgument& val) {
1205     ia = val;
1206   }
1207
1208   void __set_exist(const AlreadyExists& val) {
1209     exist = val;
1210   }
1211
1212   bool operator == (const Hbase_createTable_result & rhs) const
1213   {
1214     if (!(io == rhs.io))
1215       return false;
1216     if (!(ia == rhs.ia))
1217       return false;
1218     if (!(exist == rhs.exist))
1219       return false;
1220     return true;
1221   }
1222   bool operator != (const Hbase_createTable_result &rhs) const {
1223     return !(*this == rhs);
1224   }
1225
1226   bool operator < (const Hbase_createTable_result & ) const;
1227
1228   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1229   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1230
1231 };
1232
1233 typedef struct _Hbase_createTable_presult__isset {
1234   _Hbase_createTable_presult__isset() : io(false), ia(false), exist(false) {}
1235   bool io;
1236   bool ia;
1237   bool exist;
1238 } _Hbase_createTable_presult__isset;
1239
1240 class Hbase_createTable_presult {
1241  public:
1242
1243
1244   virtual ~Hbase_createTable_presult() throw() {}
1245
1246   IOError io;
1247   IllegalArgument ia;
1248   AlreadyExists exist;
1249
1250   _Hbase_createTable_presult__isset __isset;
1251
1252   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1253
1254 };
1255
1256 typedef struct _Hbase_deleteTable_args__isset {
1257   _Hbase_deleteTable_args__isset() : tableName(false) {}
1258   bool tableName;
1259 } _Hbase_deleteTable_args__isset;
1260
1261 class Hbase_deleteTable_args {
1262  public:
1263
1264   Hbase_deleteTable_args() : tableName() {
1265   }
1266
1267   virtual ~Hbase_deleteTable_args() throw() {}
1268
1269   Text tableName;
1270
1271   _Hbase_deleteTable_args__isset __isset;
1272
1273   void __set_tableName(const Text& val) {
1274     tableName = val;
1275   }
1276
1277   bool operator == (const Hbase_deleteTable_args & rhs) const
1278   {
1279     if (!(tableName == rhs.tableName))
1280       return false;
1281     return true;
1282   }
1283   bool operator != (const Hbase_deleteTable_args &rhs) const {
1284     return !(*this == rhs);
1285   }
1286
1287   bool operator < (const Hbase_deleteTable_args & ) const;
1288
1289   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1290   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1291
1292 };
1293
1294
1295 class Hbase_deleteTable_pargs {
1296  public:
1297
1298
1299   virtual ~Hbase_deleteTable_pargs() throw() {}
1300
1301   const Text* tableName;
1302
1303   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1304
1305 };
1306
1307 typedef struct _Hbase_deleteTable_result__isset {
1308   _Hbase_deleteTable_result__isset() : io(false) {}
1309   bool io;
1310 } _Hbase_deleteTable_result__isset;
1311
1312 class Hbase_deleteTable_result {
1313  public:
1314
1315   Hbase_deleteTable_result() {
1316   }
1317
1318   virtual ~Hbase_deleteTable_result() throw() {}
1319
1320   IOError io;
1321
1322   _Hbase_deleteTable_result__isset __isset;
1323
1324   void __set_io(const IOError& val) {
1325     io = val;
1326   }
1327
1328   bool operator == (const Hbase_deleteTable_result & rhs) const
1329   {
1330     if (!(io == rhs.io))
1331       return false;
1332     return true;
1333   }
1334   bool operator != (const Hbase_deleteTable_result &rhs) const {
1335     return !(*this == rhs);
1336   }
1337
1338   bool operator < (const Hbase_deleteTable_result & ) const;
1339
1340   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1341   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1342
1343 };
1344
1345 typedef struct _Hbase_deleteTable_presult__isset {
1346   _Hbase_deleteTable_presult__isset() : io(false) {}
1347   bool io;
1348 } _Hbase_deleteTable_presult__isset;
1349
1350 class Hbase_deleteTable_presult {
1351  public:
1352
1353
1354   virtual ~Hbase_deleteTable_presult() throw() {}
1355
1356   IOError io;
1357
1358   _Hbase_deleteTable_presult__isset __isset;
1359
1360   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1361
1362 };
1363
1364 typedef struct _Hbase_get_args__isset {
1365   _Hbase_get_args__isset() : tableName(false), row(false), column(false), attributes(false) {}
1366   bool tableName;
1367   bool row;
1368   bool column;
1369   bool attributes;
1370 } _Hbase_get_args__isset;
1371
1372 class Hbase_get_args {
1373  public:
1374
1375   Hbase_get_args() : tableName(), row(), column() {
1376   }
1377
1378   virtual ~Hbase_get_args() throw() {}
1379
1380   Text tableName;
1381   Text row;
1382   Text column;
1383   std::map<Text, Text>  attributes;
1384
1385   _Hbase_get_args__isset __isset;
1386
1387   void __set_tableName(const Text& val) {
1388     tableName = val;
1389   }
1390
1391   void __set_row(const Text& val) {
1392     row = val;
1393   }
1394
1395   void __set_column(const Text& val) {
1396     column = val;
1397   }
1398
1399   void __set_attributes(const std::map<Text, Text> & val) {
1400     attributes = val;
1401   }
1402
1403   bool operator == (const Hbase_get_args & rhs) const
1404   {
1405     if (!(tableName == rhs.tableName))
1406       return false;
1407     if (!(row == rhs.row))
1408       return false;
1409     if (!(column == rhs.column))
1410       return false;
1411     if (!(attributes == rhs.attributes))
1412       return false;
1413     return true;
1414   }
1415   bool operator != (const Hbase_get_args &rhs) const {
1416     return !(*this == rhs);
1417   }
1418
1419   bool operator < (const Hbase_get_args & ) const;
1420
1421   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1422   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1423
1424 };
1425
1426
1427 class Hbase_get_pargs {
1428  public:
1429
1430
1431   virtual ~Hbase_get_pargs() throw() {}
1432
1433   const Text* tableName;
1434   const Text* row;
1435   const Text* column;
1436   const std::map<Text, Text> * attributes;
1437
1438   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1439
1440 };
1441
1442 typedef struct _Hbase_get_result__isset {
1443   _Hbase_get_result__isset() : success(false), io(false) {}
1444   bool success;
1445   bool io;
1446 } _Hbase_get_result__isset;
1447
1448 class Hbase_get_result {
1449  public:
1450
1451   Hbase_get_result() {
1452   }
1453
1454   virtual ~Hbase_get_result() throw() {}
1455
1456   std::vector<TCell>  success;
1457   IOError io;
1458
1459   _Hbase_get_result__isset __isset;
1460
1461   void __set_success(const std::vector<TCell> & val) {
1462     success = val;
1463   }
1464
1465   void __set_io(const IOError& val) {
1466     io = val;
1467   }
1468
1469   bool operator == (const Hbase_get_result & rhs) const
1470   {
1471     if (!(success == rhs.success))
1472       return false;
1473     if (!(io == rhs.io))
1474       return false;
1475     return true;
1476   }
1477   bool operator != (const Hbase_get_result &rhs) const {
1478     return !(*this == rhs);
1479   }
1480
1481   bool operator < (const Hbase_get_result & ) const;
1482
1483   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1484   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1485
1486 };
1487
1488 typedef struct _Hbase_get_presult__isset {
1489   _Hbase_get_presult__isset() : success(false), io(false) {}
1490   bool success;
1491   bool io;
1492 } _Hbase_get_presult__isset;
1493
1494 class Hbase_get_presult {
1495  public:
1496
1497
1498   virtual ~Hbase_get_presult() throw() {}
1499
1500   std::vector<TCell> * success;
1501   IOError io;
1502
1503   _Hbase_get_presult__isset __isset;
1504
1505   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1506
1507 };
1508
1509 typedef struct _Hbase_getVer_args__isset {
1510   _Hbase_getVer_args__isset() : tableName(false), row(false), column(false), numVersions(false), attributes(false) {}
1511   bool tableName;
1512   bool row;
1513   bool column;
1514   bool numVersions;
1515   bool attributes;
1516 } _Hbase_getVer_args__isset;
1517
1518 class Hbase_getVer_args {
1519  public:
1520
1521   Hbase_getVer_args() : tableName(), row(), column(), numVersions(0) {
1522   }
1523
1524   virtual ~Hbase_getVer_args() throw() {}
1525
1526   Text tableName;
1527   Text row;
1528   Text column;
1529   int32_t numVersions;
1530   std::map<Text, Text>  attributes;
1531
1532   _Hbase_getVer_args__isset __isset;
1533
1534   void __set_tableName(const Text& val) {
1535     tableName = val;
1536   }
1537
1538   void __set_row(const Text& val) {
1539     row = val;
1540   }
1541
1542   void __set_column(const Text& val) {
1543     column = val;
1544   }
1545
1546   void __set_numVersions(const int32_t val) {
1547     numVersions = val;
1548   }
1549
1550   void __set_attributes(const std::map<Text, Text> & val) {
1551     attributes = val;
1552   }
1553
1554   bool operator == (const Hbase_getVer_args & rhs) const
1555   {
1556     if (!(tableName == rhs.tableName))
1557       return false;
1558     if (!(row == rhs.row))
1559       return false;
1560     if (!(column == rhs.column))
1561       return false;
1562     if (!(numVersions == rhs.numVersions))
1563       return false;
1564     if (!(attributes == rhs.attributes))
1565       return false;
1566     return true;
1567   }
1568   bool operator != (const Hbase_getVer_args &rhs) const {
1569     return !(*this == rhs);
1570   }
1571
1572   bool operator < (const Hbase_getVer_args & ) const;
1573
1574   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1575   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1576
1577 };
1578
1579
1580 class Hbase_getVer_pargs {
1581  public:
1582
1583
1584   virtual ~Hbase_getVer_pargs() throw() {}
1585
1586   const Text* tableName;
1587   const Text* row;
1588   const Text* column;
1589   const int32_t* numVersions;
1590   const std::map<Text, Text> * attributes;
1591
1592   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1593
1594 };
1595
1596 typedef struct _Hbase_getVer_result__isset {
1597   _Hbase_getVer_result__isset() : success(false), io(false) {}
1598   bool success;
1599   bool io;
1600 } _Hbase_getVer_result__isset;
1601
1602 class Hbase_getVer_result {
1603  public:
1604
1605   Hbase_getVer_result() {
1606   }
1607
1608   virtual ~Hbase_getVer_result() throw() {}
1609
1610   std::vector<TCell>  success;
1611   IOError io;
1612
1613   _Hbase_getVer_result__isset __isset;
1614
1615   void __set_success(const std::vector<TCell> & val) {
1616     success = val;
1617   }
1618
1619   void __set_io(const IOError& val) {
1620     io = val;
1621   }
1622
1623   bool operator == (const Hbase_getVer_result & rhs) const
1624   {
1625     if (!(success == rhs.success))
1626       return false;
1627     if (!(io == rhs.io))
1628       return false;
1629     return true;
1630   }
1631   bool operator != (const Hbase_getVer_result &rhs) const {
1632     return !(*this == rhs);
1633   }
1634
1635   bool operator < (const Hbase_getVer_result & ) const;
1636
1637   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1638   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1639
1640 };
1641
1642 typedef struct _Hbase_getVer_presult__isset {
1643   _Hbase_getVer_presult__isset() : success(false), io(false) {}
1644   bool success;
1645   bool io;
1646 } _Hbase_getVer_presult__isset;
1647
1648 class Hbase_getVer_presult {
1649  public:
1650
1651
1652   virtual ~Hbase_getVer_presult() throw() {}
1653
1654   std::vector<TCell> * success;
1655   IOError io;
1656
1657   _Hbase_getVer_presult__isset __isset;
1658
1659   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1660
1661 };
1662
1663 typedef struct _Hbase_getVerTs_args__isset {
1664   _Hbase_getVerTs_args__isset() : tableName(false), row(false), column(false), timestamp(false), numVersions(false), attributes(false) {}
1665   bool tableName;
1666   bool row;
1667   bool column;
1668   bool timestamp;
1669   bool numVersions;
1670   bool attributes;
1671 } _Hbase_getVerTs_args__isset;
1672
1673 class Hbase_getVerTs_args {
1674  public:
1675
1676   Hbase_getVerTs_args() : tableName(), row(), column(), timestamp(0), numVersions(0) {
1677   }
1678
1679   virtual ~Hbase_getVerTs_args() throw() {}
1680
1681   Text tableName;
1682   Text row;
1683   Text column;
1684   int64_t timestamp;
1685   int32_t numVersions;
1686   std::map<Text, Text>  attributes;
1687
1688   _Hbase_getVerTs_args__isset __isset;
1689
1690   void __set_tableName(const Text& val) {
1691     tableName = val;
1692   }
1693
1694   void __set_row(const Text& val) {
1695     row = val;
1696   }
1697
1698   void __set_column(const Text& val) {
1699     column = val;
1700   }
1701
1702   void __set_timestamp(const int64_t val) {
1703     timestamp = val;
1704   }
1705
1706   void __set_numVersions(const int32_t val) {
1707     numVersions = val;
1708   }
1709
1710   void __set_attributes(const std::map<Text, Text> & val) {
1711     attributes = val;
1712   }
1713
1714   bool operator == (const Hbase_getVerTs_args & rhs) const
1715   {
1716     if (!(tableName == rhs.tableName))
1717       return false;
1718     if (!(row == rhs.row))
1719       return false;
1720     if (!(column == rhs.column))
1721       return false;
1722     if (!(timestamp == rhs.timestamp))
1723       return false;
1724     if (!(numVersions == rhs.numVersions))
1725       return false;
1726     if (!(attributes == rhs.attributes))
1727       return false;
1728     return true;
1729   }
1730   bool operator != (const Hbase_getVerTs_args &rhs) const {
1731     return !(*this == rhs);
1732   }
1733
1734   bool operator < (const Hbase_getVerTs_args & ) const;
1735
1736   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1737   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1738
1739 };
1740
1741
1742 class Hbase_getVerTs_pargs {
1743  public:
1744
1745
1746   virtual ~Hbase_getVerTs_pargs() throw() {}
1747
1748   const Text* tableName;
1749   const Text* row;
1750   const Text* column;
1751   const int64_t* timestamp;
1752   const int32_t* numVersions;
1753   const std::map<Text, Text> * attributes;
1754
1755   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1756
1757 };
1758
1759 typedef struct _Hbase_getVerTs_result__isset {
1760   _Hbase_getVerTs_result__isset() : success(false), io(false) {}
1761   bool success;
1762   bool io;
1763 } _Hbase_getVerTs_result__isset;
1764
1765 class Hbase_getVerTs_result {
1766  public:
1767
1768   Hbase_getVerTs_result() {
1769   }
1770
1771   virtual ~Hbase_getVerTs_result() throw() {}
1772
1773   std::vector<TCell>  success;
1774   IOError io;
1775
1776   _Hbase_getVerTs_result__isset __isset;
1777
1778   void __set_success(const std::vector<TCell> & val) {
1779     success = val;
1780   }
1781
1782   void __set_io(const IOError& val) {
1783     io = val;
1784   }
1785
1786   bool operator == (const Hbase_getVerTs_result & rhs) const
1787   {
1788     if (!(success == rhs.success))
1789       return false;
1790     if (!(io == rhs.io))
1791       return false;
1792     return true;
1793   }
1794   bool operator != (const Hbase_getVerTs_result &rhs) const {
1795     return !(*this == rhs);
1796   }
1797
1798   bool operator < (const Hbase_getVerTs_result & ) const;
1799
1800   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1801   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1802
1803 };
1804
1805 typedef struct _Hbase_getVerTs_presult__isset {
1806   _Hbase_getVerTs_presult__isset() : success(false), io(false) {}
1807   bool success;
1808   bool io;
1809 } _Hbase_getVerTs_presult__isset;
1810
1811 class Hbase_getVerTs_presult {
1812  public:
1813
1814
1815   virtual ~Hbase_getVerTs_presult() throw() {}
1816
1817   std::vector<TCell> * success;
1818   IOError io;
1819
1820   _Hbase_getVerTs_presult__isset __isset;
1821
1822   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1823
1824 };
1825
1826 typedef struct _Hbase_getRow_args__isset {
1827   _Hbase_getRow_args__isset() : tableName(false), row(false), attributes(false) {}
1828   bool tableName;
1829   bool row;
1830   bool attributes;
1831 } _Hbase_getRow_args__isset;
1832
1833 class Hbase_getRow_args {
1834  public:
1835
1836   Hbase_getRow_args() : tableName(), row() {
1837   }
1838
1839   virtual ~Hbase_getRow_args() throw() {}
1840
1841   Text tableName;
1842   Text row;
1843   std::map<Text, Text>  attributes;
1844
1845   _Hbase_getRow_args__isset __isset;
1846
1847   void __set_tableName(const Text& val) {
1848     tableName = val;
1849   }
1850
1851   void __set_row(const Text& val) {
1852     row = val;
1853   }
1854
1855   void __set_attributes(const std::map<Text, Text> & val) {
1856     attributes = val;
1857   }
1858
1859   bool operator == (const Hbase_getRow_args & rhs) const
1860   {
1861     if (!(tableName == rhs.tableName))
1862       return false;
1863     if (!(row == rhs.row))
1864       return false;
1865     if (!(attributes == rhs.attributes))
1866       return false;
1867     return true;
1868   }
1869   bool operator != (const Hbase_getRow_args &rhs) const {
1870     return !(*this == rhs);
1871   }
1872
1873   bool operator < (const Hbase_getRow_args & ) const;
1874
1875   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1876   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1877
1878 };
1879
1880
1881 class Hbase_getRow_pargs {
1882  public:
1883
1884
1885   virtual ~Hbase_getRow_pargs() throw() {}
1886
1887   const Text* tableName;
1888   const Text* row;
1889   const std::map<Text, Text> * attributes;
1890
1891   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1892
1893 };
1894
1895 typedef struct _Hbase_getRow_result__isset {
1896   _Hbase_getRow_result__isset() : success(false), io(false) {}
1897   bool success;
1898   bool io;
1899 } _Hbase_getRow_result__isset;
1900
1901 class Hbase_getRow_result {
1902  public:
1903
1904   Hbase_getRow_result() {
1905   }
1906
1907   virtual ~Hbase_getRow_result() throw() {}
1908
1909   std::vector<TRowResult>  success;
1910   IOError io;
1911
1912   _Hbase_getRow_result__isset __isset;
1913
1914   void __set_success(const std::vector<TRowResult> & val) {
1915     success = val;
1916   }
1917
1918   void __set_io(const IOError& val) {
1919     io = val;
1920   }
1921
1922   bool operator == (const Hbase_getRow_result & rhs) const
1923   {
1924     if (!(success == rhs.success))
1925       return false;
1926     if (!(io == rhs.io))
1927       return false;
1928     return true;
1929   }
1930   bool operator != (const Hbase_getRow_result &rhs) const {
1931     return !(*this == rhs);
1932   }
1933
1934   bool operator < (const Hbase_getRow_result & ) const;
1935
1936   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1937   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1938
1939 };
1940
1941 typedef struct _Hbase_getRow_presult__isset {
1942   _Hbase_getRow_presult__isset() : success(false), io(false) {}
1943   bool success;
1944   bool io;
1945 } _Hbase_getRow_presult__isset;
1946
1947 class Hbase_getRow_presult {
1948  public:
1949
1950
1951   virtual ~Hbase_getRow_presult() throw() {}
1952
1953   std::vector<TRowResult> * success;
1954   IOError io;
1955
1956   _Hbase_getRow_presult__isset __isset;
1957
1958   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1959
1960 };
1961
1962 typedef struct _Hbase_getRowWithColumns_args__isset {
1963   _Hbase_getRowWithColumns_args__isset() : tableName(false), row(false), columns(false), attributes(false) {}
1964   bool tableName;
1965   bool row;
1966   bool columns;
1967   bool attributes;
1968 } _Hbase_getRowWithColumns_args__isset;
1969
1970 class Hbase_getRowWithColumns_args {
1971  public:
1972
1973   Hbase_getRowWithColumns_args() : tableName(), row() {
1974   }
1975
1976   virtual ~Hbase_getRowWithColumns_args() throw() {}
1977
1978   Text tableName;
1979   Text row;
1980   std::vector<Text>  columns;
1981   std::map<Text, Text>  attributes;
1982
1983   _Hbase_getRowWithColumns_args__isset __isset;
1984
1985   void __set_tableName(const Text& val) {
1986     tableName = val;
1987   }
1988
1989   void __set_row(const Text& val) {
1990     row = val;
1991   }
1992
1993   void __set_columns(const std::vector<Text> & val) {
1994     columns = val;
1995   }
1996
1997   void __set_attributes(const std::map<Text, Text> & val) {
1998     attributes = val;
1999   }
2000
2001   bool operator == (const Hbase_getRowWithColumns_args & rhs) const
2002   {
2003     if (!(tableName == rhs.tableName))
2004       return false;
2005     if (!(row == rhs.row))
2006       return false;
2007     if (!(columns == rhs.columns))
2008       return false;
2009     if (!(attributes == rhs.attributes))
2010       return false;
2011     return true;
2012   }
2013   bool operator != (const Hbase_getRowWithColumns_args &rhs) const {
2014     return !(*this == rhs);
2015   }
2016
2017   bool operator < (const Hbase_getRowWithColumns_args & ) const;
2018
2019   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2020   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2021
2022 };
2023
2024
2025 class Hbase_getRowWithColumns_pargs {
2026  public:
2027
2028
2029   virtual ~Hbase_getRowWithColumns_pargs() throw() {}
2030
2031   const Text* tableName;
2032   const Text* row;
2033   const std::vector<Text> * columns;
2034   const std::map<Text, Text> * attributes;
2035
2036   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2037
2038 };
2039
2040 typedef struct _Hbase_getRowWithColumns_result__isset {
2041   _Hbase_getRowWithColumns_result__isset() : success(false), io(false) {}
2042   bool success;
2043   bool io;
2044 } _Hbase_getRowWithColumns_result__isset;
2045
2046 class Hbase_getRowWithColumns_result {
2047  public:
2048
2049   Hbase_getRowWithColumns_result() {
2050   }
2051
2052   virtual ~Hbase_getRowWithColumns_result() throw() {}
2053
2054   std::vector<TRowResult>  success;
2055   IOError io;
2056
2057   _Hbase_getRowWithColumns_result__isset __isset;
2058
2059   void __set_success(const std::vector<TRowResult> & val) {
2060     success = val;
2061   }
2062
2063   void __set_io(const IOError& val) {
2064     io = val;
2065   }
2066
2067   bool operator == (const Hbase_getRowWithColumns_result & rhs) const
2068   {
2069     if (!(success == rhs.success))
2070       return false;
2071     if (!(io == rhs.io))
2072       return false;
2073     return true;
2074   }
2075   bool operator != (const Hbase_getRowWithColumns_result &rhs) const {
2076     return !(*this == rhs);
2077   }
2078
2079   bool operator < (const Hbase_getRowWithColumns_result & ) const;
2080
2081   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2082   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2083
2084 };
2085
2086 typedef struct _Hbase_getRowWithColumns_presult__isset {
2087   _Hbase_getRowWithColumns_presult__isset() : success(false), io(false) {}
2088   bool success;
2089   bool io;
2090 } _Hbase_getRowWithColumns_presult__isset;
2091
2092 class Hbase_getRowWithColumns_presult {
2093  public:
2094
2095
2096   virtual ~Hbase_getRowWithColumns_presult() throw() {}
2097
2098   std::vector<TRowResult> * success;
2099   IOError io;
2100
2101   _Hbase_getRowWithColumns_presult__isset __isset;
2102
2103   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2104
2105 };
2106
2107 typedef struct _Hbase_getRowTs_args__isset {
2108   _Hbase_getRowTs_args__isset() : tableName(false), row(false), timestamp(false), attributes(false) {}
2109   bool tableName;
2110   bool row;
2111   bool timestamp;
2112   bool attributes;
2113 } _Hbase_getRowTs_args__isset;
2114
2115 class Hbase_getRowTs_args {
2116  public:
2117
2118   Hbase_getRowTs_args() : tableName(), row(), timestamp(0) {
2119   }
2120
2121   virtual ~Hbase_getRowTs_args() throw() {}
2122
2123   Text tableName;
2124   Text row;
2125   int64_t timestamp;
2126   std::map<Text, Text>  attributes;
2127
2128   _Hbase_getRowTs_args__isset __isset;
2129
2130   void __set_tableName(const Text& val) {
2131     tableName = val;
2132   }
2133
2134   void __set_row(const Text& val) {
2135     row = val;
2136   }
2137
2138   void __set_timestamp(const int64_t val) {
2139     timestamp = val;
2140   }
2141
2142   void __set_attributes(const std::map<Text, Text> & val) {
2143     attributes = val;
2144   }
2145
2146   bool operator == (const Hbase_getRowTs_args & rhs) const
2147   {
2148     if (!(tableName == rhs.tableName))
2149       return false;
2150     if (!(row == rhs.row))
2151       return false;
2152     if (!(timestamp == rhs.timestamp))
2153       return false;
2154     if (!(attributes == rhs.attributes))
2155       return false;
2156     return true;
2157   }
2158   bool operator != (const Hbase_getRowTs_args &rhs) const {
2159     return !(*this == rhs);
2160   }
2161
2162   bool operator < (const Hbase_getRowTs_args & ) const;
2163
2164   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2165   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2166
2167 };
2168
2169
2170 class Hbase_getRowTs_pargs {
2171  public:
2172
2173
2174   virtual ~Hbase_getRowTs_pargs() throw() {}
2175
2176   const Text* tableName;
2177   const Text* row;
2178   const int64_t* timestamp;
2179   const std::map<Text, Text> * attributes;
2180
2181   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2182
2183 };
2184
2185 typedef struct _Hbase_getRowTs_result__isset {
2186   _Hbase_getRowTs_result__isset() : success(false), io(false) {}
2187   bool success;
2188   bool io;
2189 } _Hbase_getRowTs_result__isset;
2190
2191 class Hbase_getRowTs_result {
2192  public:
2193
2194   Hbase_getRowTs_result() {
2195   }
2196
2197   virtual ~Hbase_getRowTs_result() throw() {}
2198
2199   std::vector<TRowResult>  success;
2200   IOError io;
2201
2202   _Hbase_getRowTs_result__isset __isset;
2203
2204   void __set_success(const std::vector<TRowResult> & val) {
2205     success = val;
2206   }
2207
2208   void __set_io(const IOError& val) {
2209     io = val;
2210   }
2211
2212   bool operator == (const Hbase_getRowTs_result & rhs) const
2213   {
2214     if (!(success == rhs.success))
2215       return false;
2216     if (!(io == rhs.io))
2217       return false;
2218     return true;
2219   }
2220   bool operator != (const Hbase_getRowTs_result &rhs) const {
2221     return !(*this == rhs);
2222   }
2223
2224   bool operator < (const Hbase_getRowTs_result & ) const;
2225
2226   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2227   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2228
2229 };
2230
2231 typedef struct _Hbase_getRowTs_presult__isset {
2232   _Hbase_getRowTs_presult__isset() : success(false), io(false) {}
2233   bool success;
2234   bool io;
2235 } _Hbase_getRowTs_presult__isset;
2236
2237 class Hbase_getRowTs_presult {
2238  public:
2239
2240
2241   virtual ~Hbase_getRowTs_presult() throw() {}
2242
2243   std::vector<TRowResult> * success;
2244   IOError io;
2245
2246   _Hbase_getRowTs_presult__isset __isset;
2247
2248   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2249
2250 };
2251
2252 typedef struct _Hbase_getRowWithColumnsTs_args__isset {
2253   _Hbase_getRowWithColumnsTs_args__isset() : tableName(false), row(false), columns(false), timestamp(false), attributes(false) {}
2254   bool tableName;
2255   bool row;
2256   bool columns;
2257   bool timestamp;
2258   bool attributes;
2259 } _Hbase_getRowWithColumnsTs_args__isset;
2260
2261 class Hbase_getRowWithColumnsTs_args {
2262  public:
2263
2264   Hbase_getRowWithColumnsTs_args() : tableName(), row(), timestamp(0) {
2265   }
2266
2267   virtual ~Hbase_getRowWithColumnsTs_args() throw() {}
2268
2269   Text tableName;
2270   Text row;
2271   std::vector<Text>  columns;
2272   int64_t timestamp;
2273   std::map<Text, Text>  attributes;
2274
2275   _Hbase_getRowWithColumnsTs_args__isset __isset;
2276
2277   void __set_tableName(const Text& val) {
2278     tableName = val;
2279   }
2280
2281   void __set_row(const Text& val) {
2282     row = val;
2283   }
2284
2285   void __set_columns(const std::vector<Text> & val) {
2286     columns = val;
2287   }
2288
2289   void __set_timestamp(const int64_t val) {
2290     timestamp = val;
2291   }
2292
2293   void __set_attributes(const std::map<Text, Text> & val) {
2294     attributes = val;
2295   }
2296
2297   bool operator == (const Hbase_getRowWithColumnsTs_args & rhs) const
2298   {
2299     if (!(tableName == rhs.tableName))
2300       return false;
2301     if (!(row == rhs.row))
2302       return false;
2303     if (!(columns == rhs.columns))
2304       return false;
2305     if (!(timestamp == rhs.timestamp))
2306       return false;
2307     if (!(attributes == rhs.attributes))
2308       return false;
2309     return true;
2310   }
2311   bool operator != (const Hbase_getRowWithColumnsTs_args &rhs) const {
2312     return !(*this == rhs);
2313   }
2314
2315   bool operator < (const Hbase_getRowWithColumnsTs_args & ) const;
2316
2317   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2318   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2319
2320 };
2321
2322
2323 class Hbase_getRowWithColumnsTs_pargs {
2324  public:
2325
2326
2327   virtual ~Hbase_getRowWithColumnsTs_pargs() throw() {}
2328
2329   const Text* tableName;
2330   const Text* row;
2331   const std::vector<Text> * columns;
2332   const int64_t* timestamp;
2333   const std::map<Text, Text> * attributes;
2334
2335   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2336
2337 };
2338
2339 typedef struct _Hbase_getRowWithColumnsTs_result__isset {
2340   _Hbase_getRowWithColumnsTs_result__isset() : success(false), io(false) {}
2341   bool success;
2342   bool io;
2343 } _Hbase_getRowWithColumnsTs_result__isset;
2344
2345 class Hbase_getRowWithColumnsTs_result {
2346  public:
2347
2348   Hbase_getRowWithColumnsTs_result() {
2349   }
2350
2351   virtual ~Hbase_getRowWithColumnsTs_result() throw() {}
2352
2353   std::vector<TRowResult>  success;
2354   IOError io;
2355
2356   _Hbase_getRowWithColumnsTs_result__isset __isset;
2357
2358   void __set_success(const std::vector<TRowResult> & val) {
2359     success = val;
2360   }
2361
2362   void __set_io(const IOError& val) {
2363     io = val;
2364   }
2365
2366   bool operator == (const Hbase_getRowWithColumnsTs_result & rhs) const
2367   {
2368     if (!(success == rhs.success))
2369       return false;
2370     if (!(io == rhs.io))
2371       return false;
2372     return true;
2373   }
2374   bool operator != (const Hbase_getRowWithColumnsTs_result &rhs) const {
2375     return !(*this == rhs);
2376   }
2377
2378   bool operator < (const Hbase_getRowWithColumnsTs_result & ) const;
2379
2380   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2381   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2382
2383 };
2384
2385 typedef struct _Hbase_getRowWithColumnsTs_presult__isset {
2386   _Hbase_getRowWithColumnsTs_presult__isset() : success(false), io(false) {}
2387   bool success;
2388   bool io;
2389 } _Hbase_getRowWithColumnsTs_presult__isset;
2390
2391 class Hbase_getRowWithColumnsTs_presult {
2392  public:
2393
2394
2395   virtual ~Hbase_getRowWithColumnsTs_presult() throw() {}
2396
2397   std::vector<TRowResult> * success;
2398   IOError io;
2399
2400   _Hbase_getRowWithColumnsTs_presult__isset __isset;
2401
2402   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2403
2404 };
2405
2406 typedef struct _Hbase_getRows_args__isset {
2407   _Hbase_getRows_args__isset() : tableName(false), rows(false), attributes(false) {}
2408   bool tableName;
2409   bool rows;
2410   bool attributes;
2411 } _Hbase_getRows_args__isset;
2412
2413 class Hbase_getRows_args {
2414  public:
2415
2416   Hbase_getRows_args() : tableName() {
2417   }
2418
2419   virtual ~Hbase_getRows_args() throw() {}
2420
2421   Text tableName;
2422   std::vector<Text>  rows;
2423   std::map<Text, Text>  attributes;
2424
2425   _Hbase_getRows_args__isset __isset;
2426
2427   void __set_tableName(const Text& val) {
2428     tableName = val;
2429   }
2430
2431   void __set_rows(const std::vector<Text> & val) {
2432     rows = val;
2433   }
2434
2435   void __set_attributes(const std::map<Text, Text> & val) {
2436     attributes = val;
2437   }
2438
2439   bool operator == (const Hbase_getRows_args & rhs) const
2440   {
2441     if (!(tableName == rhs.tableName))
2442       return false;
2443     if (!(rows == rhs.rows))
2444       return false;
2445     if (!(attributes == rhs.attributes))
2446       return false;
2447     return true;
2448   }
2449   bool operator != (const Hbase_getRows_args &rhs) const {
2450     return !(*this == rhs);
2451   }
2452
2453   bool operator < (const Hbase_getRows_args & ) const;
2454
2455   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2456   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2457
2458 };
2459
2460
2461 class Hbase_getRows_pargs {
2462  public:
2463
2464
2465   virtual ~Hbase_getRows_pargs() throw() {}
2466
2467   const Text* tableName;
2468   const std::vector<Text> * rows;
2469   const std::map<Text, Text> * attributes;
2470
2471   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2472
2473 };
2474
2475 typedef struct _Hbase_getRows_result__isset {
2476   _Hbase_getRows_result__isset() : success(false), io(false) {}
2477   bool success;
2478   bool io;
2479 } _Hbase_getRows_result__isset;
2480
2481 class Hbase_getRows_result {
2482  public:
2483
2484   Hbase_getRows_result() {
2485   }
2486
2487   virtual ~Hbase_getRows_result() throw() {}
2488
2489   std::vector<TRowResult>  success;
2490   IOError io;
2491
2492   _Hbase_getRows_result__isset __isset;
2493
2494   void __set_success(const std::vector<TRowResult> & val) {
2495     success = val;
2496   }
2497
2498   void __set_io(const IOError& val) {
2499     io = val;
2500   }
2501
2502   bool operator == (const Hbase_getRows_result & rhs) const
2503   {
2504     if (!(success == rhs.success))
2505       return false;
2506     if (!(io == rhs.io))
2507       return false;
2508     return true;
2509   }
2510   bool operator != (const Hbase_getRows_result &rhs) const {
2511     return !(*this == rhs);
2512   }
2513
2514   bool operator < (const Hbase_getRows_result & ) const;
2515
2516   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2517   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2518
2519 };
2520
2521 typedef struct _Hbase_getRows_presult__isset {
2522   _Hbase_getRows_presult__isset() : success(false), io(false) {}
2523   bool success;
2524   bool io;
2525 } _Hbase_getRows_presult__isset;
2526
2527 class Hbase_getRows_presult {
2528  public:
2529
2530
2531   virtual ~Hbase_getRows_presult() throw() {}
2532
2533   std::vector<TRowResult> * success;
2534   IOError io;
2535
2536   _Hbase_getRows_presult__isset __isset;
2537
2538   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2539
2540 };
2541
2542 typedef struct _Hbase_getRowsWithColumns_args__isset {
2543   _Hbase_getRowsWithColumns_args__isset() : tableName(false), rows(false), columns(false), attributes(false) {}
2544   bool tableName;
2545   bool rows;
2546   bool columns;
2547   bool attributes;
2548 } _Hbase_getRowsWithColumns_args__isset;
2549
2550 class Hbase_getRowsWithColumns_args {
2551  public:
2552
2553   Hbase_getRowsWithColumns_args() : tableName() {
2554   }
2555
2556   virtual ~Hbase_getRowsWithColumns_args() throw() {}
2557
2558   Text tableName;
2559   std::vector<Text>  rows;
2560   std::vector<Text>  columns;
2561   std::map<Text, Text>  attributes;
2562
2563   _Hbase_getRowsWithColumns_args__isset __isset;
2564
2565   void __set_tableName(const Text& val) {
2566     tableName = val;
2567   }
2568
2569   void __set_rows(const std::vector<Text> & val) {
2570     rows = val;
2571   }
2572
2573   void __set_columns(const std::vector<Text> & val) {
2574     columns = val;
2575   }
2576
2577   void __set_attributes(const std::map<Text, Text> & val) {
2578     attributes = val;
2579   }
2580
2581   bool operator == (const Hbase_getRowsWithColumns_args & rhs) const
2582   {
2583     if (!(tableName == rhs.tableName))
2584       return false;
2585     if (!(rows == rhs.rows))
2586       return false;
2587     if (!(columns == rhs.columns))
2588       return false;
2589     if (!(attributes == rhs.attributes))
2590       return false;
2591     return true;
2592   }
2593   bool operator != (const Hbase_getRowsWithColumns_args &rhs) const {
2594     return !(*this == rhs);
2595   }
2596
2597   bool operator < (const Hbase_getRowsWithColumns_args & ) const;
2598
2599   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2600   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2601
2602 };
2603
2604
2605 class Hbase_getRowsWithColumns_pargs {
2606  public:
2607
2608
2609   virtual ~Hbase_getRowsWithColumns_pargs() throw() {}
2610
2611   const Text* tableName;
2612   const std::vector<Text> * rows;
2613   const std::vector<Text> * columns;
2614   const std::map<Text, Text> * attributes;
2615
2616   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2617
2618 };
2619
2620 typedef struct _Hbase_getRowsWithColumns_result__isset {
2621   _Hbase_getRowsWithColumns_result__isset() : success(false), io(false) {}
2622   bool success;
2623   bool io;
2624 } _Hbase_getRowsWithColumns_result__isset;
2625
2626 class Hbase_getRowsWithColumns_result {
2627  public:
2628
2629   Hbase_getRowsWithColumns_result() {
2630   }
2631
2632   virtual ~Hbase_getRowsWithColumns_result() throw() {}
2633
2634   std::vector<TRowResult>  success;
2635   IOError io;
2636
2637   _Hbase_getRowsWithColumns_result__isset __isset;
2638
2639   void __set_success(const std::vector<TRowResult> & val) {
2640     success = val;
2641   }
2642
2643   void __set_io(const IOError& val) {
2644     io = val;
2645   }
2646
2647   bool operator == (const Hbase_getRowsWithColumns_result & rhs) const
2648   {
2649     if (!(success == rhs.success))
2650       return false;
2651     if (!(io == rhs.io))
2652       return false;
2653     return true;
2654   }
2655   bool operator != (const Hbase_getRowsWithColumns_result &rhs) const {
2656     return !(*this == rhs);
2657   }
2658
2659   bool operator < (const Hbase_getRowsWithColumns_result & ) const;
2660
2661   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2662   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2663
2664 };
2665
2666 typedef struct _Hbase_getRowsWithColumns_presult__isset {
2667   _Hbase_getRowsWithColumns_presult__isset() : success(false), io(false) {}
2668   bool success;
2669   bool io;
2670 } _Hbase_getRowsWithColumns_presult__isset;
2671
2672 class Hbase_getRowsWithColumns_presult {
2673  public:
2674
2675
2676   virtual ~Hbase_getRowsWithColumns_presult() throw() {}
2677
2678   std::vector<TRowResult> * success;
2679   IOError io;
2680
2681   _Hbase_getRowsWithColumns_presult__isset __isset;
2682
2683   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2684
2685 };
2686
2687 typedef struct _Hbase_getRowsTs_args__isset {
2688   _Hbase_getRowsTs_args__isset() : tableName(false), rows(false), timestamp(false), attributes(false) {}
2689   bool tableName;
2690   bool rows;
2691   bool timestamp;
2692   bool attributes;
2693 } _Hbase_getRowsTs_args__isset;
2694
2695 class Hbase_getRowsTs_args {
2696  public:
2697
2698   Hbase_getRowsTs_args() : tableName(), timestamp(0) {
2699   }
2700
2701   virtual ~Hbase_getRowsTs_args() throw() {}
2702
2703   Text tableName;
2704   std::vector<Text>  rows;
2705   int64_t timestamp;
2706   std::map<Text, Text>  attributes;
2707
2708   _Hbase_getRowsTs_args__isset __isset;
2709
2710   void __set_tableName(const Text& val) {
2711     tableName = val;
2712   }
2713
2714   void __set_rows(const std::vector<Text> & val) {
2715     rows = val;
2716   }
2717
2718   void __set_timestamp(const int64_t val) {
2719     timestamp = val;
2720   }
2721
2722   void __set_attributes(const std::map<Text, Text> & val) {
2723     attributes = val;
2724   }
2725
2726   bool operator == (const Hbase_getRowsTs_args & rhs) const
2727   {
2728     if (!(tableName == rhs.tableName))
2729       return false;
2730     if (!(rows == rhs.rows))
2731       return false;
2732     if (!(timestamp == rhs.timestamp))
2733       return false;
2734     if (!(attributes == rhs.attributes))
2735       return false;
2736     return true;
2737   }
2738   bool operator != (const Hbase_getRowsTs_args &rhs) const {
2739     return !(*this == rhs);
2740   }
2741
2742   bool operator < (const Hbase_getRowsTs_args & ) const;
2743
2744   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2745   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2746
2747 };
2748
2749
2750 class Hbase_getRowsTs_pargs {
2751  public:
2752
2753
2754   virtual ~Hbase_getRowsTs_pargs() throw() {}
2755
2756   const Text* tableName;
2757   const std::vector<Text> * rows;
2758   const int64_t* timestamp;
2759   const std::map<Text, Text> * attributes;
2760
2761   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2762
2763 };
2764
2765 typedef struct _Hbase_getRowsTs_result__isset {
2766   _Hbase_getRowsTs_result__isset() : success(false), io(false) {}
2767   bool success;
2768   bool io;
2769 } _Hbase_getRowsTs_result__isset;
2770
2771 class Hbase_getRowsTs_result {
2772  public:
2773
2774   Hbase_getRowsTs_result() {
2775   }
2776
2777   virtual ~Hbase_getRowsTs_result() throw() {}
2778
2779   std::vector<TRowResult>  success;
2780   IOError io;
2781
2782   _Hbase_getRowsTs_result__isset __isset;
2783
2784   void __set_success(const std::vector<TRowResult> & val) {
2785     success = val;
2786   }
2787
2788   void __set_io(const IOError& val) {
2789     io = val;
2790   }
2791
2792   bool operator == (const Hbase_getRowsTs_result & rhs) const
2793   {
2794     if (!(success == rhs.success))
2795       return false;
2796     if (!(io == rhs.io))
2797       return false;
2798     return true;
2799   }
2800   bool operator != (const Hbase_getRowsTs_result &rhs) const {
2801     return !(*this == rhs);
2802   }
2803
2804   bool operator < (const Hbase_getRowsTs_result & ) const;
2805
2806   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2807   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2808
2809 };
2810
2811 typedef struct _Hbase_getRowsTs_presult__isset {
2812   _Hbase_getRowsTs_presult__isset() : success(false), io(false) {}
2813   bool success;
2814   bool io;
2815 } _Hbase_getRowsTs_presult__isset;
2816
2817 class Hbase_getRowsTs_presult {
2818  public:
2819
2820
2821   virtual ~Hbase_getRowsTs_presult() throw() {}
2822
2823   std::vector<TRowResult> * success;
2824   IOError io;
2825
2826   _Hbase_getRowsTs_presult__isset __isset;
2827
2828   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2829
2830 };
2831
2832 typedef struct _Hbase_getRowsWithColumnsTs_args__isset {
2833   _Hbase_getRowsWithColumnsTs_args__isset() : tableName(false), rows(false), columns(false), timestamp(false), attributes(false) {}
2834   bool tableName;
2835   bool rows;
2836   bool columns;
2837   bool timestamp;
2838   bool attributes;
2839 } _Hbase_getRowsWithColumnsTs_args__isset;
2840
2841 class Hbase_getRowsWithColumnsTs_args {
2842  public:
2843
2844   Hbase_getRowsWithColumnsTs_args() : tableName(), timestamp(0) {
2845   }
2846
2847   virtual ~Hbase_getRowsWithColumnsTs_args() throw() {}
2848
2849   Text tableName;
2850   std::vector<Text>  rows;
2851   std::vector<Text>  columns;
2852   int64_t timestamp;
2853   std::map<Text, Text>  attributes;
2854
2855   _Hbase_getRowsWithColumnsTs_args__isset __isset;
2856
2857   void __set_tableName(const Text& val) {
2858     tableName = val;
2859   }
2860
2861   void __set_rows(const std::vector<Text> & val) {
2862     rows = val;
2863   }
2864
2865   void __set_columns(const std::vector<Text> & val) {
2866     columns = val;
2867   }
2868
2869   void __set_timestamp(const int64_t val) {
2870     timestamp = val;
2871   }
2872
2873   void __set_attributes(const std::map<Text, Text> & val) {
2874     attributes = val;
2875   }
2876
2877   bool operator == (const Hbase_getRowsWithColumnsTs_args & rhs) const
2878   {
2879     if (!(tableName == rhs.tableName))
2880       return false;
2881     if (!(rows == rhs.rows))
2882       return false;
2883     if (!(columns == rhs.columns))
2884       return false;
2885     if (!(timestamp == rhs.timestamp))
2886       return false;
2887     if (!(attributes == rhs.attributes))
2888       return false;
2889     return true;
2890   }
2891   bool operator != (const Hbase_getRowsWithColumnsTs_args &rhs) const {
2892     return !(*this == rhs);
2893   }
2894
2895   bool operator < (const Hbase_getRowsWithColumnsTs_args & ) const;
2896
2897   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2898   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2899
2900 };
2901
2902
2903 class Hbase_getRowsWithColumnsTs_pargs {
2904  public:
2905
2906
2907   virtual ~Hbase_getRowsWithColumnsTs_pargs() throw() {}
2908
2909   const Text* tableName;
2910   const std::vector<Text> * rows;
2911   const std::vector<Text> * columns;
2912   const int64_t* timestamp;
2913   const std::map<Text, Text> * attributes;
2914
2915   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2916
2917 };
2918
2919 typedef struct _Hbase_getRowsWithColumnsTs_result__isset {
2920   _Hbase_getRowsWithColumnsTs_result__isset() : success(false), io(false) {}
2921   bool success;
2922   bool io;
2923 } _Hbase_getRowsWithColumnsTs_result__isset;
2924
2925 class Hbase_getRowsWithColumnsTs_result {
2926  public:
2927
2928   Hbase_getRowsWithColumnsTs_result() {
2929   }
2930
2931   virtual ~Hbase_getRowsWithColumnsTs_result() throw() {}
2932
2933   std::vector<TRowResult>  success;
2934   IOError io;
2935
2936   _Hbase_getRowsWithColumnsTs_result__isset __isset;
2937
2938   void __set_success(const std::vector<TRowResult> & val) {
2939     success = val;
2940   }
2941
2942   void __set_io(const IOError& val) {
2943     io = val;
2944   }
2945
2946   bool operator == (const Hbase_getRowsWithColumnsTs_result & rhs) const
2947   {
2948     if (!(success == rhs.success))
2949       return false;
2950     if (!(io == rhs.io))
2951       return false;
2952     return true;
2953   }
2954   bool operator != (const Hbase_getRowsWithColumnsTs_result &rhs) const {
2955     return !(*this == rhs);
2956   }
2957
2958   bool operator < (const Hbase_getRowsWithColumnsTs_result & ) const;
2959
2960   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2961   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2962
2963 };
2964
2965 typedef struct _Hbase_getRowsWithColumnsTs_presult__isset {
2966   _Hbase_getRowsWithColumnsTs_presult__isset() : success(false), io(false) {}
2967   bool success;
2968   bool io;
2969 } _Hbase_getRowsWithColumnsTs_presult__isset;
2970
2971 class Hbase_getRowsWithColumnsTs_presult {
2972  public:
2973
2974
2975   virtual ~Hbase_getRowsWithColumnsTs_presult() throw() {}
2976
2977   std::vector<TRowResult> * success;
2978   IOError io;
2979
2980   _Hbase_getRowsWithColumnsTs_presult__isset __isset;
2981
2982   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2983
2984 };
2985
2986 typedef struct _Hbase_mutateRow_args__isset {
2987   _Hbase_mutateRow_args__isset() : tableName(false), row(false), mutations(false), attributes(false) {}
2988   bool tableName;
2989   bool row;
2990   bool mutations;
2991   bool attributes;
2992 } _Hbase_mutateRow_args__isset;
2993
2994 class Hbase_mutateRow_args {
2995  public:
2996
2997   Hbase_mutateRow_args() : tableName(), row() {
2998   }
2999
3000   virtual ~Hbase_mutateRow_args() throw() {}
3001
3002   Text tableName;
3003   Text row;
3004   std::vector<Mutation>  mutations;
3005   std::map<Text, Text>  attributes;
3006
3007   _Hbase_mutateRow_args__isset __isset;
3008
3009   void __set_tableName(const Text& val) {
3010     tableName = val;
3011   }
3012
3013   void __set_row(const Text& val) {
3014     row = val;
3015   }
3016
3017   void __set_mutations(const std::vector<Mutation> & val) {
3018     mutations = val;
3019   }
3020
3021   void __set_attributes(const std::map<Text, Text> & val) {
3022     attributes = val;
3023   }
3024
3025   bool operator == (const Hbase_mutateRow_args & rhs) const
3026   {
3027     if (!(tableName == rhs.tableName))
3028       return false;
3029     if (!(row == rhs.row))
3030       return false;
3031     if (!(mutations == rhs.mutations))
3032       return false;
3033     if (!(attributes == rhs.attributes))
3034       return false;
3035     return true;
3036   }
3037   bool operator != (const Hbase_mutateRow_args &rhs) const {
3038     return !(*this == rhs);
3039   }
3040
3041   bool operator < (const Hbase_mutateRow_args & ) const;
3042
3043   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3044   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3045
3046 };
3047
3048
3049 class Hbase_mutateRow_pargs {
3050  public:
3051
3052
3053   virtual ~Hbase_mutateRow_pargs() throw() {}
3054
3055   const Text* tableName;
3056   const Text* row;
3057   const std::vector<Mutation> * mutations;
3058   const std::map<Text, Text> * attributes;
3059
3060   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3061
3062 };
3063
3064 typedef struct _Hbase_mutateRow_result__isset {
3065   _Hbase_mutateRow_result__isset() : io(false), ia(false) {}
3066   bool io;
3067   bool ia;
3068 } _Hbase_mutateRow_result__isset;
3069
3070 class Hbase_mutateRow_result {
3071  public:
3072
3073   Hbase_mutateRow_result() {
3074   }
3075
3076   virtual ~Hbase_mutateRow_result() throw() {}
3077
3078   IOError io;
3079   IllegalArgument ia;
3080
3081   _Hbase_mutateRow_result__isset __isset;
3082
3083   void __set_io(const IOError& val) {
3084     io = val;
3085   }
3086
3087   void __set_ia(const IllegalArgument& val) {
3088     ia = val;
3089   }
3090
3091   bool operator == (const Hbase_mutateRow_result & rhs) const
3092   {
3093     if (!(io == rhs.io))
3094       return false;
3095     if (!(ia == rhs.ia))
3096       return false;
3097     return true;
3098   }
3099   bool operator != (const Hbase_mutateRow_result &rhs) const {
3100     return !(*this == rhs);
3101   }
3102
3103   bool operator < (const Hbase_mutateRow_result & ) const;
3104
3105   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3106   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3107
3108 };
3109
3110 typedef struct _Hbase_mutateRow_presult__isset {
3111   _Hbase_mutateRow_presult__isset() : io(false), ia(false) {}
3112   bool io;
3113   bool ia;
3114 } _Hbase_mutateRow_presult__isset;
3115
3116 class Hbase_mutateRow_presult {
3117  public:
3118
3119
3120   virtual ~Hbase_mutateRow_presult() throw() {}
3121
3122   IOError io;
3123   IllegalArgument ia;
3124
3125   _Hbase_mutateRow_presult__isset __isset;
3126
3127   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3128
3129 };
3130
3131 typedef struct _Hbase_mutateRowTs_args__isset {
3132   _Hbase_mutateRowTs_args__isset() : tableName(false), row(false), mutations(false), timestamp(false), attributes(false) {}
3133   bool tableName;
3134   bool row;
3135   bool mutations;
3136   bool timestamp;
3137   bool attributes;
3138 } _Hbase_mutateRowTs_args__isset;
3139
3140 class Hbase_mutateRowTs_args {
3141  public:
3142
3143   Hbase_mutateRowTs_args() : tableName(), row(), timestamp(0) {
3144   }
3145
3146   virtual ~Hbase_mutateRowTs_args() throw() {}
3147
3148   Text tableName;
3149   Text row;
3150   std::vector<Mutation>  mutations;
3151   int64_t timestamp;
3152   std::map<Text, Text>  attributes;
3153
3154   _Hbase_mutateRowTs_args__isset __isset;
3155
3156   void __set_tableName(const Text& val) {
3157     tableName = val;
3158   }
3159
3160   void __set_row(const Text& val) {
3161     row = val;
3162   }
3163
3164   void __set_mutations(const std::vector<Mutation> & val) {
3165     mutations = val;
3166   }
3167
3168   void __set_timestamp(const int64_t val) {
3169     timestamp = val;
3170   }
3171
3172   void __set_attributes(const std::map<Text, Text> & val) {
3173     attributes = val;
3174   }
3175
3176   bool operator == (const Hbase_mutateRowTs_args & rhs) const
3177   {
3178     if (!(tableName == rhs.tableName))
3179       return false;
3180     if (!(row == rhs.row))
3181       return false;
3182     if (!(mutations == rhs.mutations))
3183       return false;
3184     if (!(timestamp == rhs.timestamp))
3185       return false;
3186     if (!(attributes == rhs.attributes))
3187       return false;
3188     return true;
3189   }
3190   bool operator != (const Hbase_mutateRowTs_args &rhs) const {
3191     return !(*this == rhs);
3192   }
3193
3194   bool operator < (const Hbase_mutateRowTs_args & ) const;
3195
3196   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3197   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3198
3199 };
3200
3201
3202 class Hbase_mutateRowTs_pargs {
3203  public:
3204
3205
3206   virtual ~Hbase_mutateRowTs_pargs() throw() {}
3207
3208   const Text* tableName;
3209   const Text* row;
3210   const std::vector<Mutation> * mutations;
3211   const int64_t* timestamp;
3212   const std::map<Text, Text> * attributes;
3213
3214   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3215
3216 };
3217
3218 typedef struct _Hbase_mutateRowTs_result__isset {
3219   _Hbase_mutateRowTs_result__isset() : io(false), ia(false) {}
3220   bool io;
3221   bool ia;
3222 } _Hbase_mutateRowTs_result__isset;
3223
3224 class Hbase_mutateRowTs_result {
3225  public:
3226
3227   Hbase_mutateRowTs_result() {
3228   }
3229
3230   virtual ~Hbase_mutateRowTs_result() throw() {}
3231
3232   IOError io;
3233   IllegalArgument ia;
3234
3235   _Hbase_mutateRowTs_result__isset __isset;
3236
3237   void __set_io(const IOError& val) {
3238     io = val;
3239   }
3240
3241   void __set_ia(const IllegalArgument& val) {
3242     ia = val;
3243   }
3244
3245   bool operator == (const Hbase_mutateRowTs_result & rhs) const
3246   {
3247     if (!(io == rhs.io))
3248       return false;
3249     if (!(ia == rhs.ia))
3250       return false;
3251     return true;
3252   }
3253   bool operator != (const Hbase_mutateRowTs_result &rhs) const {
3254     return !(*this == rhs);
3255   }
3256
3257   bool operator < (const Hbase_mutateRowTs_result & ) const;
3258
3259   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3260   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3261
3262 };
3263
3264 typedef struct _Hbase_mutateRowTs_presult__isset {
3265   _Hbase_mutateRowTs_presult__isset() : io(false), ia(false) {}
3266   bool io;
3267   bool ia;
3268 } _Hbase_mutateRowTs_presult__isset;
3269
3270 class Hbase_mutateRowTs_presult {
3271  public:
3272
3273
3274   virtual ~Hbase_mutateRowTs_presult() throw() {}
3275
3276   IOError io;
3277   IllegalArgument ia;
3278
3279   _Hbase_mutateRowTs_presult__isset __isset;
3280
3281   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3282
3283 };
3284
3285 typedef struct _Hbase_mutateRows_args__isset {
3286   _Hbase_mutateRows_args__isset() : tableName(false), rowBatches(false), attributes(false) {}
3287   bool tableName;
3288   bool rowBatches;
3289   bool attributes;
3290 } _Hbase_mutateRows_args__isset;
3291
3292 class Hbase_mutateRows_args {
3293  public:
3294
3295   Hbase_mutateRows_args() : tableName() {
3296   }
3297
3298   virtual ~Hbase_mutateRows_args() throw() {}
3299
3300   Text tableName;
3301   std::vector<BatchMutation>  rowBatches;
3302   std::map<Text, Text>  attributes;
3303
3304   _Hbase_mutateRows_args__isset __isset;
3305
3306   void __set_tableName(const Text& val) {
3307     tableName = val;
3308   }
3309
3310   void __set_rowBatches(const std::vector<BatchMutation> & val) {
3311     rowBatches = val;
3312   }
3313
3314   void __set_attributes(const std::map<Text, Text> & val) {
3315     attributes = val;
3316   }
3317
3318   bool operator == (const Hbase_mutateRows_args & rhs) const
3319   {
3320     if (!(tableName == rhs.tableName))
3321       return false;
3322     if (!(rowBatches == rhs.rowBatches))
3323       return false;
3324     if (!(attributes == rhs.attributes))
3325       return false;
3326     return true;
3327   }
3328   bool operator != (const Hbase_mutateRows_args &rhs) const {
3329     return !(*this == rhs);
3330   }
3331
3332   bool operator < (const Hbase_mutateRows_args & ) const;
3333
3334   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3335   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3336
3337 };
3338
3339
3340 class Hbase_mutateRows_pargs {
3341  public:
3342
3343
3344   virtual ~Hbase_mutateRows_pargs() throw() {}
3345
3346   const Text* tableName;
3347   const std::vector<BatchMutation> * rowBatches;
3348   const std::map<Text, Text> * attributes;
3349
3350   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3351
3352 };
3353
3354 typedef struct _Hbase_mutateRows_result__isset {
3355   _Hbase_mutateRows_result__isset() : io(false), ia(false) {}
3356   bool io;
3357   bool ia;
3358 } _Hbase_mutateRows_result__isset;
3359
3360 class Hbase_mutateRows_result {
3361  public:
3362
3363   Hbase_mutateRows_result() {
3364   }
3365
3366   virtual ~Hbase_mutateRows_result() throw() {}
3367
3368   IOError io;
3369   IllegalArgument ia;
3370
3371   _Hbase_mutateRows_result__isset __isset;
3372
3373   void __set_io(const IOError& val) {
3374     io = val;
3375   }
3376
3377   void __set_ia(const IllegalArgument& val) {
3378     ia = val;
3379   }
3380
3381   bool operator == (const Hbase_mutateRows_result & rhs) const
3382   {
3383     if (!(io == rhs.io))
3384       return false;
3385     if (!(ia == rhs.ia))
3386       return false;
3387     return true;
3388   }
3389   bool operator != (const Hbase_mutateRows_result &rhs) const {
3390     return !(*this == rhs);
3391   }
3392
3393   bool operator < (const Hbase_mutateRows_result & ) const;
3394
3395   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3396   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3397
3398 };
3399
3400 typedef struct _Hbase_mutateRows_presult__isset {
3401   _Hbase_mutateRows_presult__isset() : io(false), ia(false) {}
3402   bool io;
3403   bool ia;
3404 } _Hbase_mutateRows_presult__isset;
3405
3406 class Hbase_mutateRows_presult {
3407  public:
3408
3409
3410   virtual ~Hbase_mutateRows_presult() throw() {}
3411
3412   IOError io;
3413   IllegalArgument ia;
3414
3415   _Hbase_mutateRows_presult__isset __isset;
3416
3417   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3418
3419 };
3420
3421 typedef struct _Hbase_mutateRowsTs_args__isset {
3422   _Hbase_mutateRowsTs_args__isset() : tableName(false), rowBatches(false), timestamp(false), attributes(false) {}
3423   bool tableName;
3424   bool rowBatches;
3425   bool timestamp;
3426   bool attributes;
3427 } _Hbase_mutateRowsTs_args__isset;
3428
3429 class Hbase_mutateRowsTs_args {
3430  public:
3431
3432   Hbase_mutateRowsTs_args() : tableName(), timestamp(0) {
3433   }
3434
3435   virtual ~Hbase_mutateRowsTs_args() throw() {}
3436
3437   Text tableName;
3438   std::vector<BatchMutation>  rowBatches;
3439   int64_t timestamp;
3440   std::map<Text, Text>  attributes;
3441
3442   _Hbase_mutateRowsTs_args__isset __isset;
3443
3444   void __set_tableName(const Text& val) {
3445     tableName = val;
3446   }
3447
3448   void __set_rowBatches(const std::vector<BatchMutation> & val) {
3449     rowBatches = val;
3450   }
3451
3452   void __set_timestamp(const int64_t val) {
3453     timestamp = val;
3454   }
3455
3456   void __set_attributes(const std::map<Text, Text> & val) {
3457     attributes = val;
3458   }
3459
3460   bool operator == (const Hbase_mutateRowsTs_args & rhs) const
3461   {
3462     if (!(tableName == rhs.tableName))
3463       return false;
3464     if (!(rowBatches == rhs.rowBatches))
3465       return false;
3466     if (!(timestamp == rhs.timestamp))
3467       return false;
3468     if (!(attributes == rhs.attributes))
3469       return false;
3470     return true;
3471   }
3472   bool operator != (const Hbase_mutateRowsTs_args &rhs) const {
3473     return !(*this == rhs);
3474   }
3475
3476   bool operator < (const Hbase_mutateRowsTs_args & ) const;
3477
3478   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3479   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3480
3481 };
3482
3483
3484 class Hbase_mutateRowsTs_pargs {
3485  public:
3486
3487
3488   virtual ~Hbase_mutateRowsTs_pargs() throw() {}
3489
3490   const Text* tableName;
3491   const std::vector<BatchMutation> * rowBatches;
3492   const int64_t* timestamp;
3493   const std::map<Text, Text> * attributes;
3494
3495   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3496
3497 };
3498
3499 typedef struct _Hbase_mutateRowsTs_result__isset {
3500   _Hbase_mutateRowsTs_result__isset() : io(false), ia(false) {}
3501   bool io;
3502   bool ia;
3503 } _Hbase_mutateRowsTs_result__isset;
3504
3505 class Hbase_mutateRowsTs_result {
3506  public:
3507
3508   Hbase_mutateRowsTs_result() {
3509   }
3510
3511   virtual ~Hbase_mutateRowsTs_result() throw() {}
3512
3513   IOError io;
3514   IllegalArgument ia;
3515
3516   _Hbase_mutateRowsTs_result__isset __isset;
3517
3518   void __set_io(const IOError& val) {
3519     io = val;
3520   }
3521
3522   void __set_ia(const IllegalArgument& val) {
3523     ia = val;
3524   }
3525
3526   bool operator == (const Hbase_mutateRowsTs_result & rhs) const
3527   {
3528     if (!(io == rhs.io))
3529       return false;
3530     if (!(ia == rhs.ia))
3531       return false;
3532     return true;
3533   }
3534   bool operator != (const Hbase_mutateRowsTs_result &rhs) const {
3535     return !(*this == rhs);
3536   }
3537
3538   bool operator < (const Hbase_mutateRowsTs_result & ) const;
3539
3540   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3541   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3542
3543 };
3544
3545 typedef struct _Hbase_mutateRowsTs_presult__isset {
3546   _Hbase_mutateRowsTs_presult__isset() : io(false), ia(false) {}
3547   bool io;
3548   bool ia;
3549 } _Hbase_mutateRowsTs_presult__isset;
3550
3551 class Hbase_mutateRowsTs_presult {
3552  public:
3553
3554
3555   virtual ~Hbase_mutateRowsTs_presult() throw() {}
3556
3557   IOError io;
3558   IllegalArgument ia;
3559
3560   _Hbase_mutateRowsTs_presult__isset __isset;
3561
3562   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3563
3564 };
3565
3566 typedef struct _Hbase_atomicIncrement_args__isset {
3567   _Hbase_atomicIncrement_args__isset() : tableName(false), row(false), column(false), value(false) {}
3568   bool tableName;
3569   bool row;
3570   bool column;
3571   bool value;
3572 } _Hbase_atomicIncrement_args__isset;
3573
3574 class Hbase_atomicIncrement_args {
3575  public:
3576
3577   Hbase_atomicIncrement_args() : tableName(), row(), column(), value(0) {
3578   }
3579
3580   virtual ~Hbase_atomicIncrement_args() throw() {}
3581
3582   Text tableName;
3583   Text row;
3584   Text column;
3585   int64_t value;
3586
3587   _Hbase_atomicIncrement_args__isset __isset;
3588
3589   void __set_tableName(const Text& val) {
3590     tableName = val;
3591   }
3592
3593   void __set_row(const Text& val) {
3594     row = val;
3595   }
3596
3597   void __set_column(const Text& val) {
3598     column = val;
3599   }
3600
3601   void __set_value(const int64_t val) {
3602     value = val;
3603   }
3604
3605   bool operator == (const Hbase_atomicIncrement_args & rhs) const
3606   {
3607     if (!(tableName == rhs.tableName))
3608       return false;
3609     if (!(row == rhs.row))
3610       return false;
3611     if (!(column == rhs.column))
3612       return false;
3613     if (!(value == rhs.value))
3614       return false;
3615     return true;
3616   }
3617   bool operator != (const Hbase_atomicIncrement_args &rhs) const {
3618     return !(*this == rhs);
3619   }
3620
3621   bool operator < (const Hbase_atomicIncrement_args & ) const;
3622
3623   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3624   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3625
3626 };
3627
3628
3629 class Hbase_atomicIncrement_pargs {
3630  public:
3631
3632
3633   virtual ~Hbase_atomicIncrement_pargs() throw() {}
3634
3635   const Text* tableName;
3636   const Text* row;
3637   const Text* column;
3638   const int64_t* value;
3639
3640   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3641
3642 };
3643
3644 typedef struct _Hbase_atomicIncrement_result__isset {
3645   _Hbase_atomicIncrement_result__isset() : success(false), io(false), ia(false) {}
3646   bool success;
3647   bool io;
3648   bool ia;
3649 } _Hbase_atomicIncrement_result__isset;
3650
3651 class Hbase_atomicIncrement_result {
3652  public:
3653
3654   Hbase_atomicIncrement_result() : success(0) {
3655   }
3656
3657   virtual ~Hbase_atomicIncrement_result() throw() {}
3658
3659   int64_t success;
3660   IOError io;
3661   IllegalArgument ia;
3662
3663   _Hbase_atomicIncrement_result__isset __isset;
3664
3665   void __set_success(const int64_t val) {
3666     success = val;
3667   }
3668
3669   void __set_io(const IOError& val) {
3670     io = val;
3671   }
3672
3673   void __set_ia(const IllegalArgument& val) {
3674     ia = val;
3675   }
3676
3677   bool operator == (const Hbase_atomicIncrement_result & rhs) const
3678   {
3679     if (!(success == rhs.success))
3680       return false;
3681     if (!(io == rhs.io))
3682       return false;
3683     if (!(ia == rhs.ia))
3684       return false;
3685     return true;
3686   }
3687   bool operator != (const Hbase_atomicIncrement_result &rhs) const {
3688     return !(*this == rhs);
3689   }
3690
3691   bool operator < (const Hbase_atomicIncrement_result & ) const;
3692
3693   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3694   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3695
3696 };
3697
3698 typedef struct _Hbase_atomicIncrement_presult__isset {
3699   _Hbase_atomicIncrement_presult__isset() : success(false), io(false), ia(false) {}
3700   bool success;
3701   bool io;
3702   bool ia;
3703 } _Hbase_atomicIncrement_presult__isset;
3704
3705 class Hbase_atomicIncrement_presult {
3706  public:
3707
3708
3709   virtual ~Hbase_atomicIncrement_presult() throw() {}
3710
3711   int64_t* success;
3712   IOError io;
3713   IllegalArgument ia;
3714
3715   _Hbase_atomicIncrement_presult__isset __isset;
3716
3717   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3718
3719 };
3720
3721 typedef struct _Hbase_deleteAll_args__isset {
3722   _Hbase_deleteAll_args__isset() : tableName(false), row(false), column(false), attributes(false) {}
3723   bool tableName;
3724   bool row;
3725   bool column;
3726   bool attributes;
3727 } _Hbase_deleteAll_args__isset;
3728
3729 class Hbase_deleteAll_args {
3730  public:
3731
3732   Hbase_deleteAll_args() : tableName(), row(), column() {
3733   }
3734
3735   virtual ~Hbase_deleteAll_args() throw() {}
3736
3737   Text tableName;
3738   Text row;
3739   Text column;
3740   std::map<Text, Text>  attributes;
3741
3742   _Hbase_deleteAll_args__isset __isset;
3743
3744   void __set_tableName(const Text& val) {
3745     tableName = val;
3746   }
3747
3748   void __set_row(const Text& val) {
3749     row = val;
3750   }
3751
3752   void __set_column(const Text& val) {
3753     column = val;
3754   }
3755
3756   void __set_attributes(const std::map<Text, Text> & val) {
3757     attributes = val;
3758   }
3759
3760   bool operator == (const Hbase_deleteAll_args & rhs) const
3761   {
3762     if (!(tableName == rhs.tableName))
3763       return false;
3764     if (!(row == rhs.row))
3765       return false;
3766     if (!(column == rhs.column))
3767       return false;
3768     if (!(attributes == rhs.attributes))
3769       return false;
3770     return true;
3771   }
3772   bool operator != (const Hbase_deleteAll_args &rhs) const {
3773     return !(*this == rhs);
3774   }
3775
3776   bool operator < (const Hbase_deleteAll_args & ) const;
3777
3778   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3779   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3780
3781 };
3782
3783
3784 class Hbase_deleteAll_pargs {
3785  public:
3786
3787
3788   virtual ~Hbase_deleteAll_pargs() throw() {}
3789
3790   const Text* tableName;
3791   const Text* row;
3792   const Text* column;
3793   const std::map<Text, Text> * attributes;
3794
3795   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3796
3797 };
3798
3799 typedef struct _Hbase_deleteAll_result__isset {
3800   _Hbase_deleteAll_result__isset() : io(false) {}
3801   bool io;
3802 } _Hbase_deleteAll_result__isset;
3803
3804 class Hbase_deleteAll_result {
3805  public:
3806
3807   Hbase_deleteAll_result() {
3808   }
3809
3810   virtual ~Hbase_deleteAll_result() throw() {}
3811
3812   IOError io;
3813
3814   _Hbase_deleteAll_result__isset __isset;
3815
3816   void __set_io(const IOError& val) {
3817     io = val;
3818   }
3819
3820   bool operator == (const Hbase_deleteAll_result & rhs) const
3821   {
3822     if (!(io == rhs.io))
3823       return false;
3824     return true;
3825   }
3826   bool operator != (const Hbase_deleteAll_result &rhs) const {
3827     return !(*this == rhs);
3828   }
3829
3830   bool operator < (const Hbase_deleteAll_result & ) const;
3831
3832   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3833   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3834
3835 };
3836
3837 typedef struct _Hbase_deleteAll_presult__isset {
3838   _Hbase_deleteAll_presult__isset() : io(false) {}
3839   bool io;
3840 } _Hbase_deleteAll_presult__isset;
3841
3842 class Hbase_deleteAll_presult {
3843  public:
3844
3845
3846   virtual ~Hbase_deleteAll_presult() throw() {}
3847
3848   IOError io;
3849
3850   _Hbase_deleteAll_presult__isset __isset;
3851
3852   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3853
3854 };
3855
3856 typedef struct _Hbase_deleteAllTs_args__isset {
3857   _Hbase_deleteAllTs_args__isset() : tableName(false), row(false), column(false), timestamp(false), attributes(false) {}
3858   bool tableName;
3859   bool row;
3860   bool column;
3861   bool timestamp;
3862   bool attributes;
3863 } _Hbase_deleteAllTs_args__isset;
3864
3865 class Hbase_deleteAllTs_args {
3866  public:
3867
3868   Hbase_deleteAllTs_args() : tableName(), row(), column(), timestamp(0) {
3869   }
3870
3871   virtual ~Hbase_deleteAllTs_args() throw() {}
3872
3873   Text tableName;
3874   Text row;
3875   Text column;
3876   int64_t timestamp;
3877   std::map<Text, Text>  attributes;
3878
3879   _Hbase_deleteAllTs_args__isset __isset;
3880
3881   void __set_tableName(const Text& val) {
3882     tableName = val;
3883   }
3884
3885   void __set_row(const Text& val) {
3886     row = val;
3887   }
3888
3889   void __set_column(const Text& val) {
3890     column = val;
3891   }
3892
3893   void __set_timestamp(const int64_t val) {
3894     timestamp = val;
3895   }
3896
3897   void __set_attributes(const std::map<Text, Text> & val) {
3898     attributes = val;
3899   }
3900
3901   bool operator == (const Hbase_deleteAllTs_args & rhs) const
3902   {
3903     if (!(tableName == rhs.tableName))
3904       return false;
3905     if (!(row == rhs.row))
3906       return false;
3907     if (!(column == rhs.column))
3908       return false;
3909     if (!(timestamp == rhs.timestamp))
3910       return false;
3911     if (!(attributes == rhs.attributes))
3912       return false;
3913     return true;
3914   }
3915   bool operator != (const Hbase_deleteAllTs_args &rhs) const {
3916     return !(*this == rhs);
3917   }
3918
3919   bool operator < (const Hbase_deleteAllTs_args & ) const;
3920
3921   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3922   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3923
3924 };
3925
3926
3927 class Hbase_deleteAllTs_pargs {
3928  public:
3929
3930
3931   virtual ~Hbase_deleteAllTs_pargs() throw() {}
3932
3933   const Text* tableName;
3934   const Text* row;
3935   const Text* column;
3936   const int64_t* timestamp;
3937   const std::map<Text, Text> * attributes;
3938
3939   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3940
3941 };
3942
3943 typedef struct _Hbase_deleteAllTs_result__isset {
3944   _Hbase_deleteAllTs_result__isset() : io(false) {}
3945   bool io;
3946 } _Hbase_deleteAllTs_result__isset;
3947
3948 class Hbase_deleteAllTs_result {
3949  public:
3950
3951   Hbase_deleteAllTs_result() {
3952   }
3953
3954   virtual ~Hbase_deleteAllTs_result() throw() {}
3955
3956   IOError io;
3957
3958   _Hbase_deleteAllTs_result__isset __isset;
3959
3960   void __set_io(const IOError& val) {
3961     io = val;
3962   }
3963
3964   bool operator == (const Hbase_deleteAllTs_result & rhs) const
3965   {
3966     if (!(io == rhs.io))
3967       return false;
3968     return true;
3969   }
3970   bool operator != (const Hbase_deleteAllTs_result &rhs) const {
3971     return !(*this == rhs);
3972   }
3973
3974   bool operator < (const Hbase_deleteAllTs_result & ) const;
3975
3976   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3977   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3978
3979 };
3980
3981 typedef struct _Hbase_deleteAllTs_presult__isset {
3982   _Hbase_deleteAllTs_presult__isset() : io(false) {}
3983   bool io;
3984 } _Hbase_deleteAllTs_presult__isset;
3985
3986 class Hbase_deleteAllTs_presult {
3987  public:
3988
3989
3990   virtual ~Hbase_deleteAllTs_presult() throw() {}
3991
3992   IOError io;
3993
3994   _Hbase_deleteAllTs_presult__isset __isset;
3995
3996   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3997
3998 };
3999
4000 typedef struct _Hbase_deleteAllRow_args__isset {
4001   _Hbase_deleteAllRow_args__isset() : tableName(false), row(false), attributes(false) {}
4002   bool tableName;
4003   bool row;
4004   bool attributes;
4005 } _Hbase_deleteAllRow_args__isset;
4006
4007 class Hbase_deleteAllRow_args {
4008  public:
4009
4010   Hbase_deleteAllRow_args() : tableName(), row() {
4011   }
4012
4013   virtual ~Hbase_deleteAllRow_args() throw() {}
4014
4015   Text tableName;
4016   Text row;
4017   std::map<Text, Text>  attributes;
4018
4019   _Hbase_deleteAllRow_args__isset __isset;
4020
4021   void __set_tableName(const Text& val) {
4022     tableName = val;
4023   }
4024
4025   void __set_row(const Text& val) {
4026     row = val;
4027   }
4028
4029   void __set_attributes(const std::map<Text, Text> & val) {
4030     attributes = val;
4031   }
4032
4033   bool operator == (const Hbase_deleteAllRow_args & rhs) const
4034   {
4035     if (!(tableName == rhs.tableName))
4036       return false;
4037     if (!(row == rhs.row))
4038       return false;
4039     if (!(attributes == rhs.attributes))
4040       return false;
4041     return true;
4042   }
4043   bool operator != (const Hbase_deleteAllRow_args &rhs) const {
4044     return !(*this == rhs);
4045   }
4046
4047   bool operator < (const Hbase_deleteAllRow_args & ) const;
4048
4049   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4050   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4051
4052 };
4053
4054
4055 class Hbase_deleteAllRow_pargs {
4056  public:
4057
4058
4059   virtual ~Hbase_deleteAllRow_pargs() throw() {}
4060
4061   const Text* tableName;
4062   const Text* row;
4063   const std::map<Text, Text> * attributes;
4064
4065   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4066
4067 };
4068
4069 typedef struct _Hbase_deleteAllRow_result__isset {
4070   _Hbase_deleteAllRow_result__isset() : io(false) {}
4071   bool io;
4072 } _Hbase_deleteAllRow_result__isset;
4073
4074 class Hbase_deleteAllRow_result {
4075  public:
4076
4077   Hbase_deleteAllRow_result() {
4078   }
4079
4080   virtual ~Hbase_deleteAllRow_result() throw() {}
4081
4082   IOError io;
4083
4084   _Hbase_deleteAllRow_result__isset __isset;
4085
4086   void __set_io(const IOError& val) {
4087     io = val;
4088   }
4089
4090   bool operator == (const Hbase_deleteAllRow_result & rhs) const
4091   {
4092     if (!(io == rhs.io))
4093       return false;
4094     return true;
4095   }
4096   bool operator != (const Hbase_deleteAllRow_result &rhs) const {
4097     return !(*this == rhs);
4098   }
4099
4100   bool operator < (const Hbase_deleteAllRow_result & ) const;
4101
4102   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4103   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4104
4105 };
4106
4107 typedef struct _Hbase_deleteAllRow_presult__isset {
4108   _Hbase_deleteAllRow_presult__isset() : io(false) {}
4109   bool io;
4110 } _Hbase_deleteAllRow_presult__isset;
4111
4112 class Hbase_deleteAllRow_presult {
4113  public:
4114
4115
4116   virtual ~Hbase_deleteAllRow_presult() throw() {}
4117
4118   IOError io;
4119
4120   _Hbase_deleteAllRow_presult__isset __isset;
4121
4122   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4123
4124 };
4125
4126 typedef struct _Hbase_increment_args__isset {
4127   _Hbase_increment_args__isset() : increment(false) {}
4128   bool increment;
4129 } _Hbase_increment_args__isset;
4130
4131 class Hbase_increment_args {
4132  public:
4133
4134   Hbase_increment_args() {
4135   }
4136
4137   virtual ~Hbase_increment_args() throw() {}
4138
4139   TIncrement increment;
4140
4141   _Hbase_increment_args__isset __isset;
4142
4143   void __set_increment(const TIncrement& val) {
4144     increment = val;
4145   }
4146
4147   bool operator == (const Hbase_increment_args & rhs) const
4148   {
4149     if (!(increment == rhs.increment))
4150       return false;
4151     return true;
4152   }
4153   bool operator != (const Hbase_increment_args &rhs) const {
4154     return !(*this == rhs);
4155   }
4156
4157   bool operator < (const Hbase_increment_args & ) const;
4158
4159   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4160   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4161
4162 };
4163
4164
4165 class Hbase_increment_pargs {
4166  public:
4167
4168
4169   virtual ~Hbase_increment_pargs() throw() {}
4170
4171   const TIncrement* increment;
4172
4173   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4174
4175 };
4176
4177 typedef struct _Hbase_increment_result__isset {
4178   _Hbase_increment_result__isset() : io(false) {}
4179   bool io;
4180 } _Hbase_increment_result__isset;
4181
4182 class Hbase_increment_result {
4183  public:
4184
4185   Hbase_increment_result() {
4186   }
4187
4188   virtual ~Hbase_increment_result() throw() {}
4189
4190   IOError io;
4191
4192   _Hbase_increment_result__isset __isset;
4193
4194   void __set_io(const IOError& val) {
4195     io = val;
4196   }
4197
4198   bool operator == (const Hbase_increment_result & rhs) const
4199   {
4200     if (!(io == rhs.io))
4201       return false;
4202     return true;
4203   }
4204   bool operator != (const Hbase_increment_result &rhs) const {
4205     return !(*this == rhs);
4206   }
4207
4208   bool operator < (const Hbase_increment_result & ) const;
4209
4210   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4211   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4212
4213 };
4214
4215 typedef struct _Hbase_increment_presult__isset {
4216   _Hbase_increment_presult__isset() : io(false) {}
4217   bool io;
4218 } _Hbase_increment_presult__isset;
4219
4220 class Hbase_increment_presult {
4221  public:
4222
4223
4224   virtual ~Hbase_increment_presult() throw() {}
4225
4226   IOError io;
4227
4228   _Hbase_increment_presult__isset __isset;
4229
4230   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4231
4232 };
4233
4234 typedef struct _Hbase_incrementRows_args__isset {
4235   _Hbase_incrementRows_args__isset() : increments(false) {}
4236   bool increments;
4237 } _Hbase_incrementRows_args__isset;
4238
4239 class Hbase_incrementRows_args {
4240  public:
4241
4242   Hbase_incrementRows_args() {
4243   }
4244
4245   virtual ~Hbase_incrementRows_args() throw() {}
4246
4247   std::vector<TIncrement>  increments;
4248
4249   _Hbase_incrementRows_args__isset __isset;
4250
4251   void __set_increments(const std::vector<TIncrement> & val) {
4252     increments = val;
4253   }
4254
4255   bool operator == (const Hbase_incrementRows_args & rhs) const
4256   {
4257     if (!(increments == rhs.increments))
4258       return false;
4259     return true;
4260   }
4261   bool operator != (const Hbase_incrementRows_args &rhs) const {
4262     return !(*this == rhs);
4263   }
4264
4265   bool operator < (const Hbase_incrementRows_args & ) const;
4266
4267   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4268   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4269
4270 };
4271
4272
4273 class Hbase_incrementRows_pargs {
4274  public:
4275
4276
4277   virtual ~Hbase_incrementRows_pargs() throw() {}
4278
4279   const std::vector<TIncrement> * increments;
4280
4281   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4282
4283 };
4284
4285 typedef struct _Hbase_incrementRows_result__isset {
4286   _Hbase_incrementRows_result__isset() : io(false) {}
4287   bool io;
4288 } _Hbase_incrementRows_result__isset;
4289
4290 class Hbase_incrementRows_result {
4291  public:
4292
4293   Hbase_incrementRows_result() {
4294   }
4295
4296   virtual ~Hbase_incrementRows_result() throw() {}
4297
4298   IOError io;
4299
4300   _Hbase_incrementRows_result__isset __isset;
4301
4302   void __set_io(const IOError& val) {
4303     io = val;
4304   }
4305
4306   bool operator == (const Hbase_incrementRows_result & rhs) const
4307   {
4308     if (!(io == rhs.io))
4309       return false;
4310     return true;
4311   }
4312   bool operator != (const Hbase_incrementRows_result &rhs) const {
4313     return !(*this == rhs);
4314   }
4315
4316   bool operator < (const Hbase_incrementRows_result & ) const;
4317
4318   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4319   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4320
4321 };
4322
4323 typedef struct _Hbase_incrementRows_presult__isset {
4324   _Hbase_incrementRows_presult__isset() : io(false) {}
4325   bool io;
4326 } _Hbase_incrementRows_presult__isset;
4327
4328 class Hbase_incrementRows_presult {
4329  public:
4330
4331
4332   virtual ~Hbase_incrementRows_presult() throw() {}
4333
4334   IOError io;
4335
4336   _Hbase_incrementRows_presult__isset __isset;
4337
4338   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4339
4340 };
4341
4342 typedef struct _Hbase_deleteAllRowTs_args__isset {
4343   _Hbase_deleteAllRowTs_args__isset() : tableName(false), row(false), timestamp(false), attributes(false) {}
4344   bool tableName;
4345   bool row;
4346   bool timestamp;
4347   bool attributes;
4348 } _Hbase_deleteAllRowTs_args__isset;
4349
4350 class Hbase_deleteAllRowTs_args {
4351  public:
4352
4353   Hbase_deleteAllRowTs_args() : tableName(), row(), timestamp(0) {
4354   }
4355
4356   virtual ~Hbase_deleteAllRowTs_args() throw() {}
4357
4358   Text tableName;
4359   Text row;
4360   int64_t timestamp;
4361   std::map<Text, Text>  attributes;
4362
4363   _Hbase_deleteAllRowTs_args__isset __isset;
4364
4365   void __set_tableName(const Text& val) {
4366     tableName = val;
4367   }
4368
4369   void __set_row(const Text& val) {
4370     row = val;
4371   }
4372
4373   void __set_timestamp(const int64_t val) {
4374     timestamp = val;
4375   }
4376
4377   void __set_attributes(const std::map<Text, Text> & val) {
4378     attributes = val;
4379   }
4380
4381   bool operator == (const Hbase_deleteAllRowTs_args & rhs) const
4382   {
4383     if (!(tableName == rhs.tableName))
4384       return false;
4385     if (!(row == rhs.row))
4386       return false;
4387     if (!(timestamp == rhs.timestamp))
4388       return false;
4389     if (!(attributes == rhs.attributes))
4390       return false;
4391     return true;
4392   }
4393   bool operator != (const Hbase_deleteAllRowTs_args &rhs) const {
4394     return !(*this == rhs);
4395   }
4396
4397   bool operator < (const Hbase_deleteAllRowTs_args & ) const;
4398
4399   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4400   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4401
4402 };
4403
4404
4405 class Hbase_deleteAllRowTs_pargs {
4406  public:
4407
4408
4409   virtual ~Hbase_deleteAllRowTs_pargs() throw() {}
4410
4411   const Text* tableName;
4412   const Text* row;
4413   const int64_t* timestamp;
4414   const std::map<Text, Text> * attributes;
4415
4416   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4417
4418 };
4419
4420 typedef struct _Hbase_deleteAllRowTs_result__isset {
4421   _Hbase_deleteAllRowTs_result__isset() : io(false) {}
4422   bool io;
4423 } _Hbase_deleteAllRowTs_result__isset;
4424
4425 class Hbase_deleteAllRowTs_result {
4426  public:
4427
4428   Hbase_deleteAllRowTs_result() {
4429   }
4430
4431   virtual ~Hbase_deleteAllRowTs_result() throw() {}
4432
4433   IOError io;
4434
4435   _Hbase_deleteAllRowTs_result__isset __isset;
4436
4437   void __set_io(const IOError& val) {
4438     io = val;
4439   }
4440
4441   bool operator == (const Hbase_deleteAllRowTs_result & rhs) const
4442   {
4443     if (!(io == rhs.io))
4444       return false;
4445     return true;
4446   }
4447   bool operator != (const Hbase_deleteAllRowTs_result &rhs) const {
4448     return !(*this == rhs);
4449   }
4450
4451   bool operator < (const Hbase_deleteAllRowTs_result & ) const;
4452
4453   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4454   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4455
4456 };
4457
4458 typedef struct _Hbase_deleteAllRowTs_presult__isset {
4459   _Hbase_deleteAllRowTs_presult__isset() : io(false) {}
4460   bool io;
4461 } _Hbase_deleteAllRowTs_presult__isset;
4462
4463 class Hbase_deleteAllRowTs_presult {
4464  public:
4465
4466
4467   virtual ~Hbase_deleteAllRowTs_presult() throw() {}
4468
4469   IOError io;
4470
4471   _Hbase_deleteAllRowTs_presult__isset __isset;
4472
4473   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4474
4475 };
4476
4477 typedef struct _Hbase_scannerOpenWithScan_args__isset {
4478   _Hbase_scannerOpenWithScan_args__isset() : tableName(false), scan(false), attributes(false) {}
4479   bool tableName;
4480   bool scan;
4481   bool attributes;
4482 } _Hbase_scannerOpenWithScan_args__isset;
4483
4484 class Hbase_scannerOpenWithScan_args {
4485  public:
4486
4487   Hbase_scannerOpenWithScan_args() : tableName() {
4488   }
4489
4490   virtual ~Hbase_scannerOpenWithScan_args() throw() {}
4491
4492   Text tableName;
4493   TScan scan;
4494   std::map<Text, Text>  attributes;
4495
4496   _Hbase_scannerOpenWithScan_args__isset __isset;
4497
4498   void __set_tableName(const Text& val) {
4499     tableName = val;
4500   }
4501
4502   void __set_scan(const TScan& val) {
4503     scan = val;
4504   }
4505
4506   void __set_attributes(const std::map<Text, Text> & val) {
4507     attributes = val;
4508   }
4509
4510   bool operator == (const Hbase_scannerOpenWithScan_args & rhs) const
4511   {
4512     if (!(tableName == rhs.tableName))
4513       return false;
4514     if (!(scan == rhs.scan))
4515       return false;
4516     if (!(attributes == rhs.attributes))
4517       return false;
4518     return true;
4519   }
4520   bool operator != (const Hbase_scannerOpenWithScan_args &rhs) const {
4521     return !(*this == rhs);
4522   }
4523
4524   bool operator < (const Hbase_scannerOpenWithScan_args & ) const;
4525
4526   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4527   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4528
4529 };
4530
4531
4532 class Hbase_scannerOpenWithScan_pargs {
4533  public:
4534
4535
4536   virtual ~Hbase_scannerOpenWithScan_pargs() throw() {}
4537
4538   const Text* tableName;
4539   const TScan* scan;
4540   const std::map<Text, Text> * attributes;
4541
4542   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4543
4544 };
4545
4546 typedef struct _Hbase_scannerOpenWithScan_result__isset {
4547   _Hbase_scannerOpenWithScan_result__isset() : success(false), io(false) {}
4548   bool success;
4549   bool io;
4550 } _Hbase_scannerOpenWithScan_result__isset;
4551
4552 class Hbase_scannerOpenWithScan_result {
4553  public:
4554
4555   Hbase_scannerOpenWithScan_result() : success(0) {
4556   }
4557
4558   virtual ~Hbase_scannerOpenWithScan_result() throw() {}
4559
4560   ScannerID success;
4561   IOError io;
4562
4563   _Hbase_scannerOpenWithScan_result__isset __isset;
4564
4565   void __set_success(const ScannerID val) {
4566     success = val;
4567   }
4568
4569   void __set_io(const IOError& val) {
4570     io = val;
4571   }
4572
4573   bool operator == (const Hbase_scannerOpenWithScan_result & rhs) const
4574   {
4575     if (!(success == rhs.success))
4576       return false;
4577     if (!(io == rhs.io))
4578       return false;
4579     return true;
4580   }
4581   bool operator != (const Hbase_scannerOpenWithScan_result &rhs) const {
4582     return !(*this == rhs);
4583   }
4584
4585   bool operator < (const Hbase_scannerOpenWithScan_result & ) const;
4586
4587   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4588   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4589
4590 };
4591
4592 typedef struct _Hbase_scannerOpenWithScan_presult__isset {
4593   _Hbase_scannerOpenWithScan_presult__isset() : success(false), io(false) {}
4594   bool success;
4595   bool io;
4596 } _Hbase_scannerOpenWithScan_presult__isset;
4597
4598 class Hbase_scannerOpenWithScan_presult {
4599  public:
4600
4601
4602   virtual ~Hbase_scannerOpenWithScan_presult() throw() {}
4603
4604   ScannerID* success;
4605   IOError io;
4606
4607   _Hbase_scannerOpenWithScan_presult__isset __isset;
4608
4609   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4610
4611 };
4612
4613 typedef struct _Hbase_scannerOpen_args__isset {
4614   _Hbase_scannerOpen_args__isset() : tableName(false), startRow(false), columns(false), attributes(false) {}
4615   bool tableName;
4616   bool startRow;
4617   bool columns;
4618   bool attributes;
4619 } _Hbase_scannerOpen_args__isset;
4620
4621 class Hbase_scannerOpen_args {
4622  public:
4623
4624   Hbase_scannerOpen_args() : tableName(), startRow() {
4625   }
4626
4627   virtual ~Hbase_scannerOpen_args() throw() {}
4628
4629   Text tableName;
4630   Text startRow;
4631   std::vector<Text>  columns;
4632   std::map<Text, Text>  attributes;
4633
4634   _Hbase_scannerOpen_args__isset __isset;
4635
4636   void __set_tableName(const Text& val) {
4637     tableName = val;
4638   }
4639
4640   void __set_startRow(const Text& val) {
4641     startRow = val;
4642   }
4643
4644   void __set_columns(const std::vector<Text> & val) {
4645     columns = val;
4646   }
4647
4648   void __set_attributes(const std::map<Text, Text> & val) {
4649     attributes = val;
4650   }
4651
4652   bool operator == (const Hbase_scannerOpen_args & rhs) const
4653   {
4654     if (!(tableName == rhs.tableName))
4655       return false;
4656     if (!(startRow == rhs.startRow))
4657       return false;
4658     if (!(columns == rhs.columns))
4659       return false;
4660     if (!(attributes == rhs.attributes))
4661       return false;
4662     return true;
4663   }
4664   bool operator != (const Hbase_scannerOpen_args &rhs) const {
4665     return !(*this == rhs);
4666   }
4667
4668   bool operator < (const Hbase_scannerOpen_args & ) const;
4669
4670   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4671   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4672
4673 };
4674
4675
4676 class Hbase_scannerOpen_pargs {
4677  public:
4678
4679
4680   virtual ~Hbase_scannerOpen_pargs() throw() {}
4681
4682   const Text* tableName;
4683   const Text* startRow;
4684   const std::vector<Text> * columns;
4685   const std::map<Text, Text> * attributes;
4686
4687   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4688
4689 };
4690
4691 typedef struct _Hbase_scannerOpen_result__isset {
4692   _Hbase_scannerOpen_result__isset() : success(false), io(false) {}
4693   bool success;
4694   bool io;
4695 } _Hbase_scannerOpen_result__isset;
4696
4697 class Hbase_scannerOpen_result {
4698  public:
4699
4700   Hbase_scannerOpen_result() : success(0) {
4701   }
4702
4703   virtual ~Hbase_scannerOpen_result() throw() {}
4704
4705   ScannerID success;
4706   IOError io;
4707
4708   _Hbase_scannerOpen_result__isset __isset;
4709
4710   void __set_success(const ScannerID val) {
4711     success = val;
4712   }
4713
4714   void __set_io(const IOError& val) {
4715     io = val;
4716   }
4717
4718   bool operator == (const Hbase_scannerOpen_result & rhs) const
4719   {
4720     if (!(success == rhs.success))
4721       return false;
4722     if (!(io == rhs.io))
4723       return false;
4724     return true;
4725   }
4726   bool operator != (const Hbase_scannerOpen_result &rhs) const {
4727     return !(*this == rhs);
4728   }
4729
4730   bool operator < (const Hbase_scannerOpen_result & ) const;
4731
4732   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4733   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4734
4735 };
4736
4737 typedef struct _Hbase_scannerOpen_presult__isset {
4738   _Hbase_scannerOpen_presult__isset() : success(false), io(false) {}
4739   bool success;
4740   bool io;
4741 } _Hbase_scannerOpen_presult__isset;
4742
4743 class Hbase_scannerOpen_presult {
4744  public:
4745
4746
4747   virtual ~Hbase_scannerOpen_presult() throw() {}
4748
4749   ScannerID* success;
4750   IOError io;
4751
4752   _Hbase_scannerOpen_presult__isset __isset;
4753
4754   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4755
4756 };
4757
4758 typedef struct _Hbase_scannerOpenWithStop_args__isset {
4759   _Hbase_scannerOpenWithStop_args__isset() : tableName(false), startRow(false), stopRow(false), columns(false), attributes(false) {}
4760   bool tableName;
4761   bool startRow;
4762   bool stopRow;
4763   bool columns;
4764   bool attributes;
4765 } _Hbase_scannerOpenWithStop_args__isset;
4766
4767 class Hbase_scannerOpenWithStop_args {
4768  public:
4769
4770   Hbase_scannerOpenWithStop_args() : tableName(), startRow(), stopRow() {
4771   }
4772
4773   virtual ~Hbase_scannerOpenWithStop_args() throw() {}
4774
4775   Text tableName;
4776   Text startRow;
4777   Text stopRow;
4778   std::vector<Text>  columns;
4779   std::map<Text, Text>  attributes;
4780
4781   _Hbase_scannerOpenWithStop_args__isset __isset;
4782
4783   void __set_tableName(const Text& val) {
4784     tableName = val;
4785   }
4786
4787   void __set_startRow(const Text& val) {
4788     startRow = val;
4789   }
4790
4791   void __set_stopRow(const Text& val) {
4792     stopRow = val;
4793   }
4794
4795   void __set_columns(const std::vector<Text> & val) {
4796     columns = val;
4797   }
4798
4799   void __set_attributes(const std::map<Text, Text> & val) {
4800     attributes = val;
4801   }
4802
4803   bool operator == (const Hbase_scannerOpenWithStop_args & rhs) const
4804   {
4805     if (!(tableName == rhs.tableName))
4806       return false;
4807     if (!(startRow == rhs.startRow))
4808       return false;
4809     if (!(stopRow == rhs.stopRow))
4810       return false;
4811     if (!(columns == rhs.columns))
4812       return false;
4813     if (!(attributes == rhs.attributes))
4814       return false;
4815     return true;
4816   }
4817   bool operator != (const Hbase_scannerOpenWithStop_args &rhs) const {
4818     return !(*this == rhs);
4819   }
4820
4821   bool operator < (const Hbase_scannerOpenWithStop_args & ) const;
4822
4823   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4824   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4825
4826 };
4827
4828
4829 class Hbase_scannerOpenWithStop_pargs {
4830  public:
4831
4832
4833   virtual ~Hbase_scannerOpenWithStop_pargs() throw() {}
4834
4835   const Text* tableName;
4836   const Text* startRow;
4837   const Text* stopRow;
4838   const std::vector<Text> * columns;
4839   const std::map<Text, Text> * attributes;
4840
4841   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4842
4843 };
4844
4845 typedef struct _Hbase_scannerOpenWithStop_result__isset {
4846   _Hbase_scannerOpenWithStop_result__isset() : success(false), io(false) {}
4847   bool success;
4848   bool io;
4849 } _Hbase_scannerOpenWithStop_result__isset;
4850
4851 class Hbase_scannerOpenWithStop_result {
4852  public:
4853
4854   Hbase_scannerOpenWithStop_result() : success(0) {
4855   }
4856
4857   virtual ~Hbase_scannerOpenWithStop_result() throw() {}
4858
4859   ScannerID success;
4860   IOError io;
4861
4862   _Hbase_scannerOpenWithStop_result__isset __isset;
4863
4864   void __set_success(const ScannerID val) {
4865     success = val;
4866   }
4867
4868   void __set_io(const IOError& val) {
4869     io = val;
4870   }
4871
4872   bool operator == (const Hbase_scannerOpenWithStop_result & rhs) const
4873   {
4874     if (!(success == rhs.success))
4875       return false;
4876     if (!(io == rhs.io))
4877       return false;
4878     return true;
4879   }
4880   bool operator != (const Hbase_scannerOpenWithStop_result &rhs) const {
4881     return !(*this == rhs);
4882   }
4883
4884   bool operator < (const Hbase_scannerOpenWithStop_result & ) const;
4885
4886   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4887   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4888
4889 };
4890
4891 typedef struct _Hbase_scannerOpenWithStop_presult__isset {
4892   _Hbase_scannerOpenWithStop_presult__isset() : success(false), io(false) {}
4893   bool success;
4894   bool io;
4895 } _Hbase_scannerOpenWithStop_presult__isset;
4896
4897 class Hbase_scannerOpenWithStop_presult {
4898  public:
4899
4900
4901   virtual ~Hbase_scannerOpenWithStop_presult() throw() {}
4902
4903   ScannerID* success;
4904   IOError io;
4905
4906   _Hbase_scannerOpenWithStop_presult__isset __isset;
4907
4908   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4909
4910 };
4911
4912 typedef struct _Hbase_scannerOpenWithPrefix_args__isset {
4913   _Hbase_scannerOpenWithPrefix_args__isset() : tableName(false), startAndPrefix(false), columns(false), attributes(false) {}
4914   bool tableName;
4915   bool startAndPrefix;
4916   bool columns;
4917   bool attributes;
4918 } _Hbase_scannerOpenWithPrefix_args__isset;
4919
4920 class Hbase_scannerOpenWithPrefix_args {
4921  public:
4922
4923   Hbase_scannerOpenWithPrefix_args() : tableName(), startAndPrefix() {
4924   }
4925
4926   virtual ~Hbase_scannerOpenWithPrefix_args() throw() {}
4927
4928   Text tableName;
4929   Text startAndPrefix;
4930   std::vector<Text>  columns;
4931   std::map<Text, Text>  attributes;
4932
4933   _Hbase_scannerOpenWithPrefix_args__isset __isset;
4934
4935   void __set_tableName(const Text& val) {
4936     tableName = val;
4937   }
4938
4939   void __set_startAndPrefix(const Text& val) {
4940     startAndPrefix = val;
4941   }
4942
4943   void __set_columns(const std::vector<Text> & val) {
4944     columns = val;
4945   }
4946
4947   void __set_attributes(const std::map<Text, Text> & val) {
4948     attributes = val;
4949   }
4950
4951   bool operator == (const Hbase_scannerOpenWithPrefix_args & rhs) const
4952   {
4953     if (!(tableName == rhs.tableName))
4954       return false;
4955     if (!(startAndPrefix == rhs.startAndPrefix))
4956       return false;
4957     if (!(columns == rhs.columns))
4958       return false;
4959     if (!(attributes == rhs.attributes))
4960       return false;
4961     return true;
4962   }
4963   bool operator != (const Hbase_scannerOpenWithPrefix_args &rhs) const {
4964     return !(*this == rhs);
4965   }
4966
4967   bool operator < (const Hbase_scannerOpenWithPrefix_args & ) const;
4968
4969   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4970   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4971
4972 };
4973
4974
4975 class Hbase_scannerOpenWithPrefix_pargs {
4976  public:
4977
4978
4979   virtual ~Hbase_scannerOpenWithPrefix_pargs() throw() {}
4980
4981   const Text* tableName;
4982   const Text* startAndPrefix;
4983   const std::vector<Text> * columns;
4984   const std::map<Text, Text> * attributes;
4985
4986   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4987
4988 };
4989
4990 typedef struct _Hbase_scannerOpenWithPrefix_result__isset {
4991   _Hbase_scannerOpenWithPrefix_result__isset() : success(false), io(false) {}
4992   bool success;
4993   bool io;
4994 } _Hbase_scannerOpenWithPrefix_result__isset;
4995
4996 class Hbase_scannerOpenWithPrefix_result {
4997  public:
4998
4999   Hbase_scannerOpenWithPrefix_result() : success(0) {
5000   }
5001
5002   virtual ~Hbase_scannerOpenWithPrefix_result() throw() {}
5003
5004   ScannerID success;
5005   IOError io;
5006
5007   _Hbase_scannerOpenWithPrefix_result__isset __isset;
5008
5009   void __set_success(const ScannerID val) {
5010     success = val;
5011   }
5012
5013   void __set_io(const IOError& val) {
5014     io = val;
5015   }
5016
5017   bool operator == (const Hbase_scannerOpenWithPrefix_result & rhs) const
5018   {
5019     if (!(success == rhs.success))
5020       return false;
5021     if (!(io == rhs.io))
5022       return false;
5023     return true;
5024   }
5025   bool operator != (const Hbase_scannerOpenWithPrefix_result &rhs) const {
5026     return !(*this == rhs);
5027   }
5028
5029   bool operator < (const Hbase_scannerOpenWithPrefix_result & ) const;
5030
5031   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5032   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5033
5034 };
5035
5036 typedef struct _Hbase_scannerOpenWithPrefix_presult__isset {
5037   _Hbase_scannerOpenWithPrefix_presult__isset() : success(false), io(false) {}
5038   bool success;
5039   bool io;
5040 } _Hbase_scannerOpenWithPrefix_presult__isset;
5041
5042 class Hbase_scannerOpenWithPrefix_presult {
5043  public:
5044
5045
5046   virtual ~Hbase_scannerOpenWithPrefix_presult() throw() {}
5047
5048   ScannerID* success;
5049   IOError io;
5050
5051   _Hbase_scannerOpenWithPrefix_presult__isset __isset;
5052
5053   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5054
5055 };
5056
5057 typedef struct _Hbase_scannerOpenTs_args__isset {
5058   _Hbase_scannerOpenTs_args__isset() : tableName(false), startRow(false), columns(false), timestamp(false), attributes(false) {}
5059   bool tableName;
5060   bool startRow;
5061   bool columns;
5062   bool timestamp;
5063   bool attributes;
5064 } _Hbase_scannerOpenTs_args__isset;
5065
5066 class Hbase_scannerOpenTs_args {
5067  public:
5068
5069   Hbase_scannerOpenTs_args() : tableName(), startRow(), timestamp(0) {
5070   }
5071
5072   virtual ~Hbase_scannerOpenTs_args() throw() {}
5073
5074   Text tableName;
5075   Text startRow;
5076   std::vector<Text>  columns;
5077   int64_t timestamp;
5078   std::map<Text, Text>  attributes;
5079
5080   _Hbase_scannerOpenTs_args__isset __isset;
5081
5082   void __set_tableName(const Text& val) {
5083     tableName = val;
5084   }
5085
5086   void __set_startRow(const Text& val) {
5087     startRow = val;
5088   }
5089
5090   void __set_columns(const std::vector<Text> & val) {
5091     columns = val;
5092   }
5093
5094   void __set_timestamp(const int64_t val) {
5095     timestamp = val;
5096   }
5097
5098   void __set_attributes(const std::map<Text, Text> & val) {
5099     attributes = val;
5100   }
5101
5102   bool operator == (const Hbase_scannerOpenTs_args & rhs) const
5103   {
5104     if (!(tableName == rhs.tableName))
5105       return false;
5106     if (!(startRow == rhs.startRow))
5107       return false;
5108     if (!(columns == rhs.columns))
5109       return false;
5110     if (!(timestamp == rhs.timestamp))
5111       return false;
5112     if (!(attributes == rhs.attributes))
5113       return false;
5114     return true;
5115   }
5116   bool operator != (const Hbase_scannerOpenTs_args &rhs) const {
5117     return !(*this == rhs);
5118   }
5119
5120   bool operator < (const Hbase_scannerOpenTs_args & ) const;
5121
5122   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5123   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5124
5125 };
5126
5127
5128 class Hbase_scannerOpenTs_pargs {
5129  public:
5130
5131
5132   virtual ~Hbase_scannerOpenTs_pargs() throw() {}
5133
5134   const Text* tableName;
5135   const Text* startRow;
5136   const std::vector<Text> * columns;
5137   const int64_t* timestamp;
5138   const std::map<Text, Text> * attributes;
5139
5140   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5141
5142 };
5143
5144 typedef struct _Hbase_scannerOpenTs_result__isset {
5145   _Hbase_scannerOpenTs_result__isset() : success(false), io(false) {}
5146   bool success;
5147   bool io;
5148 } _Hbase_scannerOpenTs_result__isset;
5149
5150 class Hbase_scannerOpenTs_result {
5151  public:
5152
5153   Hbase_scannerOpenTs_result() : success(0) {
5154   }
5155
5156   virtual ~Hbase_scannerOpenTs_result() throw() {}
5157
5158   ScannerID success;
5159   IOError io;
5160
5161   _Hbase_scannerOpenTs_result__isset __isset;
5162
5163   void __set_success(const ScannerID val) {
5164     success = val;
5165   }
5166
5167   void __set_io(const IOError& val) {
5168     io = val;
5169   }
5170
5171   bool operator == (const Hbase_scannerOpenTs_result & rhs) const
5172   {
5173     if (!(success == rhs.success))
5174       return false;
5175     if (!(io == rhs.io))
5176       return false;
5177     return true;
5178   }
5179   bool operator != (const Hbase_scannerOpenTs_result &rhs) const {
5180     return !(*this == rhs);
5181   }
5182
5183   bool operator < (const Hbase_scannerOpenTs_result & ) const;
5184
5185   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5186   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5187
5188 };
5189
5190 typedef struct _Hbase_scannerOpenTs_presult__isset {
5191   _Hbase_scannerOpenTs_presult__isset() : success(false), io(false) {}
5192   bool success;
5193   bool io;
5194 } _Hbase_scannerOpenTs_presult__isset;
5195
5196 class Hbase_scannerOpenTs_presult {
5197  public:
5198
5199
5200   virtual ~Hbase_scannerOpenTs_presult() throw() {}
5201
5202   ScannerID* success;
5203   IOError io;
5204
5205   _Hbase_scannerOpenTs_presult__isset __isset;
5206
5207   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5208
5209 };
5210
5211 typedef struct _Hbase_scannerOpenWithStopTs_args__isset {
5212   _Hbase_scannerOpenWithStopTs_args__isset() : tableName(false), startRow(false), stopRow(false), columns(false), timestamp(false), attributes(false) {}
5213   bool tableName;
5214   bool startRow;
5215   bool stopRow;
5216   bool columns;
5217   bool timestamp;
5218   bool attributes;
5219 } _Hbase_scannerOpenWithStopTs_args__isset;
5220
5221 class Hbase_scannerOpenWithStopTs_args {
5222  public:
5223
5224   Hbase_scannerOpenWithStopTs_args() : tableName(), startRow(), stopRow(), timestamp(0) {
5225   }
5226
5227   virtual ~Hbase_scannerOpenWithStopTs_args() throw() {}
5228
5229   Text tableName;
5230   Text startRow;
5231   Text stopRow;
5232   std::vector<Text>  columns;
5233   int64_t timestamp;
5234   std::map<Text, Text>  attributes;
5235
5236   _Hbase_scannerOpenWithStopTs_args__isset __isset;
5237
5238   void __set_tableName(const Text& val) {
5239     tableName = val;
5240   }
5241
5242   void __set_startRow(const Text& val) {
5243     startRow = val;
5244   }
5245
5246   void __set_stopRow(const Text& val) {
5247     stopRow = val;
5248   }
5249
5250   void __set_columns(const std::vector<Text> & val) {
5251     columns = val;
5252   }
5253
5254   void __set_timestamp(const int64_t val) {
5255     timestamp = val;
5256   }
5257
5258   void __set_attributes(const std::map<Text, Text> & val) {
5259     attributes = val;
5260   }
5261
5262   bool operator == (const Hbase_scannerOpenWithStopTs_args & rhs) const
5263   {
5264     if (!(tableName == rhs.tableName))
5265       return false;
5266     if (!(startRow == rhs.startRow))
5267       return false;
5268     if (!(stopRow == rhs.stopRow))
5269       return false;
5270     if (!(columns == rhs.columns))
5271       return false;
5272     if (!(timestamp == rhs.timestamp))
5273       return false;
5274     if (!(attributes == rhs.attributes))
5275       return false;
5276     return true;
5277   }
5278   bool operator != (const Hbase_scannerOpenWithStopTs_args &rhs) const {
5279     return !(*this == rhs);
5280   }
5281
5282   bool operator < (const Hbase_scannerOpenWithStopTs_args & ) const;
5283
5284   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5285   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5286
5287 };
5288
5289
5290 class Hbase_scannerOpenWithStopTs_pargs {
5291  public:
5292
5293
5294   virtual ~Hbase_scannerOpenWithStopTs_pargs() throw() {}
5295
5296   const Text* tableName;
5297   const Text* startRow;
5298   const Text* stopRow;
5299   const std::vector<Text> * columns;
5300   const int64_t* timestamp;
5301   const std::map<Text, Text> * attributes;
5302
5303   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5304
5305 };
5306
5307 typedef struct _Hbase_scannerOpenWithStopTs_result__isset {
5308   _Hbase_scannerOpenWithStopTs_result__isset() : success(false), io(false) {}
5309   bool success;
5310   bool io;
5311 } _Hbase_scannerOpenWithStopTs_result__isset;
5312
5313 class Hbase_scannerOpenWithStopTs_result {
5314  public:
5315
5316   Hbase_scannerOpenWithStopTs_result() : success(0) {
5317   }
5318
5319   virtual ~Hbase_scannerOpenWithStopTs_result() throw() {}
5320
5321   ScannerID success;
5322   IOError io;
5323
5324   _Hbase_scannerOpenWithStopTs_result__isset __isset;
5325
5326   void __set_success(const ScannerID val) {
5327     success = val;
5328   }
5329
5330   void __set_io(const IOError& val) {
5331     io = val;
5332   }
5333
5334   bool operator == (const Hbase_scannerOpenWithStopTs_result & rhs) const
5335   {
5336     if (!(success == rhs.success))
5337       return false;
5338     if (!(io == rhs.io))
5339       return false;
5340     return true;
5341   }
5342   bool operator != (const Hbase_scannerOpenWithStopTs_result &rhs) const {
5343     return !(*this == rhs);
5344   }
5345
5346   bool operator < (const Hbase_scannerOpenWithStopTs_result & ) const;
5347
5348   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5349   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5350
5351 };
5352
5353 typedef struct _Hbase_scannerOpenWithStopTs_presult__isset {
5354   _Hbase_scannerOpenWithStopTs_presult__isset() : success(false), io(false) {}
5355   bool success;
5356   bool io;
5357 } _Hbase_scannerOpenWithStopTs_presult__isset;
5358
5359 class Hbase_scannerOpenWithStopTs_presult {
5360  public:
5361
5362
5363   virtual ~Hbase_scannerOpenWithStopTs_presult() throw() {}
5364
5365   ScannerID* success;
5366   IOError io;
5367
5368   _Hbase_scannerOpenWithStopTs_presult__isset __isset;
5369
5370   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5371
5372 };
5373
5374 typedef struct _Hbase_scannerGet_args__isset {
5375   _Hbase_scannerGet_args__isset() : id(false) {}
5376   bool id;
5377 } _Hbase_scannerGet_args__isset;
5378
5379 class Hbase_scannerGet_args {
5380  public:
5381
5382   Hbase_scannerGet_args() : id(0) {
5383   }
5384
5385   virtual ~Hbase_scannerGet_args() throw() {}
5386
5387   ScannerID id;
5388
5389   _Hbase_scannerGet_args__isset __isset;
5390
5391   void __set_id(const ScannerID val) {
5392     id = val;
5393   }
5394
5395   bool operator == (const Hbase_scannerGet_args & rhs) const
5396   {
5397     if (!(id == rhs.id))
5398       return false;
5399     return true;
5400   }
5401   bool operator != (const Hbase_scannerGet_args &rhs) const {
5402     return !(*this == rhs);
5403   }
5404
5405   bool operator < (const Hbase_scannerGet_args & ) const;
5406
5407   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5408   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5409
5410 };
5411
5412
5413 class Hbase_scannerGet_pargs {
5414  public:
5415
5416
5417   virtual ~Hbase_scannerGet_pargs() throw() {}
5418
5419   const ScannerID* id;
5420
5421   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5422
5423 };
5424
5425 typedef struct _Hbase_scannerGet_result__isset {
5426   _Hbase_scannerGet_result__isset() : success(false), io(false), ia(false) {}
5427   bool success;
5428   bool io;
5429   bool ia;
5430 } _Hbase_scannerGet_result__isset;
5431
5432 class Hbase_scannerGet_result {
5433  public:
5434
5435   Hbase_scannerGet_result() {
5436   }
5437
5438   virtual ~Hbase_scannerGet_result() throw() {}
5439
5440   std::vector<TRowResult>  success;
5441   IOError io;
5442   IllegalArgument ia;
5443
5444   _Hbase_scannerGet_result__isset __isset;
5445
5446   void __set_success(const std::vector<TRowResult> & val) {
5447     success = val;
5448   }
5449
5450   void __set_io(const IOError& val) {
5451     io = val;
5452   }
5453
5454   void __set_ia(const IllegalArgument& val) {
5455     ia = val;
5456   }
5457
5458   bool operator == (const Hbase_scannerGet_result & rhs) const
5459   {
5460     if (!(success == rhs.success))
5461       return false;
5462     if (!(io == rhs.io))
5463       return false;
5464     if (!(ia == rhs.ia))
5465       return false;
5466     return true;
5467   }
5468   bool operator != (const Hbase_scannerGet_result &rhs) const {
5469     return !(*this == rhs);
5470   }
5471
5472   bool operator < (const Hbase_scannerGet_result & ) const;
5473
5474   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5475   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5476
5477 };
5478
5479 typedef struct _Hbase_scannerGet_presult__isset {
5480   _Hbase_scannerGet_presult__isset() : success(false), io(false), ia(false) {}
5481   bool success;
5482   bool io;
5483   bool ia;
5484 } _Hbase_scannerGet_presult__isset;
5485
5486 class Hbase_scannerGet_presult {
5487  public:
5488
5489
5490   virtual ~Hbase_scannerGet_presult() throw() {}
5491
5492   std::vector<TRowResult> * success;
5493   IOError io;
5494   IllegalArgument ia;
5495
5496   _Hbase_scannerGet_presult__isset __isset;
5497
5498   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5499
5500 };
5501
5502 typedef struct _Hbase_scannerGetList_args__isset {
5503   _Hbase_scannerGetList_args__isset() : id(false), nbRows(false) {}
5504   bool id;
5505   bool nbRows;
5506 } _Hbase_scannerGetList_args__isset;
5507
5508 class Hbase_scannerGetList_args {
5509  public:
5510
5511   Hbase_scannerGetList_args() : id(0), nbRows(0) {
5512   }
5513
5514   virtual ~Hbase_scannerGetList_args() throw() {}
5515
5516   ScannerID id;
5517   int32_t nbRows;
5518
5519   _Hbase_scannerGetList_args__isset __isset;
5520
5521   void __set_id(const ScannerID val) {
5522     id = val;
5523   }
5524
5525   void __set_nbRows(const int32_t val) {
5526     nbRows = val;
5527   }
5528
5529   bool operator == (const Hbase_scannerGetList_args & rhs) const
5530   {
5531     if (!(id == rhs.id))
5532       return false;
5533     if (!(nbRows == rhs.nbRows))
5534       return false;
5535     return true;
5536   }
5537   bool operator != (const Hbase_scannerGetList_args &rhs) const {
5538     return !(*this == rhs);
5539   }
5540
5541   bool operator < (const Hbase_scannerGetList_args & ) const;
5542
5543   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5544   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5545
5546 };
5547
5548
5549 class Hbase_scannerGetList_pargs {
5550  public:
5551
5552
5553   virtual ~Hbase_scannerGetList_pargs() throw() {}
5554
5555   const ScannerID* id;
5556   const int32_t* nbRows;
5557
5558   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5559
5560 };
5561
5562 typedef struct _Hbase_scannerGetList_result__isset {
5563   _Hbase_scannerGetList_result__isset() : success(false), io(false), ia(false) {}
5564   bool success;
5565   bool io;
5566   bool ia;
5567 } _Hbase_scannerGetList_result__isset;
5568
5569 class Hbase_scannerGetList_result {
5570  public:
5571
5572   Hbase_scannerGetList_result() {
5573   }
5574
5575   virtual ~Hbase_scannerGetList_result() throw() {}
5576
5577   std::vector<TRowResult>  success;
5578   IOError io;
5579   IllegalArgument ia;
5580
5581   _Hbase_scannerGetList_result__isset __isset;
5582
5583   void __set_success(const std::vector<TRowResult> & val) {
5584     success = val;
5585   }
5586
5587   void __set_io(const IOError& val) {
5588     io = val;
5589   }
5590
5591   void __set_ia(const IllegalArgument& val) {
5592     ia = val;
5593   }
5594
5595   bool operator == (const Hbase_scannerGetList_result & rhs) const
5596   {
5597     if (!(success == rhs.success))
5598       return false;
5599     if (!(io == rhs.io))
5600       return false;
5601     if (!(ia == rhs.ia))
5602       return false;
5603     return true;
5604   }
5605   bool operator != (const Hbase_scannerGetList_result &rhs) const {
5606     return !(*this == rhs);
5607   }
5608
5609   bool operator < (const Hbase_scannerGetList_result & ) const;
5610
5611   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5612   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5613
5614 };
5615
5616 typedef struct _Hbase_scannerGetList_presult__isset {
5617   _Hbase_scannerGetList_presult__isset() : success(false), io(false), ia(false) {}
5618   bool success;
5619   bool io;
5620   bool ia;
5621 } _Hbase_scannerGetList_presult__isset;
5622
5623 class Hbase_scannerGetList_presult {
5624  public:
5625
5626
5627   virtual ~Hbase_scannerGetList_presult() throw() {}
5628
5629   std::vector<TRowResult> * success;
5630   IOError io;
5631   IllegalArgument ia;
5632
5633   _Hbase_scannerGetList_presult__isset __isset;
5634
5635   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5636
5637 };
5638
5639 typedef struct _Hbase_scannerClose_args__isset {
5640   _Hbase_scannerClose_args__isset() : id(false) {}
5641   bool id;
5642 } _Hbase_scannerClose_args__isset;
5643
5644 class Hbase_scannerClose_args {
5645  public:
5646
5647   Hbase_scannerClose_args() : id(0) {
5648   }
5649
5650   virtual ~Hbase_scannerClose_args() throw() {}
5651
5652   ScannerID id;
5653
5654   _Hbase_scannerClose_args__isset __isset;
5655
5656   void __set_id(const ScannerID val) {
5657     id = val;
5658   }
5659
5660   bool operator == (const Hbase_scannerClose_args & rhs) const
5661   {
5662     if (!(id == rhs.id))
5663       return false;
5664     return true;
5665   }
5666   bool operator != (const Hbase_scannerClose_args &rhs) const {
5667     return !(*this == rhs);
5668   }
5669
5670   bool operator < (const Hbase_scannerClose_args & ) const;
5671
5672   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5673   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5674
5675 };
5676
5677
5678 class Hbase_scannerClose_pargs {
5679  public:
5680
5681
5682   virtual ~Hbase_scannerClose_pargs() throw() {}
5683
5684   const ScannerID* id;
5685
5686   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5687
5688 };
5689
5690 typedef struct _Hbase_scannerClose_result__isset {
5691   _Hbase_scannerClose_result__isset() : io(false), ia(false) {}
5692   bool io;
5693   bool ia;
5694 } _Hbase_scannerClose_result__isset;
5695
5696 class Hbase_scannerClose_result {
5697  public:
5698
5699   Hbase_scannerClose_result() {
5700   }
5701
5702   virtual ~Hbase_scannerClose_result() throw() {}
5703
5704   IOError io;
5705   IllegalArgument ia;
5706
5707   _Hbase_scannerClose_result__isset __isset;
5708
5709   void __set_io(const IOError& val) {
5710     io = val;
5711   }
5712
5713   void __set_ia(const IllegalArgument& val) {
5714     ia = val;
5715   }
5716
5717   bool operator == (const Hbase_scannerClose_result & rhs) const
5718   {
5719     if (!(io == rhs.io))
5720       return false;
5721     if (!(ia == rhs.ia))
5722       return false;
5723     return true;
5724   }
5725   bool operator != (const Hbase_scannerClose_result &rhs) const {
5726     return !(*this == rhs);
5727   }
5728
5729   bool operator < (const Hbase_scannerClose_result & ) const;
5730
5731   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5732   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5733
5734 };
5735
5736 typedef struct _Hbase_scannerClose_presult__isset {
5737   _Hbase_scannerClose_presult__isset() : io(false), ia(false) {}
5738   bool io;
5739   bool ia;
5740 } _Hbase_scannerClose_presult__isset;
5741
5742 class Hbase_scannerClose_presult {
5743  public:
5744
5745
5746   virtual ~Hbase_scannerClose_presult() throw() {}
5747
5748   IOError io;
5749   IllegalArgument ia;
5750
5751   _Hbase_scannerClose_presult__isset __isset;
5752
5753   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5754
5755 };
5756
5757 typedef struct _Hbase_getRowOrBefore_args__isset {
5758   _Hbase_getRowOrBefore_args__isset() : tableName(false), row(false), family(false) {}
5759   bool tableName;
5760   bool row;
5761   bool family;
5762 } _Hbase_getRowOrBefore_args__isset;
5763
5764 class Hbase_getRowOrBefore_args {
5765  public:
5766
5767   Hbase_getRowOrBefore_args() : tableName(), row(), family() {
5768   }
5769
5770   virtual ~Hbase_getRowOrBefore_args() throw() {}
5771
5772   Text tableName;
5773   Text row;
5774   Text family;
5775
5776   _Hbase_getRowOrBefore_args__isset __isset;
5777
5778   void __set_tableName(const Text& val) {
5779     tableName = val;
5780   }
5781
5782   void __set_row(const Text& val) {
5783     row = val;
5784   }
5785
5786   void __set_family(const Text& val) {
5787     family = val;
5788   }
5789
5790   bool operator == (const Hbase_getRowOrBefore_args & rhs) const
5791   {
5792     if (!(tableName == rhs.tableName))
5793       return false;
5794     if (!(row == rhs.row))
5795       return false;
5796     if (!(family == rhs.family))
5797       return false;
5798     return true;
5799   }
5800   bool operator != (const Hbase_getRowOrBefore_args &rhs) const {
5801     return !(*this == rhs);
5802   }
5803
5804   bool operator < (const Hbase_getRowOrBefore_args & ) const;
5805
5806   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5807   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5808
5809 };
5810
5811
5812 class Hbase_getRowOrBefore_pargs {
5813  public:
5814
5815
5816   virtual ~Hbase_getRowOrBefore_pargs() throw() {}
5817
5818   const Text* tableName;
5819   const Text* row;
5820   const Text* family;
5821
5822   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5823
5824 };
5825
5826 typedef struct _Hbase_getRowOrBefore_result__isset {
5827   _Hbase_getRowOrBefore_result__isset() : success(false), io(false) {}
5828   bool success;
5829   bool io;
5830 } _Hbase_getRowOrBefore_result__isset;
5831
5832 class Hbase_getRowOrBefore_result {
5833  public:
5834
5835   Hbase_getRowOrBefore_result() {
5836   }
5837
5838   virtual ~Hbase_getRowOrBefore_result() throw() {}
5839
5840   std::vector<TCell>  success;
5841   IOError io;
5842
5843   _Hbase_getRowOrBefore_result__isset __isset;
5844
5845   void __set_success(const std::vector<TCell> & val) {
5846     success = val;
5847   }
5848
5849   void __set_io(const IOError& val) {
5850     io = val;
5851   }
5852
5853   bool operator == (const Hbase_getRowOrBefore_result & rhs) const
5854   {
5855     if (!(success == rhs.success))
5856       return false;
5857     if (!(io == rhs.io))
5858       return false;
5859     return true;
5860   }
5861   bool operator != (const Hbase_getRowOrBefore_result &rhs) const {
5862     return !(*this == rhs);
5863   }
5864
5865   bool operator < (const Hbase_getRowOrBefore_result & ) const;
5866
5867   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5868   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5869
5870 };
5871
5872 typedef struct _Hbase_getRowOrBefore_presult__isset {
5873   _Hbase_getRowOrBefore_presult__isset() : success(false), io(false) {}
5874   bool success;
5875   bool io;
5876 } _Hbase_getRowOrBefore_presult__isset;
5877
5878 class Hbase_getRowOrBefore_presult {
5879  public:
5880
5881
5882   virtual ~Hbase_getRowOrBefore_presult() throw() {}
5883
5884   std::vector<TCell> * success;
5885   IOError io;
5886
5887   _Hbase_getRowOrBefore_presult__isset __isset;
5888
5889   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5890
5891 };
5892
5893 typedef struct _Hbase_getRegionInfo_args__isset {
5894   _Hbase_getRegionInfo_args__isset() : row(false) {}
5895   bool row;
5896 } _Hbase_getRegionInfo_args__isset;
5897
5898 class Hbase_getRegionInfo_args {
5899  public:
5900
5901   Hbase_getRegionInfo_args() : row() {
5902   }
5903
5904   virtual ~Hbase_getRegionInfo_args() throw() {}
5905
5906   Text row;
5907
5908   _Hbase_getRegionInfo_args__isset __isset;
5909
5910   void __set_row(const Text& val) {
5911     row = val;
5912   }
5913
5914   bool operator == (const Hbase_getRegionInfo_args & rhs) const
5915   {
5916     if (!(row == rhs.row))
5917       return false;
5918     return true;
5919   }
5920   bool operator != (const Hbase_getRegionInfo_args &rhs) const {
5921     return !(*this == rhs);
5922   }
5923
5924   bool operator < (const Hbase_getRegionInfo_args & ) const;
5925
5926   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5927   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5928
5929 };
5930
5931
5932 class Hbase_getRegionInfo_pargs {
5933  public:
5934
5935
5936   virtual ~Hbase_getRegionInfo_pargs() throw() {}
5937
5938   const Text* row;
5939
5940   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5941
5942 };
5943
5944 typedef struct _Hbase_getRegionInfo_result__isset {
5945   _Hbase_getRegionInfo_result__isset() : success(false), io(false) {}
5946   bool success;
5947   bool io;
5948 } _Hbase_getRegionInfo_result__isset;
5949
5950 class Hbase_getRegionInfo_result {
5951  public:
5952
5953   Hbase_getRegionInfo_result() {
5954   }
5955
5956   virtual ~Hbase_getRegionInfo_result() throw() {}
5957
5958   TRegionInfo success;
5959   IOError io;
5960
5961   _Hbase_getRegionInfo_result__isset __isset;
5962
5963   void __set_success(const TRegionInfo& val) {
5964     success = val;
5965   }
5966
5967   void __set_io(const IOError& val) {
5968     io = val;
5969   }
5970
5971   bool operator == (const Hbase_getRegionInfo_result & rhs) const
5972   {
5973     if (!(success == rhs.success))
5974       return false;
5975     if (!(io == rhs.io))
5976       return false;
5977     return true;
5978   }
5979   bool operator != (const Hbase_getRegionInfo_result &rhs) const {
5980     return !(*this == rhs);
5981   }
5982
5983   bool operator < (const Hbase_getRegionInfo_result & ) const;
5984
5985   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5986   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5987
5988 };
5989
5990 typedef struct _Hbase_getRegionInfo_presult__isset {
5991   _Hbase_getRegionInfo_presult__isset() : success(false), io(false) {}
5992   bool success;
5993   bool io;
5994 } _Hbase_getRegionInfo_presult__isset;
5995
5996 class Hbase_getRegionInfo_presult {
5997  public:
5998
5999
6000   virtual ~Hbase_getRegionInfo_presult() throw() {}
6001
6002   TRegionInfo* success;
6003   IOError io;
6004
6005   _Hbase_getRegionInfo_presult__isset __isset;
6006
6007   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
6008
6009 };
6010
6011 class HbaseClient : virtual public HbaseIf {
6012  public:
6013   HbaseClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
6014     piprot_(prot),
6015     poprot_(prot) {
6016     iprot_ = prot.get();
6017     oprot_ = prot.get();
6018   }
6019   HbaseClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
6020     piprot_(iprot),
6021     poprot_(oprot) {
6022     iprot_ = iprot.get();
6023     oprot_ = oprot.get();
6024   }
6025   std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
6026     return piprot_;
6027   }
6028   std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
6029     return poprot_;
6030   }
6031   void enableTable(const Bytes& tableName);
6032   void send_enableTable(const Bytes& tableName);
6033   void recv_enableTable();
6034   void disableTable(const Bytes& tableName);
6035   void send_disableTable(const Bytes& tableName);
6036   void recv_disableTable();
6037   bool isTableEnabled(const Bytes& tableName);
6038   void send_isTableEnabled(const Bytes& tableName);
6039   bool recv_isTableEnabled();
6040   void compact(const Bytes& tableNameOrRegionName);
6041   void send_compact(const Bytes& tableNameOrRegionName);
6042   void recv_compact();
6043   void majorCompact(const Bytes& tableNameOrRegionName);
6044   void send_majorCompact(const Bytes& tableNameOrRegionName);
6045   void recv_majorCompact();
6046   void getTableNames(std::vector<Text> & _return);
6047   void send_getTableNames();
6048   void recv_getTableNames(std::vector<Text> & _return);
6049   void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName);
6050   void send_getColumnDescriptors(const Text& tableName);
6051   void recv_getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return);
6052   void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName);
6053   void send_getTableRegions(const Text& tableName);
6054   void recv_getTableRegions(std::vector<TRegionInfo> & _return);
6055   void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies);
6056   void send_createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies);
6057   void recv_createTable();
6058   void deleteTable(const Text& tableName);
6059   void send_deleteTable(const Text& tableName);
6060   void recv_deleteTable();
6061   void get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes);
6062   void send_get(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes);
6063   void recv_get(std::vector<TCell> & _return);
6064   void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes);
6065   void send_getVer(const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes);
6066   void recv_getVer(std::vector<TCell> & _return);
6067   void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes);
6068   void send_getVerTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes);
6069   void recv_getVerTs(std::vector<TCell> & _return);
6070   void getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::map<Text, Text> & attributes);
6071   void send_getRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes);
6072   void recv_getRow(std::vector<TRowResult> & _return);
6073   void getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6074   void send_getRowWithColumns(const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6075   void recv_getRowWithColumns(std::vector<TRowResult> & _return);
6076   void getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes);
6077   void send_getRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes);
6078   void recv_getRowTs(std::vector<TRowResult> & _return);
6079   void getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6080   void send_getRowWithColumnsTs(const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6081   void recv_getRowWithColumnsTs(std::vector<TRowResult> & _return);
6082   void getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes);
6083   void send_getRows(const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes);
6084   void recv_getRows(std::vector<TRowResult> & _return);
6085   void getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6086   void send_getRowsWithColumns(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6087   void recv_getRowsWithColumns(std::vector<TRowResult> & _return);
6088   void getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes);
6089   void send_getRowsTs(const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes);
6090   void recv_getRowsTs(std::vector<TRowResult> & _return);
6091   void getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6092   void send_getRowsWithColumnsTs(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6093   void recv_getRowsWithColumnsTs(std::vector<TRowResult> & _return);
6094   void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes);
6095   void send_mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes);
6096   void recv_mutateRow();
6097   void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes);
6098   void send_mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes);
6099   void recv_mutateRowTs();
6100   void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes);
6101   void send_mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes);
6102   void recv_mutateRows();
6103   void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes);
6104   void send_mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes);
6105   void recv_mutateRowsTs();
6106   int64_t atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value);
6107   void send_atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value);
6108   int64_t recv_atomicIncrement();
6109   void deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes);
6110   void send_deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes);
6111   void recv_deleteAll();
6112   void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes);
6113   void send_deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes);
6114   void recv_deleteAllTs();
6115   void deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes);
6116   void send_deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes);
6117   void recv_deleteAllRow();
6118   void increment(const TIncrement& increment);
6119   void send_increment(const TIncrement& increment);
6120   void recv_increment();
6121   void incrementRows(const std::vector<TIncrement> & increments);
6122   void send_incrementRows(const std::vector<TIncrement> & increments);
6123   void recv_incrementRows();
6124   void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes);
6125   void send_deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes);
6126   void recv_deleteAllRowTs();
6127   ScannerID scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes);
6128   void send_scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes);
6129   ScannerID recv_scannerOpenWithScan();
6130   ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6131   void send_scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6132   ScannerID recv_scannerOpen();
6133   ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6134   void send_scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6135   ScannerID recv_scannerOpenWithStop();
6136   ScannerID scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6137   void send_scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6138   ScannerID recv_scannerOpenWithPrefix();
6139   ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6140   void send_scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6141   ScannerID recv_scannerOpenTs();
6142   ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6143   void send_scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6144   ScannerID recv_scannerOpenWithStopTs();
6145   void scannerGet(std::vector<TRowResult> & _return, const ScannerID id);
6146   void send_scannerGet(const ScannerID id);
6147   void recv_scannerGet(std::vector<TRowResult> & _return);
6148   void scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows);
6149   void send_scannerGetList(const ScannerID id, const int32_t nbRows);
6150   void recv_scannerGetList(std::vector<TRowResult> & _return);
6151   void scannerClose(const ScannerID id);
6152   void send_scannerClose(const ScannerID id);
6153   void recv_scannerClose();
6154   void getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family);
6155   void send_getRowOrBefore(const Text& tableName, const Text& row, const Text& family);
6156   void recv_getRowOrBefore(std::vector<TCell> & _return);
6157   void getRegionInfo(TRegionInfo& _return, const Text& row);
6158   void send_getRegionInfo(const Text& row);
6159   void recv_getRegionInfo(TRegionInfo& _return);
6160  protected:
6161   std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
6162   std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
6163   ::apache::thrift::protocol::TProtocol* iprot_;
6164   ::apache::thrift::protocol::TProtocol* oprot_;
6165 };
6166
6167 class HbaseProcessor : public ::apache::thrift::TDispatchProcessor {
6168  protected:
6169   std::shared_ptr<HbaseIf> iface_;
6170   virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
6171  private:
6172   typedef  void (HbaseProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
6173   typedef std::map<std::string, ProcessFunction> ProcessMap;
6174   ProcessMap processMap_;
6175   void process_enableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6176   void process_disableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6177   void process_isTableEnabled(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6178   void process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6179   void process_majorCompact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6180   void process_getTableNames(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6181   void process_getColumnDescriptors(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6182   void process_getTableRegions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6183   void process_createTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6184   void process_deleteTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6185   void process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6186   void process_getVer(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6187   void process_getVerTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6188   void process_getRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6189   void process_getRowWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6190   void process_getRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6191   void process_getRowWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6192   void process_getRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6193   void process_getRowsWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6194   void process_getRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6195   void process_getRowsWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6196   void process_mutateRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6197   void process_mutateRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6198   void process_mutateRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6199   void process_mutateRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6200   void process_atomicIncrement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6201   void process_deleteAll(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6202   void process_deleteAllTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6203   void process_deleteAllRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6204   void process_increment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6205   void process_incrementRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6206   void process_deleteAllRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6207   void process_scannerOpenWithScan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6208   void process_scannerOpen(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6209   void process_scannerOpenWithStop(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6210   void process_scannerOpenWithPrefix(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6211   void process_scannerOpenTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6212   void process_scannerOpenWithStopTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6213   void process_scannerGet(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6214   void process_scannerGetList(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6215   void process_scannerClose(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6216   void process_getRowOrBefore(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6217   void process_getRegionInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6218  public:
6219   HbaseProcessor(std::shared_ptr<HbaseIf> iface) :
6220     iface_(iface) {
6221     processMap_["enableTable"] = &HbaseProcessor::process_enableTable;
6222     processMap_["disableTable"] = &HbaseProcessor::process_disableTable;
6223     processMap_["isTableEnabled"] = &HbaseProcessor::process_isTableEnabled;
6224     processMap_["compact"] = &HbaseProcessor::process_compact;
6225     processMap_["majorCompact"] = &HbaseProcessor::process_majorCompact;
6226     processMap_["getTableNames"] = &HbaseProcessor::process_getTableNames;
6227     processMap_["getColumnDescriptors"] = &HbaseProcessor::process_getColumnDescriptors;
6228     processMap_["getTableRegions"] = &HbaseProcessor::process_getTableRegions;
6229     processMap_["createTable"] = &HbaseProcessor::process_createTable;
6230     processMap_["deleteTable"] = &HbaseProcessor::process_deleteTable;
6231     processMap_["get"] = &HbaseProcessor::process_get;
6232     processMap_["getVer"] = &HbaseProcessor::process_getVer;
6233     processMap_["getVerTs"] = &HbaseProcessor::process_getVerTs;
6234     processMap_["getRow"] = &HbaseProcessor::process_getRow;
6235     processMap_["getRowWithColumns"] = &HbaseProcessor::process_getRowWithColumns;
6236     processMap_["getRowTs"] = &HbaseProcessor::process_getRowTs;
6237     processMap_["getRowWithColumnsTs"] = &HbaseProcessor::process_getRowWithColumnsTs;
6238     processMap_["getRows"] = &HbaseProcessor::process_getRows;
6239     processMap_["getRowsWithColumns"] = &HbaseProcessor::process_getRowsWithColumns;
6240     processMap_["getRowsTs"] = &HbaseProcessor::process_getRowsTs;
6241     processMap_["getRowsWithColumnsTs"] = &HbaseProcessor::process_getRowsWithColumnsTs;
6242     processMap_["mutateRow"] = &HbaseProcessor::process_mutateRow;
6243     processMap_["mutateRowTs"] = &HbaseProcessor::process_mutateRowTs;
6244     processMap_["mutateRows"] = &HbaseProcessor::process_mutateRows;
6245     processMap_["mutateRowsTs"] = &HbaseProcessor::process_mutateRowsTs;
6246     processMap_["atomicIncrement"] = &HbaseProcessor::process_atomicIncrement;
6247     processMap_["deleteAll"] = &HbaseProcessor::process_deleteAll;
6248     processMap_["deleteAllTs"] = &HbaseProcessor::process_deleteAllTs;
6249     processMap_["deleteAllRow"] = &HbaseProcessor::process_deleteAllRow;
6250     processMap_["increment"] = &HbaseProcessor::process_increment;
6251     processMap_["incrementRows"] = &HbaseProcessor::process_incrementRows;
6252     processMap_["deleteAllRowTs"] = &HbaseProcessor::process_deleteAllRowTs;
6253     processMap_["scannerOpenWithScan"] = &HbaseProcessor::process_scannerOpenWithScan;
6254     processMap_["scannerOpen"] = &HbaseProcessor::process_scannerOpen;
6255     processMap_["scannerOpenWithStop"] = &HbaseProcessor::process_scannerOpenWithStop;
6256     processMap_["scannerOpenWithPrefix"] = &HbaseProcessor::process_scannerOpenWithPrefix;
6257     processMap_["scannerOpenTs"] = &HbaseProcessor::process_scannerOpenTs;
6258     processMap_["scannerOpenWithStopTs"] = &HbaseProcessor::process_scannerOpenWithStopTs;
6259     processMap_["scannerGet"] = &HbaseProcessor::process_scannerGet;
6260     processMap_["scannerGetList"] = &HbaseProcessor::process_scannerGetList;
6261     processMap_["scannerClose"] = &HbaseProcessor::process_scannerClose;
6262     processMap_["getRowOrBefore"] = &HbaseProcessor::process_getRowOrBefore;
6263     processMap_["getRegionInfo"] = &HbaseProcessor::process_getRegionInfo;
6264   }
6265
6266   virtual ~HbaseProcessor() {}
6267 };
6268
6269 class HbaseProcessorFactory : public ::apache::thrift::TProcessorFactory {
6270  public:
6271   HbaseProcessorFactory(const std::shared_ptr< HbaseIfFactory >& handlerFactory) :
6272       handlerFactory_(handlerFactory) {}
6273
6274   std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
6275
6276  protected:
6277   std::shared_ptr< HbaseIfFactory > handlerFactory_;
6278 };
6279
6280 class HbaseMultiface : virtual public HbaseIf {
6281  public:
6282   HbaseMultiface(std::vector<std::shared_ptr<HbaseIf> >& ifaces) : ifaces_(ifaces) {
6283   }
6284   virtual ~HbaseMultiface() {}
6285  protected:
6286   std::vector<std::shared_ptr<HbaseIf> > ifaces_;
6287   HbaseMultiface() {}
6288   void add(std::shared_ptr<HbaseIf> iface) {
6289     ifaces_.push_back(iface);
6290   }
6291  public:
6292   void enableTable(const Bytes& tableName) {
6293     size_t sz = ifaces_.size();
6294     size_t i = 0;
6295     for (; i < (sz - 1); ++i) {
6296       ifaces_[i]->enableTable(tableName);
6297     }
6298     ifaces_[i]->enableTable(tableName);
6299   }
6300
6301   void disableTable(const Bytes& tableName) {
6302     size_t sz = ifaces_.size();
6303     size_t i = 0;
6304     for (; i < (sz - 1); ++i) {
6305       ifaces_[i]->disableTable(tableName);
6306     }
6307     ifaces_[i]->disableTable(tableName);
6308   }
6309
6310   bool isTableEnabled(const Bytes& tableName) {
6311     size_t sz = ifaces_.size();
6312     size_t i = 0;
6313     for (; i < (sz - 1); ++i) {
6314       ifaces_[i]->isTableEnabled(tableName);
6315     }
6316     return ifaces_[i]->isTableEnabled(tableName);
6317   }
6318
6319   void compact(const Bytes& tableNameOrRegionName) {
6320     size_t sz = ifaces_.size();
6321     size_t i = 0;
6322     for (; i < (sz - 1); ++i) {
6323       ifaces_[i]->compact(tableNameOrRegionName);
6324     }
6325     ifaces_[i]->compact(tableNameOrRegionName);
6326   }
6327
6328   void majorCompact(const Bytes& tableNameOrRegionName) {
6329     size_t sz = ifaces_.size();
6330     size_t i = 0;
6331     for (; i < (sz - 1); ++i) {
6332       ifaces_[i]->majorCompact(tableNameOrRegionName);
6333     }
6334     ifaces_[i]->majorCompact(tableNameOrRegionName);
6335   }
6336
6337   void getTableNames(std::vector<Text> & _return) {
6338     size_t sz = ifaces_.size();
6339     size_t i = 0;
6340     for (; i < (sz - 1); ++i) {
6341       ifaces_[i]->getTableNames(_return);
6342     }
6343     ifaces_[i]->getTableNames(_return);
6344     return;
6345   }
6346
6347   void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName) {
6348     size_t sz = ifaces_.size();
6349     size_t i = 0;
6350     for (; i < (sz - 1); ++i) {
6351       ifaces_[i]->getColumnDescriptors(_return, tableName);
6352     }
6353     ifaces_[i]->getColumnDescriptors(_return, tableName);
6354     return;
6355   }
6356
6357   void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName) {
6358     size_t sz = ifaces_.size();
6359     size_t i = 0;
6360     for (; i < (sz - 1); ++i) {
6361       ifaces_[i]->getTableRegions(_return, tableName);
6362     }
6363     ifaces_[i]->getTableRegions(_return, tableName);
6364     return;
6365   }
6366
6367   void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies) {
6368     size_t sz = ifaces_.size();
6369     size_t i = 0;
6370     for (; i < (sz - 1); ++i) {
6371       ifaces_[i]->createTable(tableName, columnFamilies);
6372     }
6373     ifaces_[i]->createTable(tableName, columnFamilies);
6374   }
6375
6376   void deleteTable(const Text& tableName) {
6377     size_t sz = ifaces_.size();
6378     size_t i = 0;
6379     for (; i < (sz - 1); ++i) {
6380       ifaces_[i]->deleteTable(tableName);
6381     }
6382     ifaces_[i]->deleteTable(tableName);
6383   }
6384
6385   void get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes) {
6386     size_t sz = ifaces_.size();
6387     size_t i = 0;
6388     for (; i < (sz - 1); ++i) {
6389       ifaces_[i]->get(_return, tableName, row, column, attributes);
6390     }
6391     ifaces_[i]->get(_return, tableName, row, column, attributes);
6392     return;
6393   }
6394
6395   void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes) {
6396     size_t sz = ifaces_.size();
6397     size_t i = 0;
6398     for (; i < (sz - 1); ++i) {
6399       ifaces_[i]->getVer(_return, tableName, row, column, numVersions, attributes);
6400     }
6401     ifaces_[i]->getVer(_return, tableName, row, column, numVersions, attributes);
6402     return;
6403   }
6404
6405   void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes) {
6406     size_t sz = ifaces_.size();
6407     size_t i = 0;
6408     for (; i < (sz - 1); ++i) {
6409       ifaces_[i]->getVerTs(_return, tableName, row, column, timestamp, numVersions, attributes);
6410     }
6411     ifaces_[i]->getVerTs(_return, tableName, row, column, timestamp, numVersions, attributes);
6412     return;
6413   }
6414
6415   void getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::map<Text, Text> & attributes) {
6416     size_t sz = ifaces_.size();
6417     size_t i = 0;
6418     for (; i < (sz - 1); ++i) {
6419       ifaces_[i]->getRow(_return, tableName, row, attributes);
6420     }
6421     ifaces_[i]->getRow(_return, tableName, row, attributes);
6422     return;
6423   }
6424
6425   void getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) {
6426     size_t sz = ifaces_.size();
6427     size_t i = 0;
6428     for (; i < (sz - 1); ++i) {
6429       ifaces_[i]->getRowWithColumns(_return, tableName, row, columns, attributes);
6430     }
6431     ifaces_[i]->getRowWithColumns(_return, tableName, row, columns, attributes);
6432     return;
6433   }
6434
6435   void getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6436     size_t sz = ifaces_.size();
6437     size_t i = 0;
6438     for (; i < (sz - 1); ++i) {
6439       ifaces_[i]->getRowTs(_return, tableName, row, timestamp, attributes);
6440     }
6441     ifaces_[i]->getRowTs(_return, tableName, row, timestamp, attributes);
6442     return;
6443   }
6444
6445   void getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6446     size_t sz = ifaces_.size();
6447     size_t i = 0;
6448     for (; i < (sz - 1); ++i) {
6449       ifaces_[i]->getRowWithColumnsTs(_return, tableName, row, columns, timestamp, attributes);
6450     }
6451     ifaces_[i]->getRowWithColumnsTs(_return, tableName, row, columns, timestamp, attributes);
6452     return;
6453   }
6454
6455   void getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes) {
6456     size_t sz = ifaces_.size();
6457     size_t i = 0;
6458     for (; i < (sz - 1); ++i) {
6459       ifaces_[i]->getRows(_return, tableName, rows, attributes);
6460     }
6461     ifaces_[i]->getRows(_return, tableName, rows, attributes);
6462     return;
6463   }
6464
6465   void getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) {
6466     size_t sz = ifaces_.size();
6467     size_t i = 0;
6468     for (; i < (sz - 1); ++i) {
6469       ifaces_[i]->getRowsWithColumns(_return, tableName, rows, columns, attributes);
6470     }
6471     ifaces_[i]->getRowsWithColumns(_return, tableName, rows, columns, attributes);
6472     return;
6473   }
6474
6475   void getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6476     size_t sz = ifaces_.size();
6477     size_t i = 0;
6478     for (; i < (sz - 1); ++i) {
6479       ifaces_[i]->getRowsTs(_return, tableName, rows, timestamp, attributes);
6480     }
6481     ifaces_[i]->getRowsTs(_return, tableName, rows, timestamp, attributes);
6482     return;
6483   }
6484
6485   void getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6486     size_t sz = ifaces_.size();
6487     size_t i = 0;
6488     for (; i < (sz - 1); ++i) {
6489       ifaces_[i]->getRowsWithColumnsTs(_return, tableName, rows, columns, timestamp, attributes);
6490     }
6491     ifaces_[i]->getRowsWithColumnsTs(_return, tableName, rows, columns, timestamp, attributes);
6492     return;
6493   }
6494
6495   void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes) {
6496     size_t sz = ifaces_.size();
6497     size_t i = 0;
6498     for (; i < (sz - 1); ++i) {
6499       ifaces_[i]->mutateRow(tableName, row, mutations, attributes);
6500     }
6501     ifaces_[i]->mutateRow(tableName, row, mutations, attributes);
6502   }
6503
6504   void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6505     size_t sz = ifaces_.size();
6506     size_t i = 0;
6507     for (; i < (sz - 1); ++i) {
6508       ifaces_[i]->mutateRowTs(tableName, row, mutations, timestamp, attributes);
6509     }
6510     ifaces_[i]->mutateRowTs(tableName, row, mutations, timestamp, attributes);
6511   }
6512
6513   void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes) {
6514     size_t sz = ifaces_.size();
6515     size_t i = 0;
6516     for (; i < (sz - 1); ++i) {
6517       ifaces_[i]->mutateRows(tableName, rowBatches, attributes);
6518     }
6519     ifaces_[i]->mutateRows(tableName, rowBatches, attributes);
6520   }
6521
6522   void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6523     size_t sz = ifaces_.size();
6524     size_t i = 0;
6525     for (; i < (sz - 1); ++i) {
6526       ifaces_[i]->mutateRowsTs(tableName, rowBatches, timestamp, attributes);
6527     }
6528     ifaces_[i]->mutateRowsTs(tableName, rowBatches, timestamp, attributes);
6529   }
6530
6531   int64_t atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value) {
6532     size_t sz = ifaces_.size();
6533     size_t i = 0;
6534     for (; i < (sz - 1); ++i) {
6535       ifaces_[i]->atomicIncrement(tableName, row, column, value);
6536     }
6537     return ifaces_[i]->atomicIncrement(tableName, row, column, value);
6538   }
6539
6540   void deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes) {
6541     size_t sz = ifaces_.size();
6542     size_t i = 0;
6543     for (; i < (sz - 1); ++i) {
6544       ifaces_[i]->deleteAll(tableName, row, column, attributes);
6545     }
6546     ifaces_[i]->deleteAll(tableName, row, column, attributes);
6547   }
6548
6549   void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6550     size_t sz = ifaces_.size();
6551     size_t i = 0;
6552     for (; i < (sz - 1); ++i) {
6553       ifaces_[i]->deleteAllTs(tableName, row, column, timestamp, attributes);
6554     }
6555     ifaces_[i]->deleteAllTs(tableName, row, column, timestamp, attributes);
6556   }
6557
6558   void deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes) {
6559     size_t sz = ifaces_.size();
6560     size_t i = 0;
6561     for (; i < (sz - 1); ++i) {
6562       ifaces_[i]->deleteAllRow(tableName, row, attributes);
6563     }
6564     ifaces_[i]->deleteAllRow(tableName, row, attributes);
6565   }
6566
6567   void increment(const TIncrement& increment) {
6568     size_t sz = ifaces_.size();
6569     size_t i = 0;
6570     for (; i < (sz - 1); ++i) {
6571       ifaces_[i]->increment(increment);
6572     }
6573     ifaces_[i]->increment(increment);
6574   }
6575
6576   void incrementRows(const std::vector<TIncrement> & increments) {
6577     size_t sz = ifaces_.size();
6578     size_t i = 0;
6579     for (; i < (sz - 1); ++i) {
6580       ifaces_[i]->incrementRows(increments);
6581     }
6582     ifaces_[i]->incrementRows(increments);
6583   }
6584
6585   void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6586     size_t sz = ifaces_.size();
6587     size_t i = 0;
6588     for (; i < (sz - 1); ++i) {
6589       ifaces_[i]->deleteAllRowTs(tableName, row, timestamp, attributes);
6590     }
6591     ifaces_[i]->deleteAllRowTs(tableName, row, timestamp, attributes);
6592   }
6593
6594   ScannerID scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes) {
6595     size_t sz = ifaces_.size();
6596     size_t i = 0;
6597     for (; i < (sz - 1); ++i) {
6598       ifaces_[i]->scannerOpenWithScan(tableName, scan, attributes);
6599     }
6600     return ifaces_[i]->scannerOpenWithScan(tableName, scan, attributes);
6601   }
6602
6603   ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) {
6604     size_t sz = ifaces_.size();
6605     size_t i = 0;
6606     for (; i < (sz - 1); ++i) {
6607       ifaces_[i]->scannerOpen(tableName, startRow, columns, attributes);
6608     }
6609     return ifaces_[i]->scannerOpen(tableName, startRow, columns, attributes);
6610   }
6611
6612   ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) {
6613     size_t sz = ifaces_.size();
6614     size_t i = 0;
6615     for (; i < (sz - 1); ++i) {
6616       ifaces_[i]->scannerOpenWithStop(tableName, startRow, stopRow, columns, attributes);
6617     }
6618     return ifaces_[i]->scannerOpenWithStop(tableName, startRow, stopRow, columns, attributes);
6619   }
6620
6621   ScannerID scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) {
6622     size_t sz = ifaces_.size();
6623     size_t i = 0;
6624     for (; i < (sz - 1); ++i) {
6625       ifaces_[i]->scannerOpenWithPrefix(tableName, startAndPrefix, columns, attributes);
6626     }
6627     return ifaces_[i]->scannerOpenWithPrefix(tableName, startAndPrefix, columns, attributes);
6628   }
6629
6630   ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6631     size_t sz = ifaces_.size();
6632     size_t i = 0;
6633     for (; i < (sz - 1); ++i) {
6634       ifaces_[i]->scannerOpenTs(tableName, startRow, columns, timestamp, attributes);
6635     }
6636     return ifaces_[i]->scannerOpenTs(tableName, startRow, columns, timestamp, attributes);
6637   }
6638
6639   ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6640     size_t sz = ifaces_.size();
6641     size_t i = 0;
6642     for (; i < (sz - 1); ++i) {
6643       ifaces_[i]->scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp, attributes);
6644     }
6645     return ifaces_[i]->scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp, attributes);
6646   }
6647
6648   void scannerGet(std::vector<TRowResult> & _return, const ScannerID id) {
6649     size_t sz = ifaces_.size();
6650     size_t i = 0;
6651     for (; i < (sz - 1); ++i) {
6652       ifaces_[i]->scannerGet(_return, id);
6653     }
6654     ifaces_[i]->scannerGet(_return, id);
6655     return;
6656   }
6657
6658   void scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows) {
6659     size_t sz = ifaces_.size();
6660     size_t i = 0;
6661     for (; i < (sz - 1); ++i) {
6662       ifaces_[i]->scannerGetList(_return, id, nbRows);
6663     }
6664     ifaces_[i]->scannerGetList(_return, id, nbRows);
6665     return;
6666   }
6667
6668   void scannerClose(const ScannerID id) {
6669     size_t sz = ifaces_.size();
6670     size_t i = 0;
6671     for (; i < (sz - 1); ++i) {
6672       ifaces_[i]->scannerClose(id);
6673     }
6674     ifaces_[i]->scannerClose(id);
6675   }
6676
6677   void getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family) {
6678     size_t sz = ifaces_.size();
6679     size_t i = 0;
6680     for (; i < (sz - 1); ++i) {
6681       ifaces_[i]->getRowOrBefore(_return, tableName, row, family);
6682     }
6683     ifaces_[i]->getRowOrBefore(_return, tableName, row, family);
6684     return;
6685   }
6686
6687   void getRegionInfo(TRegionInfo& _return, const Text& row) {
6688     size_t sz = ifaces_.size();
6689     size_t i = 0;
6690     for (; i < (sz - 1); ++i) {
6691       ifaces_[i]->getRegionInfo(_return, row);
6692     }
6693     ifaces_[i]->getRegionInfo(_return, row);
6694     return;
6695   }
6696
6697 };
6698
6699 }}}} // namespace
6700
6701 #endif