/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 */
#ifndef Hbase_H
#define Hbase_H

#include <TProcessor.h>
#include "Hbase_types.h"

namespace apache { namespace hadoop { namespace hbase { namespace thrift {

class HbaseIf {
 public:
  virtual ~HbaseIf() {}
  virtual void enableTable(const Bytes& tableName) = 0;
  virtual void disableTable(const Bytes& tableName) = 0;
  virtual bool isTableEnabled(const Bytes& tableName) = 0;
  virtual void getTableNames(std::vector<Text> & _return) = 0;
  virtual void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName) = 0;
  virtual void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName) = 0;
  virtual void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies) = 0;
  virtual void deleteTable(const Text& tableName) = 0;
  virtual void get(TCell& _return, const Text& tableName, const Text& row, const Text& column) = 0;
  virtual void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions) = 0;
  virtual void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions) = 0;
  virtual void getRow(TRowResult& _return, const Text& tableName, const Text& row) = 0;
  virtual void getRowTs(TRowResult& _return, const Text& tableName, const Text& row, const int64_t timestamp) = 0;
  virtual void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations) = 0;
  virtual void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp) = 0;
  virtual void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches) = 0;
  virtual void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp) = 0;
  virtual void deleteAll(const Text& tableName, const Text& row, const Text& column) = 0;
  virtual void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp) = 0;
  virtual void deleteAllRow(const Text& tableName, const Text& row) = 0;
  virtual void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp) = 0;
  virtual ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns) = 0;
  virtual ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns) = 0;
  virtual ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp) = 0;
  virtual ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp) = 0;
  virtual void scannerGet(TRowResult& _return, const ScannerID id) = 0;
  virtual void scannerClose(const ScannerID id) = 0;
};

class HbaseNull : virtual public HbaseIf {
 public:
  virtual ~HbaseNull() {}
  void enableTable(const Bytes& /* tableName */) {
    return;
  }
  void disableTable(const Bytes& /* tableName */) {
    return;
  }
  bool isTableEnabled(const Bytes& /* tableName */) {
    bool _return = false;
    return _return;
  }
  void getTableNames(std::vector<Text> & /* _return */) {
    return;
  }
  void getColumnDescriptors(std::map<Text, ColumnDescriptor> & /* _return */, const Text& /* tableName */) {
    return;
  }
  void getTableRegions(std::vector<TRegionInfo> & /* _return */, const Text& /* tableName */) {
    return;
  }
  void createTable(const Text& /* tableName */, const std::vector<ColumnDescriptor> & /* columnFamilies */) {
    return;
  }
  void deleteTable(const Text& /* tableName */) {
    return;
  }
  void get(TCell& /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */) {
    return;
  }
  void getVer(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int32_t /* numVersions */) {
    return;
  }
  void getVerTs(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* timestamp */, const int32_t /* numVersions */) {
    return;
  }
  void getRow(TRowResult& /* _return */, const Text& /* tableName */, const Text& /* row */) {
    return;
  }
  void getRowTs(TRowResult& /* _return */, const Text& /* tableName */, const Text& /* row */, const int64_t /* timestamp */) {
    return;
  }
  void mutateRow(const Text& /* tableName */, const Text& /* row */, const std::vector<Mutation> & /* mutations */) {
    return;
  }
  void mutateRowTs(const Text& /* tableName */, const Text& /* row */, const std::vector<Mutation> & /* mutations */, const int64_t /* timestamp */) {
    return;
  }
  void mutateRows(const Text& /* tableName */, const std::vector<BatchMutation> & /* rowBatches */) {
    return;
  }
  void mutateRowsTs(const Text& /* tableName */, const std::vector<BatchMutation> & /* rowBatches */, const int64_t /* timestamp */) {
    return;
  }
  void deleteAll(const Text& /* tableName */, const Text& /* row */, const Text& /* column */) {
    return;
  }
  void deleteAllTs(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* timestamp */) {
    return;
  }
  void deleteAllRow(const Text& /* tableName */, const Text& /* row */) {
    return;
  }
  void deleteAllRowTs(const Text& /* tableName */, const Text& /* row */, const int64_t /* timestamp */) {
    return;
  }
  ScannerID scannerOpen(const Text& /* tableName */, const Text& /* startRow */, const std::vector<Text> & /* columns */) {
    ScannerID _return = 0;
    return _return;
  }
  ScannerID scannerOpenWithStop(const Text& /* tableName */, const Text& /* startRow */, const Text& /* stopRow */, const std::vector<Text> & /* columns */) {
    ScannerID _return = 0;
    return _return;
  }
  ScannerID scannerOpenTs(const Text& /* tableName */, const Text& /* startRow */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */) {
    ScannerID _return = 0;
    return _return;
  }
  ScannerID scannerOpenWithStopTs(const Text& /* tableName */, const Text& /* startRow */, const Text& /* stopRow */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */) {
    ScannerID _return = 0;
    return _return;
  }
  void scannerGet(TRowResult& /* _return */, const ScannerID /* id */) {
    return;
  }
  void scannerClose(const ScannerID /* id */) {
    return;
  }
};

class Hbase_enableTable_args {
 public:

  Hbase_enableTable_args() : tableName("") {
  }

  virtual ~Hbase_enableTable_args() throw() {}

  Bytes tableName;

  struct __isset {
    __isset() : tableName(false) {}
    bool tableName;
  } __isset;

  bool operator == (const Hbase_enableTable_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    return true;
  }
  bool operator != (const Hbase_enableTable_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_enableTable_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_enableTable_pargs {
 public:


  virtual ~Hbase_enableTable_pargs() throw() {}

  const Bytes* tableName;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_enableTable_result {
 public:

  Hbase_enableTable_result() {
  }

  virtual ~Hbase_enableTable_result() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  bool operator == (const Hbase_enableTable_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_enableTable_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_enableTable_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_enableTable_presult {
 public:


  virtual ~Hbase_enableTable_presult() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_disableTable_args {
 public:

  Hbase_disableTable_args() : tableName("") {
  }

  virtual ~Hbase_disableTable_args() throw() {}

  Bytes tableName;

  struct __isset {
    __isset() : tableName(false) {}
    bool tableName;
  } __isset;

  bool operator == (const Hbase_disableTable_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    return true;
  }
  bool operator != (const Hbase_disableTable_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_disableTable_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_disableTable_pargs {
 public:


  virtual ~Hbase_disableTable_pargs() throw() {}

  const Bytes* tableName;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_disableTable_result {
 public:

  Hbase_disableTable_result() {
  }

  virtual ~Hbase_disableTable_result() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  bool operator == (const Hbase_disableTable_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_disableTable_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_disableTable_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_disableTable_presult {
 public:


  virtual ~Hbase_disableTable_presult() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_isTableEnabled_args {
 public:

  Hbase_isTableEnabled_args() : tableName("") {
  }

  virtual ~Hbase_isTableEnabled_args() throw() {}

  Bytes tableName;

  struct __isset {
    __isset() : tableName(false) {}
    bool tableName;
  } __isset;

  bool operator == (const Hbase_isTableEnabled_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    return true;
  }
  bool operator != (const Hbase_isTableEnabled_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_isTableEnabled_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_isTableEnabled_pargs {
 public:


  virtual ~Hbase_isTableEnabled_pargs() throw() {}

  const Bytes* tableName;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_isTableEnabled_result {
 public:

  Hbase_isTableEnabled_result() : success(0) {
  }

  virtual ~Hbase_isTableEnabled_result() throw() {}

  bool success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  bool operator == (const Hbase_isTableEnabled_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_isTableEnabled_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_isTableEnabled_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_isTableEnabled_presult {
 public:


  virtual ~Hbase_isTableEnabled_presult() throw() {}

  bool* success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_getTableNames_args {
 public:

  Hbase_getTableNames_args() {
  }

  virtual ~Hbase_getTableNames_args() throw() {}


  bool operator == (const Hbase_getTableNames_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const Hbase_getTableNames_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getTableNames_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getTableNames_pargs {
 public:


  virtual ~Hbase_getTableNames_pargs() throw() {}


  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getTableNames_result {
 public:

  Hbase_getTableNames_result() {
  }

  virtual ~Hbase_getTableNames_result() throw() {}

  std::vector<Text>  success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  bool operator == (const Hbase_getTableNames_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_getTableNames_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getTableNames_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getTableNames_presult {
 public:


  virtual ~Hbase_getTableNames_presult() throw() {}

  std::vector<Text> * success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_getColumnDescriptors_args {
 public:

  Hbase_getColumnDescriptors_args() : tableName("") {
  }

  virtual ~Hbase_getColumnDescriptors_args() throw() {}

  Text tableName;

  struct __isset {
    __isset() : tableName(false) {}
    bool tableName;
  } __isset;

  bool operator == (const Hbase_getColumnDescriptors_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    return true;
  }
  bool operator != (const Hbase_getColumnDescriptors_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getColumnDescriptors_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getColumnDescriptors_pargs {
 public:


  virtual ~Hbase_getColumnDescriptors_pargs() throw() {}

  const Text* tableName;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getColumnDescriptors_result {
 public:

  Hbase_getColumnDescriptors_result() {
  }

  virtual ~Hbase_getColumnDescriptors_result() throw() {}

  std::map<Text, ColumnDescriptor>  success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  bool operator == (const Hbase_getColumnDescriptors_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_getColumnDescriptors_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getColumnDescriptors_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getColumnDescriptors_presult {
 public:


  virtual ~Hbase_getColumnDescriptors_presult() throw() {}

  std::map<Text, ColumnDescriptor> * success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_getTableRegions_args {
 public:

  Hbase_getTableRegions_args() : tableName("") {
  }

  virtual ~Hbase_getTableRegions_args() throw() {}

  Text tableName;

  struct __isset {
    __isset() : tableName(false) {}
    bool tableName;
  } __isset;

  bool operator == (const Hbase_getTableRegions_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    return true;
  }
  bool operator != (const Hbase_getTableRegions_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getTableRegions_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getTableRegions_pargs {
 public:


  virtual ~Hbase_getTableRegions_pargs() throw() {}

  const Text* tableName;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getTableRegions_result {
 public:

  Hbase_getTableRegions_result() {
  }

  virtual ~Hbase_getTableRegions_result() throw() {}

  std::vector<TRegionInfo>  success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  bool operator == (const Hbase_getTableRegions_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_getTableRegions_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getTableRegions_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getTableRegions_presult {
 public:


  virtual ~Hbase_getTableRegions_presult() throw() {}

  std::vector<TRegionInfo> * success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_createTable_args {
 public:

  Hbase_createTable_args() : tableName("") {
  }

  virtual ~Hbase_createTable_args() throw() {}

  Text tableName;
  std::vector<ColumnDescriptor>  columnFamilies;

  struct __isset {
    __isset() : tableName(false), columnFamilies(false) {}
    bool tableName;
    bool columnFamilies;
  } __isset;

  bool operator == (const Hbase_createTable_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(columnFamilies == rhs.columnFamilies))
      return false;
    return true;
  }
  bool operator != (const Hbase_createTable_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_createTable_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_createTable_pargs {
 public:


  virtual ~Hbase_createTable_pargs() throw() {}

  const Text* tableName;
  const std::vector<ColumnDescriptor> * columnFamilies;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_createTable_result {
 public:

  Hbase_createTable_result() {
  }

  virtual ~Hbase_createTable_result() throw() {}

  IOError io;
  IllegalArgument ia;
  AlreadyExists exist;

  struct __isset {
    __isset() : io(false), ia(false), exist(false) {}
    bool io;
    bool ia;
    bool exist;
  } __isset;

  bool operator == (const Hbase_createTable_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    if (!(ia == rhs.ia))
      return false;
    if (!(exist == rhs.exist))
      return false;
    return true;
  }
  bool operator != (const Hbase_createTable_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_createTable_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_createTable_presult {
 public:


  virtual ~Hbase_createTable_presult() throw() {}

  IOError io;
  IllegalArgument ia;
  AlreadyExists exist;

  struct __isset {
    __isset() : io(false), ia(false), exist(false) {}
    bool io;
    bool ia;
    bool exist;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_deleteTable_args {
 public:

  Hbase_deleteTable_args() : tableName("") {
  }

  virtual ~Hbase_deleteTable_args() throw() {}

  Text tableName;

  struct __isset {
    __isset() : tableName(false) {}
    bool tableName;
  } __isset;

  bool operator == (const Hbase_deleteTable_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    return true;
  }
  bool operator != (const Hbase_deleteTable_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_deleteTable_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteTable_pargs {
 public:


  virtual ~Hbase_deleteTable_pargs() throw() {}

  const Text* tableName;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteTable_result {
 public:

  Hbase_deleteTable_result() {
  }

  virtual ~Hbase_deleteTable_result() throw() {}

  IOError io;
  NotFound nf;

  struct __isset {
    __isset() : io(false), nf(false) {}
    bool io;
    bool nf;
  } __isset;

  bool operator == (const Hbase_deleteTable_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    if (!(nf == rhs.nf))
      return false;
    return true;
  }
  bool operator != (const Hbase_deleteTable_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_deleteTable_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteTable_presult {
 public:


  virtual ~Hbase_deleteTable_presult() throw() {}

  IOError io;
  NotFound nf;

  struct __isset {
    __isset() : io(false), nf(false) {}
    bool io;
    bool nf;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_get_args {
 public:

  Hbase_get_args() : tableName(""), row(""), column("") {
  }

  virtual ~Hbase_get_args() throw() {}

  Text tableName;
  Text row;
  Text column;

  struct __isset {
    __isset() : tableName(false), row(false), column(false) {}
    bool tableName;
    bool row;
    bool column;
  } __isset;

  bool operator == (const Hbase_get_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(column == rhs.column))
      return false;
    return true;
  }
  bool operator != (const Hbase_get_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_get_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_get_pargs {
 public:


  virtual ~Hbase_get_pargs() throw() {}

  const Text* tableName;
  const Text* row;
  const Text* column;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_get_result {
 public:

  Hbase_get_result() {
  }

  virtual ~Hbase_get_result() throw() {}

  TCell success;
  IOError io;
  NotFound nf;

  struct __isset {
    __isset() : success(false), io(false), nf(false) {}
    bool success;
    bool io;
    bool nf;
  } __isset;

  bool operator == (const Hbase_get_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    if (!(nf == rhs.nf))
      return false;
    return true;
  }
  bool operator != (const Hbase_get_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_get_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_get_presult {
 public:


  virtual ~Hbase_get_presult() throw() {}

  TCell* success;
  IOError io;
  NotFound nf;

  struct __isset {
    __isset() : success(false), io(false), nf(false) {}
    bool success;
    bool io;
    bool nf;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_getVer_args {
 public:

  Hbase_getVer_args() : tableName(""), row(""), column(""), numVersions(0) {
  }

  virtual ~Hbase_getVer_args() throw() {}

  Text tableName;
  Text row;
  Text column;
  int32_t numVersions;

  struct __isset {
    __isset() : tableName(false), row(false), column(false), numVersions(false) {}
    bool tableName;
    bool row;
    bool column;
    bool numVersions;
  } __isset;

  bool operator == (const Hbase_getVer_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(column == rhs.column))
      return false;
    if (!(numVersions == rhs.numVersions))
      return false;
    return true;
  }
  bool operator != (const Hbase_getVer_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getVer_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getVer_pargs {
 public:


  virtual ~Hbase_getVer_pargs() throw() {}

  const Text* tableName;
  const Text* row;
  const Text* column;
  const int32_t* numVersions;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getVer_result {
 public:

  Hbase_getVer_result() {
  }

  virtual ~Hbase_getVer_result() throw() {}

  std::vector<TCell>  success;
  IOError io;
  NotFound nf;

  struct __isset {
    __isset() : success(false), io(false), nf(false) {}
    bool success;
    bool io;
    bool nf;
  } __isset;

  bool operator == (const Hbase_getVer_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    if (!(nf == rhs.nf))
      return false;
    return true;
  }
  bool operator != (const Hbase_getVer_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getVer_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getVer_presult {
 public:


  virtual ~Hbase_getVer_presult() throw() {}

  std::vector<TCell> * success;
  IOError io;
  NotFound nf;

  struct __isset {
    __isset() : success(false), io(false), nf(false) {}
    bool success;
    bool io;
    bool nf;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_getVerTs_args {
 public:

  Hbase_getVerTs_args() : tableName(""), row(""), column(""), timestamp(0), numVersions(0) {
  }

  virtual ~Hbase_getVerTs_args() throw() {}

  Text tableName;
  Text row;
  Text column;
  int64_t timestamp;
  int32_t numVersions;

  struct __isset {
    __isset() : tableName(false), row(false), column(false), timestamp(false), numVersions(false) {}
    bool tableName;
    bool row;
    bool column;
    bool timestamp;
    bool numVersions;
  } __isset;

  bool operator == (const Hbase_getVerTs_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(column == rhs.column))
      return false;
    if (!(timestamp == rhs.timestamp))
      return false;
    if (!(numVersions == rhs.numVersions))
      return false;
    return true;
  }
  bool operator != (const Hbase_getVerTs_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getVerTs_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getVerTs_pargs {
 public:


  virtual ~Hbase_getVerTs_pargs() throw() {}

  const Text* tableName;
  const Text* row;
  const Text* column;
  const int64_t* timestamp;
  const int32_t* numVersions;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getVerTs_result {
 public:

  Hbase_getVerTs_result() {
  }

  virtual ~Hbase_getVerTs_result() throw() {}

  std::vector<TCell>  success;
  IOError io;
  NotFound nf;

  struct __isset {
    __isset() : success(false), io(false), nf(false) {}
    bool success;
    bool io;
    bool nf;
  } __isset;

  bool operator == (const Hbase_getVerTs_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    if (!(nf == rhs.nf))
      return false;
    return true;
  }
  bool operator != (const Hbase_getVerTs_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getVerTs_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getVerTs_presult {
 public:


  virtual ~Hbase_getVerTs_presult() throw() {}

  std::vector<TCell> * success;
  IOError io;
  NotFound nf;

  struct __isset {
    __isset() : success(false), io(false), nf(false) {}
    bool success;
    bool io;
    bool nf;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_getRow_args {
 public:

  Hbase_getRow_args() : tableName(""), row("") {
  }

  virtual ~Hbase_getRow_args() throw() {}

  Text tableName;
  Text row;

  struct __isset {
    __isset() : tableName(false), row(false) {}
    bool tableName;
    bool row;
  } __isset;

  bool operator == (const Hbase_getRow_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(row == rhs.row))
      return false;
    return true;
  }
  bool operator != (const Hbase_getRow_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getRow_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getRow_pargs {
 public:


  virtual ~Hbase_getRow_pargs() throw() {}

  const Text* tableName;
  const Text* row;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getRow_result {
 public:

  Hbase_getRow_result() {
  }

  virtual ~Hbase_getRow_result() throw() {}

  TRowResult success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  bool operator == (const Hbase_getRow_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_getRow_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getRow_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getRow_presult {
 public:


  virtual ~Hbase_getRow_presult() throw() {}

  TRowResult* success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_getRowTs_args {
 public:

  Hbase_getRowTs_args() : tableName(""), row(""), timestamp(0) {
  }

  virtual ~Hbase_getRowTs_args() throw() {}

  Text tableName;
  Text row;
  int64_t timestamp;

  struct __isset {
    __isset() : tableName(false), row(false), timestamp(false) {}
    bool tableName;
    bool row;
    bool timestamp;
  } __isset;

  bool operator == (const Hbase_getRowTs_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(timestamp == rhs.timestamp))
      return false;
    return true;
  }
  bool operator != (const Hbase_getRowTs_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getRowTs_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getRowTs_pargs {
 public:


  virtual ~Hbase_getRowTs_pargs() throw() {}

  const Text* tableName;
  const Text* row;
  const int64_t* timestamp;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getRowTs_result {
 public:

  Hbase_getRowTs_result() {
  }

  virtual ~Hbase_getRowTs_result() throw() {}

  TRowResult success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  bool operator == (const Hbase_getRowTs_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_getRowTs_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_getRowTs_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_getRowTs_presult {
 public:


  virtual ~Hbase_getRowTs_presult() throw() {}

  TRowResult* success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_mutateRow_args {
 public:

  Hbase_mutateRow_args() : tableName(""), row("") {
  }

  virtual ~Hbase_mutateRow_args() throw() {}

  Text tableName;
  Text row;
  std::vector<Mutation>  mutations;

  struct __isset {
    __isset() : tableName(false), row(false), mutations(false) {}
    bool tableName;
    bool row;
    bool mutations;
  } __isset;

  bool operator == (const Hbase_mutateRow_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(mutations == rhs.mutations))
      return false;
    return true;
  }
  bool operator != (const Hbase_mutateRow_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_mutateRow_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRow_pargs {
 public:


  virtual ~Hbase_mutateRow_pargs() throw() {}

  const Text* tableName;
  const Text* row;
  const std::vector<Mutation> * mutations;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRow_result {
 public:

  Hbase_mutateRow_result() {
  }

  virtual ~Hbase_mutateRow_result() throw() {}

  IOError io;
  IllegalArgument ia;

  struct __isset {
    __isset() : io(false), ia(false) {}
    bool io;
    bool ia;
  } __isset;

  bool operator == (const Hbase_mutateRow_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    if (!(ia == rhs.ia))
      return false;
    return true;
  }
  bool operator != (const Hbase_mutateRow_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_mutateRow_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRow_presult {
 public:


  virtual ~Hbase_mutateRow_presult() throw() {}

  IOError io;
  IllegalArgument ia;

  struct __isset {
    __isset() : io(false), ia(false) {}
    bool io;
    bool ia;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_mutateRowTs_args {
 public:

  Hbase_mutateRowTs_args() : tableName(""), row(""), timestamp(0) {
  }

  virtual ~Hbase_mutateRowTs_args() throw() {}

  Text tableName;
  Text row;
  std::vector<Mutation>  mutations;
  int64_t timestamp;

  struct __isset {
    __isset() : tableName(false), row(false), mutations(false), timestamp(false) {}
    bool tableName;
    bool row;
    bool mutations;
    bool timestamp;
  } __isset;

  bool operator == (const Hbase_mutateRowTs_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(mutations == rhs.mutations))
      return false;
    if (!(timestamp == rhs.timestamp))
      return false;
    return true;
  }
  bool operator != (const Hbase_mutateRowTs_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_mutateRowTs_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRowTs_pargs {
 public:


  virtual ~Hbase_mutateRowTs_pargs() throw() {}

  const Text* tableName;
  const Text* row;
  const std::vector<Mutation> * mutations;
  const int64_t* timestamp;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRowTs_result {
 public:

  Hbase_mutateRowTs_result() {
  }

  virtual ~Hbase_mutateRowTs_result() throw() {}

  IOError io;
  IllegalArgument ia;

  struct __isset {
    __isset() : io(false), ia(false) {}
    bool io;
    bool ia;
  } __isset;

  bool operator == (const Hbase_mutateRowTs_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    if (!(ia == rhs.ia))
      return false;
    return true;
  }
  bool operator != (const Hbase_mutateRowTs_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_mutateRowTs_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRowTs_presult {
 public:


  virtual ~Hbase_mutateRowTs_presult() throw() {}

  IOError io;
  IllegalArgument ia;

  struct __isset {
    __isset() : io(false), ia(false) {}
    bool io;
    bool ia;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_mutateRows_args {
 public:

  Hbase_mutateRows_args() : tableName("") {
  }

  virtual ~Hbase_mutateRows_args() throw() {}

  Text tableName;
  std::vector<BatchMutation>  rowBatches;

  struct __isset {
    __isset() : tableName(false), rowBatches(false) {}
    bool tableName;
    bool rowBatches;
  } __isset;

  bool operator == (const Hbase_mutateRows_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(rowBatches == rhs.rowBatches))
      return false;
    return true;
  }
  bool operator != (const Hbase_mutateRows_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_mutateRows_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRows_pargs {
 public:


  virtual ~Hbase_mutateRows_pargs() throw() {}

  const Text* tableName;
  const std::vector<BatchMutation> * rowBatches;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRows_result {
 public:

  Hbase_mutateRows_result() {
  }

  virtual ~Hbase_mutateRows_result() throw() {}

  IOError io;
  IllegalArgument ia;

  struct __isset {
    __isset() : io(false), ia(false) {}
    bool io;
    bool ia;
  } __isset;

  bool operator == (const Hbase_mutateRows_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    if (!(ia == rhs.ia))
      return false;
    return true;
  }
  bool operator != (const Hbase_mutateRows_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_mutateRows_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRows_presult {
 public:


  virtual ~Hbase_mutateRows_presult() throw() {}

  IOError io;
  IllegalArgument ia;

  struct __isset {
    __isset() : io(false), ia(false) {}
    bool io;
    bool ia;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_mutateRowsTs_args {
 public:

  Hbase_mutateRowsTs_args() : tableName(""), timestamp(0) {
  }

  virtual ~Hbase_mutateRowsTs_args() throw() {}

  Text tableName;
  std::vector<BatchMutation>  rowBatches;
  int64_t timestamp;

  struct __isset {
    __isset() : tableName(false), rowBatches(false), timestamp(false) {}
    bool tableName;
    bool rowBatches;
    bool timestamp;
  } __isset;

  bool operator == (const Hbase_mutateRowsTs_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(rowBatches == rhs.rowBatches))
      return false;
    if (!(timestamp == rhs.timestamp))
      return false;
    return true;
  }
  bool operator != (const Hbase_mutateRowsTs_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_mutateRowsTs_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRowsTs_pargs {
 public:


  virtual ~Hbase_mutateRowsTs_pargs() throw() {}

  const Text* tableName;
  const std::vector<BatchMutation> * rowBatches;
  const int64_t* timestamp;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRowsTs_result {
 public:

  Hbase_mutateRowsTs_result() {
  }

  virtual ~Hbase_mutateRowsTs_result() throw() {}

  IOError io;
  IllegalArgument ia;

  struct __isset {
    __isset() : io(false), ia(false) {}
    bool io;
    bool ia;
  } __isset;

  bool operator == (const Hbase_mutateRowsTs_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    if (!(ia == rhs.ia))
      return false;
    return true;
  }
  bool operator != (const Hbase_mutateRowsTs_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_mutateRowsTs_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_mutateRowsTs_presult {
 public:


  virtual ~Hbase_mutateRowsTs_presult() throw() {}

  IOError io;
  IllegalArgument ia;

  struct __isset {
    __isset() : io(false), ia(false) {}
    bool io;
    bool ia;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_deleteAll_args {
 public:

  Hbase_deleteAll_args() : tableName(""), row(""), column("") {
  }

  virtual ~Hbase_deleteAll_args() throw() {}

  Text tableName;
  Text row;
  Text column;

  struct __isset {
    __isset() : tableName(false), row(false), column(false) {}
    bool tableName;
    bool row;
    bool column;
  } __isset;

  bool operator == (const Hbase_deleteAll_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(column == rhs.column))
      return false;
    return true;
  }
  bool operator != (const Hbase_deleteAll_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_deleteAll_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAll_pargs {
 public:


  virtual ~Hbase_deleteAll_pargs() throw() {}

  const Text* tableName;
  const Text* row;
  const Text* column;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAll_result {
 public:

  Hbase_deleteAll_result() {
  }

  virtual ~Hbase_deleteAll_result() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  bool operator == (const Hbase_deleteAll_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_deleteAll_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_deleteAll_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAll_presult {
 public:


  virtual ~Hbase_deleteAll_presult() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_deleteAllTs_args {
 public:

  Hbase_deleteAllTs_args() : tableName(""), row(""), column(""), timestamp(0) {
  }

  virtual ~Hbase_deleteAllTs_args() throw() {}

  Text tableName;
  Text row;
  Text column;
  int64_t timestamp;

  struct __isset {
    __isset() : tableName(false), row(false), column(false), timestamp(false) {}
    bool tableName;
    bool row;
    bool column;
    bool timestamp;
  } __isset;

  bool operator == (const Hbase_deleteAllTs_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(column == rhs.column))
      return false;
    if (!(timestamp == rhs.timestamp))
      return false;
    return true;
  }
  bool operator != (const Hbase_deleteAllTs_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_deleteAllTs_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAllTs_pargs {
 public:


  virtual ~Hbase_deleteAllTs_pargs() throw() {}

  const Text* tableName;
  const Text* row;
  const Text* column;
  const int64_t* timestamp;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAllTs_result {
 public:

  Hbase_deleteAllTs_result() {
  }

  virtual ~Hbase_deleteAllTs_result() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  bool operator == (const Hbase_deleteAllTs_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_deleteAllTs_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_deleteAllTs_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAllTs_presult {
 public:


  virtual ~Hbase_deleteAllTs_presult() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_deleteAllRow_args {
 public:

  Hbase_deleteAllRow_args() : tableName(""), row("") {
  }

  virtual ~Hbase_deleteAllRow_args() throw() {}

  Text tableName;
  Text row;

  struct __isset {
    __isset() : tableName(false), row(false) {}
    bool tableName;
    bool row;
  } __isset;

  bool operator == (const Hbase_deleteAllRow_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(row == rhs.row))
      return false;
    return true;
  }
  bool operator != (const Hbase_deleteAllRow_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_deleteAllRow_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAllRow_pargs {
 public:


  virtual ~Hbase_deleteAllRow_pargs() throw() {}

  const Text* tableName;
  const Text* row;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAllRow_result {
 public:

  Hbase_deleteAllRow_result() {
  }

  virtual ~Hbase_deleteAllRow_result() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  bool operator == (const Hbase_deleteAllRow_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_deleteAllRow_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_deleteAllRow_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAllRow_presult {
 public:


  virtual ~Hbase_deleteAllRow_presult() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_deleteAllRowTs_args {
 public:

  Hbase_deleteAllRowTs_args() : tableName(""), row(""), timestamp(0) {
  }

  virtual ~Hbase_deleteAllRowTs_args() throw() {}

  Text tableName;
  Text row;
  int64_t timestamp;

  struct __isset {
    __isset() : tableName(false), row(false), timestamp(false) {}
    bool tableName;
    bool row;
    bool timestamp;
  } __isset;

  bool operator == (const Hbase_deleteAllRowTs_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(timestamp == rhs.timestamp))
      return false;
    return true;
  }
  bool operator != (const Hbase_deleteAllRowTs_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_deleteAllRowTs_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAllRowTs_pargs {
 public:


  virtual ~Hbase_deleteAllRowTs_pargs() throw() {}

  const Text* tableName;
  const Text* row;
  const int64_t* timestamp;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAllRowTs_result {
 public:

  Hbase_deleteAllRowTs_result() {
  }

  virtual ~Hbase_deleteAllRowTs_result() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  bool operator == (const Hbase_deleteAllRowTs_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_deleteAllRowTs_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_deleteAllRowTs_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_deleteAllRowTs_presult {
 public:


  virtual ~Hbase_deleteAllRowTs_presult() throw() {}

  IOError io;

  struct __isset {
    __isset() : io(false) {}
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_scannerOpen_args {
 public:

  Hbase_scannerOpen_args() : tableName(""), startRow("") {
  }

  virtual ~Hbase_scannerOpen_args() throw() {}

  Text tableName;
  Text startRow;
  std::vector<Text>  columns;

  struct __isset {
    __isset() : tableName(false), startRow(false), columns(false) {}
    bool tableName;
    bool startRow;
    bool columns;
  } __isset;

  bool operator == (const Hbase_scannerOpen_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(startRow == rhs.startRow))
      return false;
    if (!(columns == rhs.columns))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerOpen_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerOpen_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpen_pargs {
 public:


  virtual ~Hbase_scannerOpen_pargs() throw() {}

  const Text* tableName;
  const Text* startRow;
  const std::vector<Text> * columns;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpen_result {
 public:

  Hbase_scannerOpen_result() : success(0) {
  }

  virtual ~Hbase_scannerOpen_result() throw() {}

  ScannerID success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  bool operator == (const Hbase_scannerOpen_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerOpen_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerOpen_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpen_presult {
 public:


  virtual ~Hbase_scannerOpen_presult() throw() {}

  ScannerID* success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_scannerOpenWithStop_args {
 public:

  Hbase_scannerOpenWithStop_args() : tableName(""), startRow(""), stopRow("") {
  }

  virtual ~Hbase_scannerOpenWithStop_args() throw() {}

  Text tableName;
  Text startRow;
  Text stopRow;
  std::vector<Text>  columns;

  struct __isset {
    __isset() : tableName(false), startRow(false), stopRow(false), columns(false) {}
    bool tableName;
    bool startRow;
    bool stopRow;
    bool columns;
  } __isset;

  bool operator == (const Hbase_scannerOpenWithStop_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(startRow == rhs.startRow))
      return false;
    if (!(stopRow == rhs.stopRow))
      return false;
    if (!(columns == rhs.columns))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerOpenWithStop_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerOpenWithStop_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpenWithStop_pargs {
 public:


  virtual ~Hbase_scannerOpenWithStop_pargs() throw() {}

  const Text* tableName;
  const Text* startRow;
  const Text* stopRow;
  const std::vector<Text> * columns;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpenWithStop_result {
 public:

  Hbase_scannerOpenWithStop_result() : success(0) {
  }

  virtual ~Hbase_scannerOpenWithStop_result() throw() {}

  ScannerID success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  bool operator == (const Hbase_scannerOpenWithStop_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerOpenWithStop_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerOpenWithStop_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpenWithStop_presult {
 public:


  virtual ~Hbase_scannerOpenWithStop_presult() throw() {}

  ScannerID* success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_scannerOpenTs_args {
 public:

  Hbase_scannerOpenTs_args() : tableName(""), startRow(""), timestamp(0) {
  }

  virtual ~Hbase_scannerOpenTs_args() throw() {}

  Text tableName;
  Text startRow;
  std::vector<Text>  columns;
  int64_t timestamp;

  struct __isset {
    __isset() : tableName(false), startRow(false), columns(false), timestamp(false) {}
    bool tableName;
    bool startRow;
    bool columns;
    bool timestamp;
  } __isset;

  bool operator == (const Hbase_scannerOpenTs_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(startRow == rhs.startRow))
      return false;
    if (!(columns == rhs.columns))
      return false;
    if (!(timestamp == rhs.timestamp))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerOpenTs_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerOpenTs_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpenTs_pargs {
 public:


  virtual ~Hbase_scannerOpenTs_pargs() throw() {}

  const Text* tableName;
  const Text* startRow;
  const std::vector<Text> * columns;
  const int64_t* timestamp;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpenTs_result {
 public:

  Hbase_scannerOpenTs_result() : success(0) {
  }

  virtual ~Hbase_scannerOpenTs_result() throw() {}

  ScannerID success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  bool operator == (const Hbase_scannerOpenTs_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerOpenTs_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerOpenTs_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpenTs_presult {
 public:


  virtual ~Hbase_scannerOpenTs_presult() throw() {}

  ScannerID* success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_scannerOpenWithStopTs_args {
 public:

  Hbase_scannerOpenWithStopTs_args() : tableName(""), startRow(""), stopRow(""), timestamp(0) {
  }

  virtual ~Hbase_scannerOpenWithStopTs_args() throw() {}

  Text tableName;
  Text startRow;
  Text stopRow;
  std::vector<Text>  columns;
  int64_t timestamp;

  struct __isset {
    __isset() : tableName(false), startRow(false), stopRow(false), columns(false), timestamp(false) {}
    bool tableName;
    bool startRow;
    bool stopRow;
    bool columns;
    bool timestamp;
  } __isset;

  bool operator == (const Hbase_scannerOpenWithStopTs_args & rhs) const
  {
    if (!(tableName == rhs.tableName))
      return false;
    if (!(startRow == rhs.startRow))
      return false;
    if (!(stopRow == rhs.stopRow))
      return false;
    if (!(columns == rhs.columns))
      return false;
    if (!(timestamp == rhs.timestamp))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerOpenWithStopTs_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerOpenWithStopTs_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpenWithStopTs_pargs {
 public:


  virtual ~Hbase_scannerOpenWithStopTs_pargs() throw() {}

  const Text* tableName;
  const Text* startRow;
  const Text* stopRow;
  const std::vector<Text> * columns;
  const int64_t* timestamp;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpenWithStopTs_result {
 public:

  Hbase_scannerOpenWithStopTs_result() : success(0) {
  }

  virtual ~Hbase_scannerOpenWithStopTs_result() throw() {}

  ScannerID success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  bool operator == (const Hbase_scannerOpenWithStopTs_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerOpenWithStopTs_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerOpenWithStopTs_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerOpenWithStopTs_presult {
 public:


  virtual ~Hbase_scannerOpenWithStopTs_presult() throw() {}

  ScannerID* success;
  IOError io;

  struct __isset {
    __isset() : success(false), io(false) {}
    bool success;
    bool io;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_scannerGet_args {
 public:

  Hbase_scannerGet_args() : id(0) {
  }

  virtual ~Hbase_scannerGet_args() throw() {}

  ScannerID id;

  struct __isset {
    __isset() : id(false) {}
    bool id;
  } __isset;

  bool operator == (const Hbase_scannerGet_args & rhs) const
  {
    if (!(id == rhs.id))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerGet_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerGet_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerGet_pargs {
 public:


  virtual ~Hbase_scannerGet_pargs() throw() {}

  const ScannerID* id;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerGet_result {
 public:

  Hbase_scannerGet_result() {
  }

  virtual ~Hbase_scannerGet_result() throw() {}

  TRowResult success;
  IOError io;
  IllegalArgument ia;
  NotFound nf;

  struct __isset {
    __isset() : success(false), io(false), ia(false), nf(false) {}
    bool success;
    bool io;
    bool ia;
    bool nf;
  } __isset;

  bool operator == (const Hbase_scannerGet_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(io == rhs.io))
      return false;
    if (!(ia == rhs.ia))
      return false;
    if (!(nf == rhs.nf))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerGet_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerGet_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerGet_presult {
 public:


  virtual ~Hbase_scannerGet_presult() throw() {}

  TRowResult* success;
  IOError io;
  IllegalArgument ia;
  NotFound nf;

  struct __isset {
    __isset() : success(false), io(false), ia(false), nf(false) {}
    bool success;
    bool io;
    bool ia;
    bool nf;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class Hbase_scannerClose_args {
 public:

  Hbase_scannerClose_args() : id(0) {
  }

  virtual ~Hbase_scannerClose_args() throw() {}

  ScannerID id;

  struct __isset {
    __isset() : id(false) {}
    bool id;
  } __isset;

  bool operator == (const Hbase_scannerClose_args & rhs) const
  {
    if (!(id == rhs.id))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerClose_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerClose_args & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerClose_pargs {
 public:


  virtual ~Hbase_scannerClose_pargs() throw() {}

  const ScannerID* id;

  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerClose_result {
 public:

  Hbase_scannerClose_result() {
  }

  virtual ~Hbase_scannerClose_result() throw() {}

  IOError io;
  IllegalArgument ia;

  struct __isset {
    __isset() : io(false), ia(false) {}
    bool io;
    bool ia;
  } __isset;

  bool operator == (const Hbase_scannerClose_result & rhs) const
  {
    if (!(io == rhs.io))
      return false;
    if (!(ia == rhs.ia))
      return false;
    return true;
  }
  bool operator != (const Hbase_scannerClose_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hbase_scannerClose_result & ) const;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);
  uint32_t write(facebook::thrift::protocol::TProtocol* oprot) const;

};

class Hbase_scannerClose_presult {
 public:


  virtual ~Hbase_scannerClose_presult() throw() {}

  IOError io;
  IllegalArgument ia;

  struct __isset {
    __isset() : io(false), ia(false) {}
    bool io;
    bool ia;
  } __isset;

  uint32_t read(facebook::thrift::protocol::TProtocol* iprot);

};

class HbaseClient : virtual public HbaseIf {
 public:
  HbaseClient(boost::shared_ptr<facebook::thrift::protocol::TProtocol> prot) :
    piprot_(prot),
    poprot_(prot) {
    iprot_ = prot.get();
    oprot_ = prot.get();
  }
  HbaseClient(boost::shared_ptr<facebook::thrift::protocol::TProtocol> iprot, boost::shared_ptr<facebook::thrift::protocol::TProtocol> oprot) :
    piprot_(iprot),
    poprot_(oprot) {
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
  boost::shared_ptr<facebook::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  boost::shared_ptr<facebook::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void enableTable(const Bytes& tableName);
  void send_enableTable(const Bytes& tableName);
  void recv_enableTable();
  void disableTable(const Bytes& tableName);
  void send_disableTable(const Bytes& tableName);
  void recv_disableTable();
  bool isTableEnabled(const Bytes& tableName);
  void send_isTableEnabled(const Bytes& tableName);
  bool recv_isTableEnabled();
  void getTableNames(std::vector<Text> & _return);
  void send_getTableNames();
  void recv_getTableNames(std::vector<Text> & _return);
  void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName);
  void send_getColumnDescriptors(const Text& tableName);
  void recv_getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return);
  void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName);
  void send_getTableRegions(const Text& tableName);
  void recv_getTableRegions(std::vector<TRegionInfo> & _return);
  void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies);
  void send_createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies);
  void recv_createTable();
  void deleteTable(const Text& tableName);
  void send_deleteTable(const Text& tableName);
  void recv_deleteTable();
  void get(TCell& _return, const Text& tableName, const Text& row, const Text& column);
  void send_get(const Text& tableName, const Text& row, const Text& column);
  void recv_get(TCell& _return);
  void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions);
  void send_getVer(const Text& tableName, const Text& row, const Text& column, const int32_t numVersions);
  void recv_getVer(std::vector<TCell> & _return);
  void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions);
  void send_getVerTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions);
  void recv_getVerTs(std::vector<TCell> & _return);
  void getRow(TRowResult& _return, const Text& tableName, const Text& row);
  void send_getRow(const Text& tableName, const Text& row);
  void recv_getRow(TRowResult& _return);
  void getRowTs(TRowResult& _return, const Text& tableName, const Text& row, const int64_t timestamp);
  void send_getRowTs(const Text& tableName, const Text& row, const int64_t timestamp);
  void recv_getRowTs(TRowResult& _return);
  void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations);
  void send_mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations);
  void recv_mutateRow();
  void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp);
  void send_mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp);
  void recv_mutateRowTs();
  void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches);
  void send_mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches);
  void recv_mutateRows();
  void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp);
  void send_mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp);
  void recv_mutateRowsTs();
  void deleteAll(const Text& tableName, const Text& row, const Text& column);
  void send_deleteAll(const Text& tableName, const Text& row, const Text& column);
  void recv_deleteAll();
  void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp);
  void send_deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp);
  void recv_deleteAllTs();
  void deleteAllRow(const Text& tableName, const Text& row);
  void send_deleteAllRow(const Text& tableName, const Text& row);
  void recv_deleteAllRow();
  void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp);
  void send_deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp);
  void recv_deleteAllRowTs();
  ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns);
  void send_scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns);
  ScannerID recv_scannerOpen();
  ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns);
  void send_scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns);
  ScannerID recv_scannerOpenWithStop();
  ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp);
  void send_scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp);
  ScannerID recv_scannerOpenTs();
  ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp);
  void send_scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp);
  ScannerID recv_scannerOpenWithStopTs();
  void scannerGet(TRowResult& _return, const ScannerID id);
  void send_scannerGet(const ScannerID id);
  void recv_scannerGet(TRowResult& _return);
  void scannerClose(const ScannerID id);
  void send_scannerClose(const ScannerID id);
  void recv_scannerClose();
 protected:
  boost::shared_ptr<facebook::thrift::protocol::TProtocol> piprot_;
  boost::shared_ptr<facebook::thrift::protocol::TProtocol> poprot_;
  facebook::thrift::protocol::TProtocol* iprot_;
  facebook::thrift::protocol::TProtocol* oprot_;
};

class HbaseProcessor : virtual public facebook::thrift::TProcessor {
 protected:
  boost::shared_ptr<HbaseIf> iface_;
  virtual bool process_fn(facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid);
 private:
  std::map<std::string, void (HbaseProcessor::*)(int32_t, facebook::thrift::protocol::TProtocol*, facebook::thrift::protocol::TProtocol*)> processMap_;
  void process_enableTable(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_disableTable(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_isTableEnabled(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_getTableNames(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_getColumnDescriptors(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_getTableRegions(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_createTable(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_deleteTable(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_get(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_getVer(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_getVerTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_getRow(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_getRowTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_mutateRow(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_mutateRowTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_mutateRows(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_mutateRowsTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_deleteAll(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_deleteAllTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_deleteAllRow(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_deleteAllRowTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_scannerOpen(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_scannerOpenWithStop(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_scannerOpenTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_scannerOpenWithStopTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_scannerGet(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
  void process_scannerClose(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot);
 public:
  HbaseProcessor(boost::shared_ptr<HbaseIf> iface) :
    iface_(iface) {
    processMap_["enableTable"] = &HbaseProcessor::process_enableTable;
    processMap_["disableTable"] = &HbaseProcessor::process_disableTable;
    processMap_["isTableEnabled"] = &HbaseProcessor::process_isTableEnabled;
    processMap_["getTableNames"] = &HbaseProcessor::process_getTableNames;
    processMap_["getColumnDescriptors"] = &HbaseProcessor::process_getColumnDescriptors;
    processMap_["getTableRegions"] = &HbaseProcessor::process_getTableRegions;
    processMap_["createTable"] = &HbaseProcessor::process_createTable;
    processMap_["deleteTable"] = &HbaseProcessor::process_deleteTable;
    processMap_["get"] = &HbaseProcessor::process_get;
    processMap_["getVer"] = &HbaseProcessor::process_getVer;
    processMap_["getVerTs"] = &HbaseProcessor::process_getVerTs;
    processMap_["getRow"] = &HbaseProcessor::process_getRow;
    processMap_["getRowTs"] = &HbaseProcessor::process_getRowTs;
    processMap_["mutateRow"] = &HbaseProcessor::process_mutateRow;
    processMap_["mutateRowTs"] = &HbaseProcessor::process_mutateRowTs;
    processMap_["mutateRows"] = &HbaseProcessor::process_mutateRows;
    processMap_["mutateRowsTs"] = &HbaseProcessor::process_mutateRowsTs;
    processMap_["deleteAll"] = &HbaseProcessor::process_deleteAll;
    processMap_["deleteAllTs"] = &HbaseProcessor::process_deleteAllTs;
    processMap_["deleteAllRow"] = &HbaseProcessor::process_deleteAllRow;
    processMap_["deleteAllRowTs"] = &HbaseProcessor::process_deleteAllRowTs;
    processMap_["scannerOpen"] = &HbaseProcessor::process_scannerOpen;
    processMap_["scannerOpenWithStop"] = &HbaseProcessor::process_scannerOpenWithStop;
    processMap_["scannerOpenTs"] = &HbaseProcessor::process_scannerOpenTs;
    processMap_["scannerOpenWithStopTs"] = &HbaseProcessor::process_scannerOpenWithStopTs;
    processMap_["scannerGet"] = &HbaseProcessor::process_scannerGet;
    processMap_["scannerClose"] = &HbaseProcessor::process_scannerClose;
  }

  virtual bool process(boost::shared_ptr<facebook::thrift::protocol::TProtocol> piprot, boost::shared_ptr<facebook::thrift::protocol::TProtocol> poprot);
  virtual ~HbaseProcessor() {}
};

class HbaseMultiface : virtual public HbaseIf {
 public:
  HbaseMultiface(std::vector<boost::shared_ptr<HbaseIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~HbaseMultiface() {}
 protected:
  std::vector<boost::shared_ptr<HbaseIf> > ifaces_;
  HbaseMultiface() {}
  void add(boost::shared_ptr<HbaseIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void enableTable(const Bytes& tableName) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->enableTable(tableName);
    }
  }

  void disableTable(const Bytes& tableName) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->disableTable(tableName);
    }
  }

  bool isTableEnabled(const Bytes& tableName) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        return ifaces_[i]->isTableEnabled(tableName);
      } else {
        ifaces_[i]->isTableEnabled(tableName);
      }
    }
  }

  void getTableNames(std::vector<Text> & _return) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->getTableNames(_return);
        return;
      } else {
        ifaces_[i]->getTableNames(_return);
      }
    }
  }

  void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->getColumnDescriptors(_return, tableName);
        return;
      } else {
        ifaces_[i]->getColumnDescriptors(_return, tableName);
      }
    }
  }

  void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->getTableRegions(_return, tableName);
        return;
      } else {
        ifaces_[i]->getTableRegions(_return, tableName);
      }
    }
  }

  void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->createTable(tableName, columnFamilies);
    }
  }

  void deleteTable(const Text& tableName) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->deleteTable(tableName);
    }
  }

  void get(TCell& _return, const Text& tableName, const Text& row, const Text& column) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->get(_return, tableName, row, column);
        return;
      } else {
        ifaces_[i]->get(_return, tableName, row, column);
      }
    }
  }

  void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->getVer(_return, tableName, row, column, numVersions);
        return;
      } else {
        ifaces_[i]->getVer(_return, tableName, row, column, numVersions);
      }
    }
  }

  void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->getVerTs(_return, tableName, row, column, timestamp, numVersions);
        return;
      } else {
        ifaces_[i]->getVerTs(_return, tableName, row, column, timestamp, numVersions);
      }
    }
  }

  void getRow(TRowResult& _return, const Text& tableName, const Text& row) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->getRow(_return, tableName, row);
        return;
      } else {
        ifaces_[i]->getRow(_return, tableName, row);
      }
    }
  }

  void getRowTs(TRowResult& _return, const Text& tableName, const Text& row, const int64_t timestamp) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->getRowTs(_return, tableName, row, timestamp);
        return;
      } else {
        ifaces_[i]->getRowTs(_return, tableName, row, timestamp);
      }
    }
  }

  void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->mutateRow(tableName, row, mutations);
    }
  }

  void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->mutateRowTs(tableName, row, mutations, timestamp);
    }
  }

  void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->mutateRows(tableName, rowBatches);
    }
  }

  void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->mutateRowsTs(tableName, rowBatches, timestamp);
    }
  }

  void deleteAll(const Text& tableName, const Text& row, const Text& column) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->deleteAll(tableName, row, column);
    }
  }

  void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->deleteAllTs(tableName, row, column, timestamp);
    }
  }

  void deleteAllRow(const Text& tableName, const Text& row) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->deleteAllRow(tableName, row);
    }
  }

  void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->deleteAllRowTs(tableName, row, timestamp);
    }
  }

  ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        return ifaces_[i]->scannerOpen(tableName, startRow, columns);
      } else {
        ifaces_[i]->scannerOpen(tableName, startRow, columns);
      }
    }
  }

  ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        return ifaces_[i]->scannerOpenWithStop(tableName, startRow, stopRow, columns);
      } else {
        ifaces_[i]->scannerOpenWithStop(tableName, startRow, stopRow, columns);
      }
    }
  }

  ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        return ifaces_[i]->scannerOpenTs(tableName, startRow, columns, timestamp);
      } else {
        ifaces_[i]->scannerOpenTs(tableName, startRow, columns, timestamp);
      }
    }
  }

  ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        return ifaces_[i]->scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp);
      } else {
        ifaces_[i]->scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp);
      }
    }
  }

  void scannerGet(TRowResult& _return, const ScannerID id) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->scannerGet(_return, id);
        return;
      } else {
        ifaces_[i]->scannerGet(_return, id);
      }
    }
  }

  void scannerClose(const ScannerID id) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->scannerClose(id);
    }
  }

};

}}}} // namespace

#endif