THBaseService.h

/**
 * Autogenerated by Thrift Compiler (0.10.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef THBaseService_H
#define THBaseService_H

#include <thrift/TDispatchProcessor.h>
#include <thrift/async/TConcurrentClientSyncInfo.h>
#include "hbase_types.h"

namespace apache { namespace hadoop { namespace hbase { namespace thrift2 {

#ifdef _WIN32
  #pragma warning( push )
  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
#endif

class THBaseServiceIf {
 public:
  virtual ~THBaseServiceIf() {}

  /**
   * Test for the existence of columns in the table, as specified in the TGet.
   * 
   * @return true if the specified TGet matches one or more keys, false if not
   * 
   * @param table the table to check on
   * 
   * @param tget the TGet to check for
   */
  virtual bool exists(const std::string& table, const TGet& tget) = 0;

  /**
   * Method for getting data from a row.
   * 
   * If the row cannot be found an empty Result is returned.
   * This can be checked by the empty field of the TResult
   * 
   * @return the result
   * 
   * @param table the table to get from
   * 
   * @param tget the TGet to fetch
   */
  virtual void get(TResult& _return, const std::string& table, const TGet& tget) = 0;

  /**
   * Method for getting multiple rows.
   * 
   * If a row cannot be found there will be a null
   * value in the result list for that TGet at the
   * same position.
   * 
   * So the Results are in the same order as the TGets.
   * 
   * @param table the table to get from
   * 
   * @param tgets a list of TGets to fetch, the Result list
   * will have the Results at corresponding positions
   * or null if there was an error
   */
  virtual void getMultiple(std::vector<TResult> & _return, const std::string& table, const std::vector<TGet> & tgets) = 0;

  /**
   * Commit a TPut to a table.
   * 
   * @param table the table to put data in
   * 
   * @param tput the TPut to put
   */
  virtual void put(const std::string& table, const TPut& tput) = 0;

  /**
   * Atomically checks if a row/family/qualifier value matches the expected
   * value. If it does, it adds the TPut.
   * 
   * @return true if the new put was executed, false otherwise
   * 
   * @param table to check in and put to
   * 
   * @param row row to check
   * 
   * @param family column family to check
   * 
   * @param qualifier column qualifier to check
   * 
   * @param value the expected value, if not provided the
   * check is for the non-existence of the
   * column in question
   * 
   * @param tput the TPut to put if the check succeeds
   */
  virtual bool checkAndPut(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TPut& tput) = 0;

  /**
   * Commit a List of Puts to the table.
   * 
   * @param table the table to put data in
   * 
   * @param tputs a list of TPuts to commit
   */
  virtual void putMultiple(const std::string& table, const std::vector<TPut> & tputs) = 0;

  /**
   * Deletes as specified by the TDelete.
   * 
   * Note: "delete" is a reserved keyword and cannot be used in Thrift
   * thus the inconsistent naming scheme from the other functions.
   * 
   * @param table the table to delete from
   * 
   * @param tdelete the TDelete to delete
   */
  virtual void deleteSingle(const std::string& table, const TDelete& tdelete) = 0;

  /**
   * Bulk commit a List of TDeletes to the table.
   * 
   * Throws a TIOError if any of the deletes fail.
   * 
   * Always returns an empty list for backwards compatibility.
   * 
   * @param table the table to delete from
   * 
   * @param tdeletes list of TDeletes to delete
   */
  virtual void deleteMultiple(std::vector<TDelete> & _return, const std::string& table, const std::vector<TDelete> & tdeletes) = 0;

  /**
   * Atomically checks if a row/family/qualifier value matches the expected
   * value. If it does, it adds the delete.
   * 
   * @return true if the new delete was executed, false otherwise
   * 
   * @param table to check in and delete from
   * 
   * @param row row to check
   * 
   * @param family column family to check
   * 
   * @param qualifier column qualifier to check
   * 
   * @param value the expected value, if not provided the
   * check is for the non-existence of the
   * column in question
   * 
   * @param tdelete the TDelete to execute if the check succeeds
   */
  virtual bool checkAndDelete(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TDelete& tdelete) = 0;
  virtual void increment(TResult& _return, const std::string& table, const TIncrement& tincrement) = 0;
  virtual void append(TResult& _return, const std::string& table, const TAppend& tappend) = 0;

  /**
   * Get a Scanner for the provided TScan object.
   * 
   * @return Scanner Id to be used with other scanner procedures
   * 
   * @param table the table to get the Scanner for
   * 
   * @param tscan the scan object to get a Scanner for
   */
  virtual int32_t openScanner(const std::string& table, const TScan& tscan) = 0;

  /**
   * Grabs multiple rows from a Scanner.
   * 
   * @return Between zero and numRows TResults
   * 
   * @param scannerId the Id of the Scanner to return rows from. This is an Id returned from the openScanner function.
   * 
   * @param numRows number of rows to return
   */
  virtual void getScannerRows(std::vector<TResult> & _return, const int32_t scannerId, const int32_t numRows) = 0;

  /**
   * Closes the scanner. Should be called to free server side resources timely.
   * Typically close once the scanner is not needed anymore, i.e. after looping
   * over it to get all the required rows.
   * 
   * @param scannerId the Id of the Scanner to close *
   */
  virtual void closeScanner(const int32_t scannerId) = 0;

  /**
   * mutateRow performs multiple mutations atomically on a single row.
   * 
   * @param table table to apply the mutations
   * 
   * @param trowMutations mutations to apply
   */
  virtual void mutateRow(const std::string& table, const TRowMutations& trowMutations) = 0;

  /**
   * Get results for the provided TScan object.
   * This helper function opens a scanner, get the results and close the scanner.
   * 
   * @return between zero and numRows TResults
   * 
   * @param table the table to get the Scanner for
   * 
   * @param tscan the scan object to get a Scanner for
   * 
   * @param numRows number of rows to return
   */
  virtual void getScannerResults(std::vector<TResult> & _return, const std::string& table, const TScan& tscan, const int32_t numRows) = 0;

  /**
   * Given a table and a row get the location of the region that
   * would contain the given row key.
   * 
   * reload = true means the cache will be cleared and the location
   * will be fetched from meta.
   * 
   * @param table
   * @param row
   * @param reload
   */
  virtual void getRegionLocation(THRegionLocation& _return, const std::string& table, const std::string& row, const bool reload) = 0;

  /**
   * Get all of the region locations for a given table.
   * 
   * 
   * @param table
   */
  virtual void getAllRegionLocations(std::vector<THRegionLocation> & _return, const std::string& table) = 0;

  /**
   * Atomically checks if a row/family/qualifier value matches the expected
   * value. If it does, it mutates the row.
   * 
   * @return true if the row was mutated, false otherwise
   * 
   * @param table to check in and delete from
   * 
   * @param row row to check
   * 
   * @param family column family to check
   * 
   * @param qualifier column qualifier to check
   * 
   * @param compareOp comparison to make on the value
   * 
   * @param value the expected value to be compared against, if not provided the
   * check is for the non-existence of the column in question
   * 
   * @param rowMutations row mutations to execute if the value matches
   */
  virtual bool checkAndMutate(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const TCompareOp::type compareOp, const std::string& value, const TRowMutations& rowMutations) = 0;
};

class THBaseServiceIfFactory {
 public:
  typedef THBaseServiceIf Handler;

  virtual ~THBaseServiceIfFactory() {}

  virtual THBaseServiceIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
  virtual void releaseHandler(THBaseServiceIf* /* handler */) = 0;
};

class THBaseServiceIfSingletonFactory : virtual public THBaseServiceIfFactory {
 public:
  THBaseServiceIfSingletonFactory(const boost::shared_ptr<THBaseServiceIf>& iface) : iface_(iface) {}
  virtual ~THBaseServiceIfSingletonFactory() {}

  virtual THBaseServiceIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
    return iface_.get();
  }
  virtual void releaseHandler(THBaseServiceIf* /* handler */) {}

 protected:
  boost::shared_ptr<THBaseServiceIf> iface_;
};

class THBaseServiceNull : virtual public THBaseServiceIf {
 public:
  virtual ~THBaseServiceNull() {}
  bool exists(const std::string& /* table */, const TGet& /* tget */) {
    bool _return = false;
    return _return;
  }
  void get(TResult& /* _return */, const std::string& /* table */, const TGet& /* tget */) {
    return;
  }
  void getMultiple(std::vector<TResult> & /* _return */, const std::string& /* table */, const std::vector<TGet> & /* tgets */) {
    return;
  }
  void put(const std::string& /* table */, const TPut& /* tput */) {
    return;
  }
  bool checkAndPut(const std::string& /* table */, const std::string& /* row */, const std::string& /* family */, const std::string& /* qualifier */, const std::string& /* value */, const TPut& /* tput */) {
    bool _return = false;
    return _return;
  }
  void putMultiple(const std::string& /* table */, const std::vector<TPut> & /* tputs */) {
    return;
  }
  void deleteSingle(const std::string& /* table */, const TDelete& /* tdelete */) {
    return;
  }
  void deleteMultiple(std::vector<TDelete> & /* _return */, const std::string& /* table */, const std::vector<TDelete> & /* tdeletes */) {
    return;
  }
  bool checkAndDelete(const std::string& /* table */, const std::string& /* row */, const std::string& /* family */, const std::string& /* qualifier */, const std::string& /* value */, const TDelete& /* tdelete */) {
    bool _return = false;
    return _return;
  }
  void increment(TResult& /* _return */, const std::string& /* table */, const TIncrement& /* tincrement */) {
    return;
  }
  void append(TResult& /* _return */, const std::string& /* table */, const TAppend& /* tappend */) {
    return;
  }
  int32_t openScanner(const std::string& /* table */, const TScan& /* tscan */) {
    int32_t _return = 0;
    return _return;
  }
  void getScannerRows(std::vector<TResult> & /* _return */, const int32_t /* scannerId */, const int32_t /* numRows */) {
    return;
  }
  void closeScanner(const int32_t /* scannerId */) {
    return;
  }
  void mutateRow(const std::string& /* table */, const TRowMutations& /* trowMutations */) {
    return;
  }
  void getScannerResults(std::vector<TResult> & /* _return */, const std::string& /* table */, const TScan& /* tscan */, const int32_t /* numRows */) {
    return;
  }
  void getRegionLocation(THRegionLocation& /* _return */, const std::string& /* table */, const std::string& /* row */, const bool /* reload */) {
    return;
  }
  void getAllRegionLocations(std::vector<THRegionLocation> & /* _return */, const std::string& /* table */) {
    return;
  }
  bool checkAndMutate(const std::string& /* table */, const std::string& /* row */, const std::string& /* family */, const std::string& /* qualifier */, const TCompareOp::type /* compareOp */, const std::string& /* value */, const TRowMutations& /* rowMutations */) {
    bool _return = false;
    return _return;
  }
};


class THBaseService_exists_args {
 public:

  THBaseService_exists_args(const THBaseService_exists_args&);
  THBaseService_exists_args& operator=(const THBaseService_exists_args&);
  THBaseService_exists_args() : table() {
  }

  virtual ~THBaseService_exists_args() throw();
  std::string table;
  TGet tget;

  void __set_table(const std::string& val);

  void __set_tget(const TGet& val);

  bool operator == (const THBaseService_exists_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(tget == rhs.tget))
      return false;
    return true;
  }
  bool operator != (const THBaseService_exists_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_exists_args & ) const;

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

};


class THBaseService_exists_pargs {
 public:


  virtual ~THBaseService_exists_pargs() throw();
  const std::string* table;
  const TGet* tget;

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

};

typedef struct _THBaseService_exists_result__isset {
  _THBaseService_exists_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_exists_result__isset;

class THBaseService_exists_result {
 public:

  THBaseService_exists_result(const THBaseService_exists_result&);
  THBaseService_exists_result& operator=(const THBaseService_exists_result&);
  THBaseService_exists_result() : success(0) {
  }

  virtual ~THBaseService_exists_result() throw();
  bool success;
  TIOError io;

  _THBaseService_exists_result__isset __isset;

  void __set_success(const bool val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_exists_result & ) const;

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

};

typedef struct _THBaseService_exists_presult__isset {
  _THBaseService_exists_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_exists_presult__isset;

class THBaseService_exists_presult {
 public:


  virtual ~THBaseService_exists_presult() throw();
  bool* success;
  TIOError io;

  _THBaseService_exists_presult__isset __isset;

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

};


class THBaseService_get_args {
 public:

  THBaseService_get_args(const THBaseService_get_args&);
  THBaseService_get_args& operator=(const THBaseService_get_args&);
  THBaseService_get_args() : table() {
  }

  virtual ~THBaseService_get_args() throw();
  std::string table;
  TGet tget;

  void __set_table(const std::string& val);

  void __set_tget(const TGet& val);

  bool operator == (const THBaseService_get_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(tget == rhs.tget))
      return false;
    return true;
  }
  bool operator != (const THBaseService_get_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_get_args & ) const;

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

};


class THBaseService_get_pargs {
 public:


  virtual ~THBaseService_get_pargs() throw();
  const std::string* table;
  const TGet* tget;

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

};

typedef struct _THBaseService_get_result__isset {
  _THBaseService_get_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_get_result__isset;

class THBaseService_get_result {
 public:

  THBaseService_get_result(const THBaseService_get_result&);
  THBaseService_get_result& operator=(const THBaseService_get_result&);
  THBaseService_get_result() {
  }

  virtual ~THBaseService_get_result() throw();
  TResult success;
  TIOError io;

  _THBaseService_get_result__isset __isset;

  void __set_success(const TResult& val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_get_result & ) const;

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

};

typedef struct _THBaseService_get_presult__isset {
  _THBaseService_get_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_get_presult__isset;

class THBaseService_get_presult {
 public:


  virtual ~THBaseService_get_presult() throw();
  TResult* success;
  TIOError io;

  _THBaseService_get_presult__isset __isset;

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

};


class THBaseService_getMultiple_args {
 public:

  THBaseService_getMultiple_args(const THBaseService_getMultiple_args&);
  THBaseService_getMultiple_args& operator=(const THBaseService_getMultiple_args&);
  THBaseService_getMultiple_args() : table() {
  }

  virtual ~THBaseService_getMultiple_args() throw();
  std::string table;
  std::vector<TGet>  tgets;

  void __set_table(const std::string& val);

  void __set_tgets(const std::vector<TGet> & val);

  bool operator == (const THBaseService_getMultiple_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(tgets == rhs.tgets))
      return false;
    return true;
  }
  bool operator != (const THBaseService_getMultiple_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_getMultiple_args & ) const;

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

};


class THBaseService_getMultiple_pargs {
 public:


  virtual ~THBaseService_getMultiple_pargs() throw();
  const std::string* table;
  const std::vector<TGet> * tgets;

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

};

typedef struct _THBaseService_getMultiple_result__isset {
  _THBaseService_getMultiple_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_getMultiple_result__isset;

class THBaseService_getMultiple_result {
 public:

  THBaseService_getMultiple_result(const THBaseService_getMultiple_result&);
  THBaseService_getMultiple_result& operator=(const THBaseService_getMultiple_result&);
  THBaseService_getMultiple_result() {
  }

  virtual ~THBaseService_getMultiple_result() throw();
  std::vector<TResult>  success;
  TIOError io;

  _THBaseService_getMultiple_result__isset __isset;

  void __set_success(const std::vector<TResult> & val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_getMultiple_result & ) const;

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

};

typedef struct _THBaseService_getMultiple_presult__isset {
  _THBaseService_getMultiple_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_getMultiple_presult__isset;

class THBaseService_getMultiple_presult {
 public:


  virtual ~THBaseService_getMultiple_presult() throw();
  std::vector<TResult> * success;
  TIOError io;

  _THBaseService_getMultiple_presult__isset __isset;

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

};


class THBaseService_put_args {
 public:

  THBaseService_put_args(const THBaseService_put_args&);
  THBaseService_put_args& operator=(const THBaseService_put_args&);
  THBaseService_put_args() : table() {
  }

  virtual ~THBaseService_put_args() throw();
  std::string table;
  TPut tput;

  void __set_table(const std::string& val);

  void __set_tput(const TPut& val);

  bool operator == (const THBaseService_put_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(tput == rhs.tput))
      return false;
    return true;
  }
  bool operator != (const THBaseService_put_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_put_args & ) const;

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

};


class THBaseService_put_pargs {
 public:


  virtual ~THBaseService_put_pargs() throw();
  const std::string* table;
  const TPut* tput;

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

};

typedef struct _THBaseService_put_result__isset {
  _THBaseService_put_result__isset() : io(false) {}
  bool io :1;
} _THBaseService_put_result__isset;

class THBaseService_put_result {
 public:

  THBaseService_put_result(const THBaseService_put_result&);
  THBaseService_put_result& operator=(const THBaseService_put_result&);
  THBaseService_put_result() {
  }

  virtual ~THBaseService_put_result() throw();
  TIOError io;

  _THBaseService_put_result__isset __isset;

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_put_result & ) const;

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

};

typedef struct _THBaseService_put_presult__isset {
  _THBaseService_put_presult__isset() : io(false) {}
  bool io :1;
} _THBaseService_put_presult__isset;

class THBaseService_put_presult {
 public:


  virtual ~THBaseService_put_presult() throw();
  TIOError io;

  _THBaseService_put_presult__isset __isset;

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

};

typedef struct _THBaseService_checkAndPut_args__isset {
  _THBaseService_checkAndPut_args__isset() : value(false) {}
  bool value :1;
} _THBaseService_checkAndPut_args__isset;

class THBaseService_checkAndPut_args {
 public:

  THBaseService_checkAndPut_args(const THBaseService_checkAndPut_args&);
  THBaseService_checkAndPut_args& operator=(const THBaseService_checkAndPut_args&);
  THBaseService_checkAndPut_args() : table(), row(), family(), qualifier(), value() {
  }

  virtual ~THBaseService_checkAndPut_args() throw();
  std::string table;
  std::string row;
  std::string family;
  std::string qualifier;
  std::string value;
  TPut tput;

  _THBaseService_checkAndPut_args__isset __isset;

  void __set_table(const std::string& val);

  void __set_row(const std::string& val);

  void __set_family(const std::string& val);

  void __set_qualifier(const std::string& val);

  void __set_value(const std::string& val);

  void __set_tput(const TPut& val);

  bool operator == (const THBaseService_checkAndPut_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(family == rhs.family))
      return false;
    if (!(qualifier == rhs.qualifier))
      return false;
    if (!(value == rhs.value))
      return false;
    if (!(tput == rhs.tput))
      return false;
    return true;
  }
  bool operator != (const THBaseService_checkAndPut_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_checkAndPut_args & ) const;

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

};


class THBaseService_checkAndPut_pargs {
 public:


  virtual ~THBaseService_checkAndPut_pargs() throw();
  const std::string* table;
  const std::string* row;
  const std::string* family;
  const std::string* qualifier;
  const std::string* value;
  const TPut* tput;

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

};

typedef struct _THBaseService_checkAndPut_result__isset {
  _THBaseService_checkAndPut_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_checkAndPut_result__isset;

class THBaseService_checkAndPut_result {
 public:

  THBaseService_checkAndPut_result(const THBaseService_checkAndPut_result&);
  THBaseService_checkAndPut_result& operator=(const THBaseService_checkAndPut_result&);
  THBaseService_checkAndPut_result() : success(0) {
  }

  virtual ~THBaseService_checkAndPut_result() throw();
  bool success;
  TIOError io;

  _THBaseService_checkAndPut_result__isset __isset;

  void __set_success(const bool val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_checkAndPut_result & ) const;

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

};

typedef struct _THBaseService_checkAndPut_presult__isset {
  _THBaseService_checkAndPut_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_checkAndPut_presult__isset;

class THBaseService_checkAndPut_presult {
 public:


  virtual ~THBaseService_checkAndPut_presult() throw();
  bool* success;
  TIOError io;

  _THBaseService_checkAndPut_presult__isset __isset;

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

};


class THBaseService_putMultiple_args {
 public:

  THBaseService_putMultiple_args(const THBaseService_putMultiple_args&);
  THBaseService_putMultiple_args& operator=(const THBaseService_putMultiple_args&);
  THBaseService_putMultiple_args() : table() {
  }

  virtual ~THBaseService_putMultiple_args() throw();
  std::string table;
  std::vector<TPut>  tputs;

  void __set_table(const std::string& val);

  void __set_tputs(const std::vector<TPut> & val);

  bool operator == (const THBaseService_putMultiple_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(tputs == rhs.tputs))
      return false;
    return true;
  }
  bool operator != (const THBaseService_putMultiple_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_putMultiple_args & ) const;

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

};


class THBaseService_putMultiple_pargs {
 public:


  virtual ~THBaseService_putMultiple_pargs() throw();
  const std::string* table;
  const std::vector<TPut> * tputs;

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

};

typedef struct _THBaseService_putMultiple_result__isset {
  _THBaseService_putMultiple_result__isset() : io(false) {}
  bool io :1;
} _THBaseService_putMultiple_result__isset;

class THBaseService_putMultiple_result {
 public:

  THBaseService_putMultiple_result(const THBaseService_putMultiple_result&);
  THBaseService_putMultiple_result& operator=(const THBaseService_putMultiple_result&);
  THBaseService_putMultiple_result() {
  }

  virtual ~THBaseService_putMultiple_result() throw();
  TIOError io;

  _THBaseService_putMultiple_result__isset __isset;

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_putMultiple_result & ) const;

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

};

typedef struct _THBaseService_putMultiple_presult__isset {
  _THBaseService_putMultiple_presult__isset() : io(false) {}
  bool io :1;
} _THBaseService_putMultiple_presult__isset;

class THBaseService_putMultiple_presult {
 public:


  virtual ~THBaseService_putMultiple_presult() throw();
  TIOError io;

  _THBaseService_putMultiple_presult__isset __isset;

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

};


class THBaseService_deleteSingle_args {
 public:

  THBaseService_deleteSingle_args(const THBaseService_deleteSingle_args&);
  THBaseService_deleteSingle_args& operator=(const THBaseService_deleteSingle_args&);
  THBaseService_deleteSingle_args() : table() {
  }

  virtual ~THBaseService_deleteSingle_args() throw();
  std::string table;
  TDelete tdelete;

  void __set_table(const std::string& val);

  void __set_tdelete(const TDelete& val);

  bool operator == (const THBaseService_deleteSingle_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(tdelete == rhs.tdelete))
      return false;
    return true;
  }
  bool operator != (const THBaseService_deleteSingle_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_deleteSingle_args & ) const;

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

};


class THBaseService_deleteSingle_pargs {
 public:


  virtual ~THBaseService_deleteSingle_pargs() throw();
  const std::string* table;
  const TDelete* tdelete;

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

};

typedef struct _THBaseService_deleteSingle_result__isset {
  _THBaseService_deleteSingle_result__isset() : io(false) {}
  bool io :1;
} _THBaseService_deleteSingle_result__isset;

class THBaseService_deleteSingle_result {
 public:

  THBaseService_deleteSingle_result(const THBaseService_deleteSingle_result&);
  THBaseService_deleteSingle_result& operator=(const THBaseService_deleteSingle_result&);
  THBaseService_deleteSingle_result() {
  }

  virtual ~THBaseService_deleteSingle_result() throw();
  TIOError io;

  _THBaseService_deleteSingle_result__isset __isset;

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_deleteSingle_result & ) const;

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

};

typedef struct _THBaseService_deleteSingle_presult__isset {
  _THBaseService_deleteSingle_presult__isset() : io(false) {}
  bool io :1;
} _THBaseService_deleteSingle_presult__isset;

class THBaseService_deleteSingle_presult {
 public:


  virtual ~THBaseService_deleteSingle_presult() throw();
  TIOError io;

  _THBaseService_deleteSingle_presult__isset __isset;

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

};


class THBaseService_deleteMultiple_args {
 public:

  THBaseService_deleteMultiple_args(const THBaseService_deleteMultiple_args&);
  THBaseService_deleteMultiple_args& operator=(const THBaseService_deleteMultiple_args&);
  THBaseService_deleteMultiple_args() : table() {
  }

  virtual ~THBaseService_deleteMultiple_args() throw();
  std::string table;
  std::vector<TDelete>  tdeletes;

  void __set_table(const std::string& val);

  void __set_tdeletes(const std::vector<TDelete> & val);

  bool operator == (const THBaseService_deleteMultiple_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(tdeletes == rhs.tdeletes))
      return false;
    return true;
  }
  bool operator != (const THBaseService_deleteMultiple_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_deleteMultiple_args & ) const;

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

};


class THBaseService_deleteMultiple_pargs {
 public:


  virtual ~THBaseService_deleteMultiple_pargs() throw();
  const std::string* table;
  const std::vector<TDelete> * tdeletes;

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

};

typedef struct _THBaseService_deleteMultiple_result__isset {
  _THBaseService_deleteMultiple_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_deleteMultiple_result__isset;

class THBaseService_deleteMultiple_result {
 public:

  THBaseService_deleteMultiple_result(const THBaseService_deleteMultiple_result&);
  THBaseService_deleteMultiple_result& operator=(const THBaseService_deleteMultiple_result&);
  THBaseService_deleteMultiple_result() {
  }

  virtual ~THBaseService_deleteMultiple_result() throw();
  std::vector<TDelete>  success;
  TIOError io;

  _THBaseService_deleteMultiple_result__isset __isset;

  void __set_success(const std::vector<TDelete> & val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_deleteMultiple_result & ) const;

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

};

typedef struct _THBaseService_deleteMultiple_presult__isset {
  _THBaseService_deleteMultiple_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_deleteMultiple_presult__isset;

class THBaseService_deleteMultiple_presult {
 public:


  virtual ~THBaseService_deleteMultiple_presult() throw();
  std::vector<TDelete> * success;
  TIOError io;

  _THBaseService_deleteMultiple_presult__isset __isset;

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

};

typedef struct _THBaseService_checkAndDelete_args__isset {
  _THBaseService_checkAndDelete_args__isset() : value(false) {}
  bool value :1;
} _THBaseService_checkAndDelete_args__isset;

class THBaseService_checkAndDelete_args {
 public:

  THBaseService_checkAndDelete_args(const THBaseService_checkAndDelete_args&);
  THBaseService_checkAndDelete_args& operator=(const THBaseService_checkAndDelete_args&);
  THBaseService_checkAndDelete_args() : table(), row(), family(), qualifier(), value() {
  }

  virtual ~THBaseService_checkAndDelete_args() throw();
  std::string table;
  std::string row;
  std::string family;
  std::string qualifier;
  std::string value;
  TDelete tdelete;

  _THBaseService_checkAndDelete_args__isset __isset;

  void __set_table(const std::string& val);

  void __set_row(const std::string& val);

  void __set_family(const std::string& val);

  void __set_qualifier(const std::string& val);

  void __set_value(const std::string& val);

  void __set_tdelete(const TDelete& val);

  bool operator == (const THBaseService_checkAndDelete_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(family == rhs.family))
      return false;
    if (!(qualifier == rhs.qualifier))
      return false;
    if (!(value == rhs.value))
      return false;
    if (!(tdelete == rhs.tdelete))
      return false;
    return true;
  }
  bool operator != (const THBaseService_checkAndDelete_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_checkAndDelete_args & ) const;

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

};


class THBaseService_checkAndDelete_pargs {
 public:


  virtual ~THBaseService_checkAndDelete_pargs() throw();
  const std::string* table;
  const std::string* row;
  const std::string* family;
  const std::string* qualifier;
  const std::string* value;
  const TDelete* tdelete;

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

};

typedef struct _THBaseService_checkAndDelete_result__isset {
  _THBaseService_checkAndDelete_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_checkAndDelete_result__isset;

class THBaseService_checkAndDelete_result {
 public:

  THBaseService_checkAndDelete_result(const THBaseService_checkAndDelete_result&);
  THBaseService_checkAndDelete_result& operator=(const THBaseService_checkAndDelete_result&);
  THBaseService_checkAndDelete_result() : success(0) {
  }

  virtual ~THBaseService_checkAndDelete_result() throw();
  bool success;
  TIOError io;

  _THBaseService_checkAndDelete_result__isset __isset;

  void __set_success(const bool val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_checkAndDelete_result & ) const;

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

};

typedef struct _THBaseService_checkAndDelete_presult__isset {
  _THBaseService_checkAndDelete_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_checkAndDelete_presult__isset;

class THBaseService_checkAndDelete_presult {
 public:


  virtual ~THBaseService_checkAndDelete_presult() throw();
  bool* success;
  TIOError io;

  _THBaseService_checkAndDelete_presult__isset __isset;

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

};


class THBaseService_increment_args {
 public:

  THBaseService_increment_args(const THBaseService_increment_args&);
  THBaseService_increment_args& operator=(const THBaseService_increment_args&);
  THBaseService_increment_args() : table() {
  }

  virtual ~THBaseService_increment_args() throw();
  std::string table;
  TIncrement tincrement;

  void __set_table(const std::string& val);

  void __set_tincrement(const TIncrement& val);

  bool operator == (const THBaseService_increment_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(tincrement == rhs.tincrement))
      return false;
    return true;
  }
  bool operator != (const THBaseService_increment_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_increment_args & ) const;

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

};


class THBaseService_increment_pargs {
 public:


  virtual ~THBaseService_increment_pargs() throw();
  const std::string* table;
  const TIncrement* tincrement;

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

};

typedef struct _THBaseService_increment_result__isset {
  _THBaseService_increment_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_increment_result__isset;

class THBaseService_increment_result {
 public:

  THBaseService_increment_result(const THBaseService_increment_result&);
  THBaseService_increment_result& operator=(const THBaseService_increment_result&);
  THBaseService_increment_result() {
  }

  virtual ~THBaseService_increment_result() throw();
  TResult success;
  TIOError io;

  _THBaseService_increment_result__isset __isset;

  void __set_success(const TResult& val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_increment_result & ) const;

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

};

typedef struct _THBaseService_increment_presult__isset {
  _THBaseService_increment_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_increment_presult__isset;

class THBaseService_increment_presult {
 public:


  virtual ~THBaseService_increment_presult() throw();
  TResult* success;
  TIOError io;

  _THBaseService_increment_presult__isset __isset;

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

};


class THBaseService_append_args {
 public:

  THBaseService_append_args(const THBaseService_append_args&);
  THBaseService_append_args& operator=(const THBaseService_append_args&);
  THBaseService_append_args() : table() {
  }

  virtual ~THBaseService_append_args() throw();
  std::string table;
  TAppend tappend;

  void __set_table(const std::string& val);

  void __set_tappend(const TAppend& val);

  bool operator == (const THBaseService_append_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(tappend == rhs.tappend))
      return false;
    return true;
  }
  bool operator != (const THBaseService_append_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_append_args & ) const;

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

};


class THBaseService_append_pargs {
 public:


  virtual ~THBaseService_append_pargs() throw();
  const std::string* table;
  const TAppend* tappend;

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

};

typedef struct _THBaseService_append_result__isset {
  _THBaseService_append_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_append_result__isset;

class THBaseService_append_result {
 public:

  THBaseService_append_result(const THBaseService_append_result&);
  THBaseService_append_result& operator=(const THBaseService_append_result&);
  THBaseService_append_result() {
  }

  virtual ~THBaseService_append_result() throw();
  TResult success;
  TIOError io;

  _THBaseService_append_result__isset __isset;

  void __set_success(const TResult& val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_append_result & ) const;

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

};

typedef struct _THBaseService_append_presult__isset {
  _THBaseService_append_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_append_presult__isset;

class THBaseService_append_presult {
 public:


  virtual ~THBaseService_append_presult() throw();
  TResult* success;
  TIOError io;

  _THBaseService_append_presult__isset __isset;

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

};


class THBaseService_openScanner_args {
 public:

  THBaseService_openScanner_args(const THBaseService_openScanner_args&);
  THBaseService_openScanner_args& operator=(const THBaseService_openScanner_args&);
  THBaseService_openScanner_args() : table() {
  }

  virtual ~THBaseService_openScanner_args() throw();
  std::string table;
  TScan tscan;

  void __set_table(const std::string& val);

  void __set_tscan(const TScan& val);

  bool operator == (const THBaseService_openScanner_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(tscan == rhs.tscan))
      return false;
    return true;
  }
  bool operator != (const THBaseService_openScanner_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_openScanner_args & ) const;

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

};


class THBaseService_openScanner_pargs {
 public:


  virtual ~THBaseService_openScanner_pargs() throw();
  const std::string* table;
  const TScan* tscan;

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

};

typedef struct _THBaseService_openScanner_result__isset {
  _THBaseService_openScanner_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_openScanner_result__isset;

class THBaseService_openScanner_result {
 public:

  THBaseService_openScanner_result(const THBaseService_openScanner_result&);
  THBaseService_openScanner_result& operator=(const THBaseService_openScanner_result&);
  THBaseService_openScanner_result() : success(0) {
  }

  virtual ~THBaseService_openScanner_result() throw();
  int32_t success;
  TIOError io;

  _THBaseService_openScanner_result__isset __isset;

  void __set_success(const int32_t val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_openScanner_result & ) const;

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

};

typedef struct _THBaseService_openScanner_presult__isset {
  _THBaseService_openScanner_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_openScanner_presult__isset;

class THBaseService_openScanner_presult {
 public:


  virtual ~THBaseService_openScanner_presult() throw();
  int32_t* success;
  TIOError io;

  _THBaseService_openScanner_presult__isset __isset;

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

};

typedef struct _THBaseService_getScannerRows_args__isset {
  _THBaseService_getScannerRows_args__isset() : numRows(true) {}
  bool numRows :1;
} _THBaseService_getScannerRows_args__isset;

class THBaseService_getScannerRows_args {
 public:

  THBaseService_getScannerRows_args(const THBaseService_getScannerRows_args&);
  THBaseService_getScannerRows_args& operator=(const THBaseService_getScannerRows_args&);
  THBaseService_getScannerRows_args() : scannerId(0), numRows(1) {
  }

  virtual ~THBaseService_getScannerRows_args() throw();
  int32_t scannerId;
  int32_t numRows;

  _THBaseService_getScannerRows_args__isset __isset;

  void __set_scannerId(const int32_t val);

  void __set_numRows(const int32_t val);

  bool operator == (const THBaseService_getScannerRows_args & rhs) const
  {
    if (!(scannerId == rhs.scannerId))
      return false;
    if (!(numRows == rhs.numRows))
      return false;
    return true;
  }
  bool operator != (const THBaseService_getScannerRows_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_getScannerRows_args & ) const;

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

};


class THBaseService_getScannerRows_pargs {
 public:


  virtual ~THBaseService_getScannerRows_pargs() throw();
  const int32_t* scannerId;
  const int32_t* numRows;

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

};

typedef struct _THBaseService_getScannerRows_result__isset {
  _THBaseService_getScannerRows_result__isset() : success(false), io(false), ia(false) {}
  bool success :1;
  bool io :1;
  bool ia :1;
} _THBaseService_getScannerRows_result__isset;

class THBaseService_getScannerRows_result {
 public:

  THBaseService_getScannerRows_result(const THBaseService_getScannerRows_result&);
  THBaseService_getScannerRows_result& operator=(const THBaseService_getScannerRows_result&);
  THBaseService_getScannerRows_result() {
  }

  virtual ~THBaseService_getScannerRows_result() throw();
  std::vector<TResult>  success;
  TIOError io;
  TIllegalArgument ia;

  _THBaseService_getScannerRows_result__isset __isset;

  void __set_success(const std::vector<TResult> & val);

  void __set_io(const TIOError& val);

  void __set_ia(const TIllegalArgument& val);

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

  bool operator < (const THBaseService_getScannerRows_result & ) const;

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

};

typedef struct _THBaseService_getScannerRows_presult__isset {
  _THBaseService_getScannerRows_presult__isset() : success(false), io(false), ia(false) {}
  bool success :1;
  bool io :1;
  bool ia :1;
} _THBaseService_getScannerRows_presult__isset;

class THBaseService_getScannerRows_presult {
 public:


  virtual ~THBaseService_getScannerRows_presult() throw();
  std::vector<TResult> * success;
  TIOError io;
  TIllegalArgument ia;

  _THBaseService_getScannerRows_presult__isset __isset;

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

};


class THBaseService_closeScanner_args {
 public:

  THBaseService_closeScanner_args(const THBaseService_closeScanner_args&);
  THBaseService_closeScanner_args& operator=(const THBaseService_closeScanner_args&);
  THBaseService_closeScanner_args() : scannerId(0) {
  }

  virtual ~THBaseService_closeScanner_args() throw();
  int32_t scannerId;

  void __set_scannerId(const int32_t val);

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

  bool operator < (const THBaseService_closeScanner_args & ) const;

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

};


class THBaseService_closeScanner_pargs {
 public:


  virtual ~THBaseService_closeScanner_pargs() throw();
  const int32_t* scannerId;

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

};

typedef struct _THBaseService_closeScanner_result__isset {
  _THBaseService_closeScanner_result__isset() : io(false), ia(false) {}
  bool io :1;
  bool ia :1;
} _THBaseService_closeScanner_result__isset;

class THBaseService_closeScanner_result {
 public:

  THBaseService_closeScanner_result(const THBaseService_closeScanner_result&);
  THBaseService_closeScanner_result& operator=(const THBaseService_closeScanner_result&);
  THBaseService_closeScanner_result() {
  }

  virtual ~THBaseService_closeScanner_result() throw();
  TIOError io;
  TIllegalArgument ia;

  _THBaseService_closeScanner_result__isset __isset;

  void __set_io(const TIOError& val);

  void __set_ia(const TIllegalArgument& val);

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

  bool operator < (const THBaseService_closeScanner_result & ) const;

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

};

typedef struct _THBaseService_closeScanner_presult__isset {
  _THBaseService_closeScanner_presult__isset() : io(false), ia(false) {}
  bool io :1;
  bool ia :1;
} _THBaseService_closeScanner_presult__isset;

class THBaseService_closeScanner_presult {
 public:


  virtual ~THBaseService_closeScanner_presult() throw();
  TIOError io;
  TIllegalArgument ia;

  _THBaseService_closeScanner_presult__isset __isset;

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

};


class THBaseService_mutateRow_args {
 public:

  THBaseService_mutateRow_args(const THBaseService_mutateRow_args&);
  THBaseService_mutateRow_args& operator=(const THBaseService_mutateRow_args&);
  THBaseService_mutateRow_args() : table() {
  }

  virtual ~THBaseService_mutateRow_args() throw();
  std::string table;
  TRowMutations trowMutations;

  void __set_table(const std::string& val);

  void __set_trowMutations(const TRowMutations& val);

  bool operator == (const THBaseService_mutateRow_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(trowMutations == rhs.trowMutations))
      return false;
    return true;
  }
  bool operator != (const THBaseService_mutateRow_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_mutateRow_args & ) const;

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

};


class THBaseService_mutateRow_pargs {
 public:


  virtual ~THBaseService_mutateRow_pargs() throw();
  const std::string* table;
  const TRowMutations* trowMutations;

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

};

typedef struct _THBaseService_mutateRow_result__isset {
  _THBaseService_mutateRow_result__isset() : io(false) {}
  bool io :1;
} _THBaseService_mutateRow_result__isset;

class THBaseService_mutateRow_result {
 public:

  THBaseService_mutateRow_result(const THBaseService_mutateRow_result&);
  THBaseService_mutateRow_result& operator=(const THBaseService_mutateRow_result&);
  THBaseService_mutateRow_result() {
  }

  virtual ~THBaseService_mutateRow_result() throw();
  TIOError io;

  _THBaseService_mutateRow_result__isset __isset;

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_mutateRow_result & ) const;

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

};

typedef struct _THBaseService_mutateRow_presult__isset {
  _THBaseService_mutateRow_presult__isset() : io(false) {}
  bool io :1;
} _THBaseService_mutateRow_presult__isset;

class THBaseService_mutateRow_presult {
 public:


  virtual ~THBaseService_mutateRow_presult() throw();
  TIOError io;

  _THBaseService_mutateRow_presult__isset __isset;

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

};

typedef struct _THBaseService_getScannerResults_args__isset {
  _THBaseService_getScannerResults_args__isset() : numRows(true) {}
  bool numRows :1;
} _THBaseService_getScannerResults_args__isset;

class THBaseService_getScannerResults_args {
 public:

  THBaseService_getScannerResults_args(const THBaseService_getScannerResults_args&);
  THBaseService_getScannerResults_args& operator=(const THBaseService_getScannerResults_args&);
  THBaseService_getScannerResults_args() : table(), numRows(1) {
  }

  virtual ~THBaseService_getScannerResults_args() throw();
  std::string table;
  TScan tscan;
  int32_t numRows;

  _THBaseService_getScannerResults_args__isset __isset;

  void __set_table(const std::string& val);

  void __set_tscan(const TScan& val);

  void __set_numRows(const int32_t val);

  bool operator == (const THBaseService_getScannerResults_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(tscan == rhs.tscan))
      return false;
    if (!(numRows == rhs.numRows))
      return false;
    return true;
  }
  bool operator != (const THBaseService_getScannerResults_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_getScannerResults_args & ) const;

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

};


class THBaseService_getScannerResults_pargs {
 public:


  virtual ~THBaseService_getScannerResults_pargs() throw();
  const std::string* table;
  const TScan* tscan;
  const int32_t* numRows;

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

};

typedef struct _THBaseService_getScannerResults_result__isset {
  _THBaseService_getScannerResults_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_getScannerResults_result__isset;

class THBaseService_getScannerResults_result {
 public:

  THBaseService_getScannerResults_result(const THBaseService_getScannerResults_result&);
  THBaseService_getScannerResults_result& operator=(const THBaseService_getScannerResults_result&);
  THBaseService_getScannerResults_result() {
  }

  virtual ~THBaseService_getScannerResults_result() throw();
  std::vector<TResult>  success;
  TIOError io;

  _THBaseService_getScannerResults_result__isset __isset;

  void __set_success(const std::vector<TResult> & val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_getScannerResults_result & ) const;

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

};

typedef struct _THBaseService_getScannerResults_presult__isset {
  _THBaseService_getScannerResults_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_getScannerResults_presult__isset;

class THBaseService_getScannerResults_presult {
 public:


  virtual ~THBaseService_getScannerResults_presult() throw();
  std::vector<TResult> * success;
  TIOError io;

  _THBaseService_getScannerResults_presult__isset __isset;

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

};

typedef struct _THBaseService_getRegionLocation_args__isset {
  _THBaseService_getRegionLocation_args__isset() : reload(false) {}
  bool reload :1;
} _THBaseService_getRegionLocation_args__isset;

class THBaseService_getRegionLocation_args {
 public:

  THBaseService_getRegionLocation_args(const THBaseService_getRegionLocation_args&);
  THBaseService_getRegionLocation_args& operator=(const THBaseService_getRegionLocation_args&);
  THBaseService_getRegionLocation_args() : table(), row(), reload(0) {
  }

  virtual ~THBaseService_getRegionLocation_args() throw();
  std::string table;
  std::string row;
  bool reload;

  _THBaseService_getRegionLocation_args__isset __isset;

  void __set_table(const std::string& val);

  void __set_row(const std::string& val);

  void __set_reload(const bool val);

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

  bool operator < (const THBaseService_getRegionLocation_args & ) const;

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

};


class THBaseService_getRegionLocation_pargs {
 public:


  virtual ~THBaseService_getRegionLocation_pargs() throw();
  const std::string* table;
  const std::string* row;
  const bool* reload;

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

};

typedef struct _THBaseService_getRegionLocation_result__isset {
  _THBaseService_getRegionLocation_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_getRegionLocation_result__isset;

class THBaseService_getRegionLocation_result {
 public:

  THBaseService_getRegionLocation_result(const THBaseService_getRegionLocation_result&);
  THBaseService_getRegionLocation_result& operator=(const THBaseService_getRegionLocation_result&);
  THBaseService_getRegionLocation_result() {
  }

  virtual ~THBaseService_getRegionLocation_result() throw();
  THRegionLocation success;
  TIOError io;

  _THBaseService_getRegionLocation_result__isset __isset;

  void __set_success(const THRegionLocation& val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_getRegionLocation_result & ) const;

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

};

typedef struct _THBaseService_getRegionLocation_presult__isset {
  _THBaseService_getRegionLocation_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_getRegionLocation_presult__isset;

class THBaseService_getRegionLocation_presult {
 public:


  virtual ~THBaseService_getRegionLocation_presult() throw();
  THRegionLocation* success;
  TIOError io;

  _THBaseService_getRegionLocation_presult__isset __isset;

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

};


class THBaseService_getAllRegionLocations_args {
 public:

  THBaseService_getAllRegionLocations_args(const THBaseService_getAllRegionLocations_args&);
  THBaseService_getAllRegionLocations_args& operator=(const THBaseService_getAllRegionLocations_args&);
  THBaseService_getAllRegionLocations_args() : table() {
  }

  virtual ~THBaseService_getAllRegionLocations_args() throw();
  std::string table;

  void __set_table(const std::string& val);

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

  bool operator < (const THBaseService_getAllRegionLocations_args & ) const;

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

};


class THBaseService_getAllRegionLocations_pargs {
 public:


  virtual ~THBaseService_getAllRegionLocations_pargs() throw();
  const std::string* table;

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

};

typedef struct _THBaseService_getAllRegionLocations_result__isset {
  _THBaseService_getAllRegionLocations_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_getAllRegionLocations_result__isset;

class THBaseService_getAllRegionLocations_result {
 public:

  THBaseService_getAllRegionLocations_result(const THBaseService_getAllRegionLocations_result&);
  THBaseService_getAllRegionLocations_result& operator=(const THBaseService_getAllRegionLocations_result&);
  THBaseService_getAllRegionLocations_result() {
  }

  virtual ~THBaseService_getAllRegionLocations_result() throw();
  std::vector<THRegionLocation>  success;
  TIOError io;

  _THBaseService_getAllRegionLocations_result__isset __isset;

  void __set_success(const std::vector<THRegionLocation> & val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_getAllRegionLocations_result & ) const;

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

};

typedef struct _THBaseService_getAllRegionLocations_presult__isset {
  _THBaseService_getAllRegionLocations_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_getAllRegionLocations_presult__isset;

class THBaseService_getAllRegionLocations_presult {
 public:


  virtual ~THBaseService_getAllRegionLocations_presult() throw();
  std::vector<THRegionLocation> * success;
  TIOError io;

  _THBaseService_getAllRegionLocations_presult__isset __isset;

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

};

typedef struct _THBaseService_checkAndMutate_args__isset {
  _THBaseService_checkAndMutate_args__isset() : value(false) {}
  bool value :1;
} _THBaseService_checkAndMutate_args__isset;

class THBaseService_checkAndMutate_args {
 public:

  THBaseService_checkAndMutate_args(const THBaseService_checkAndMutate_args&);
  THBaseService_checkAndMutate_args& operator=(const THBaseService_checkAndMutate_args&);
  THBaseService_checkAndMutate_args() : table(), row(), family(), qualifier(), compareOp((TCompareOp::type)0), value() {
  }

  virtual ~THBaseService_checkAndMutate_args() throw();
  std::string table;
  std::string row;
  std::string family;
  std::string qualifier;
  TCompareOp::type compareOp;
  std::string value;
  TRowMutations rowMutations;

  _THBaseService_checkAndMutate_args__isset __isset;

  void __set_table(const std::string& val);

  void __set_row(const std::string& val);

  void __set_family(const std::string& val);

  void __set_qualifier(const std::string& val);

  void __set_compareOp(const TCompareOp::type val);

  void __set_value(const std::string& val);

  void __set_rowMutations(const TRowMutations& val);

  bool operator == (const THBaseService_checkAndMutate_args & rhs) const
  {
    if (!(table == rhs.table))
      return false;
    if (!(row == rhs.row))
      return false;
    if (!(family == rhs.family))
      return false;
    if (!(qualifier == rhs.qualifier))
      return false;
    if (!(compareOp == rhs.compareOp))
      return false;
    if (!(value == rhs.value))
      return false;
    if (!(rowMutations == rhs.rowMutations))
      return false;
    return true;
  }
  bool operator != (const THBaseService_checkAndMutate_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const THBaseService_checkAndMutate_args & ) const;

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

};


class THBaseService_checkAndMutate_pargs {
 public:


  virtual ~THBaseService_checkAndMutate_pargs() throw();
  const std::string* table;
  const std::string* row;
  const std::string* family;
  const std::string* qualifier;
  const TCompareOp::type* compareOp;
  const std::string* value;
  const TRowMutations* rowMutations;

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

};

typedef struct _THBaseService_checkAndMutate_result__isset {
  _THBaseService_checkAndMutate_result__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_checkAndMutate_result__isset;

class THBaseService_checkAndMutate_result {
 public:

  THBaseService_checkAndMutate_result(const THBaseService_checkAndMutate_result&);
  THBaseService_checkAndMutate_result& operator=(const THBaseService_checkAndMutate_result&);
  THBaseService_checkAndMutate_result() : success(0) {
  }

  virtual ~THBaseService_checkAndMutate_result() throw();
  bool success;
  TIOError io;

  _THBaseService_checkAndMutate_result__isset __isset;

  void __set_success(const bool val);

  void __set_io(const TIOError& val);

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

  bool operator < (const THBaseService_checkAndMutate_result & ) const;

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

};

typedef struct _THBaseService_checkAndMutate_presult__isset {
  _THBaseService_checkAndMutate_presult__isset() : success(false), io(false) {}
  bool success :1;
  bool io :1;
} _THBaseService_checkAndMutate_presult__isset;

class THBaseService_checkAndMutate_presult {
 public:


  virtual ~THBaseService_checkAndMutate_presult() throw();
  bool* success;
  TIOError io;

  _THBaseService_checkAndMutate_presult__isset __isset;

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

};

class THBaseServiceClient : virtual public THBaseServiceIf {
 public:
  THBaseServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot);
  }
  THBaseServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    setProtocol(iprot,oprot);
  }
 private:
  void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
  setProtocol(prot,prot);
  }
  void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  bool exists(const std::string& table, const TGet& tget);
  void send_exists(const std::string& table, const TGet& tget);
  bool recv_exists();
  void get(TResult& _return, const std::string& table, const TGet& tget);
  void send_get(const std::string& table, const TGet& tget);
  void recv_get(TResult& _return);
  void getMultiple(std::vector<TResult> & _return, const std::string& table, const std::vector<TGet> & tgets);
  void send_getMultiple(const std::string& table, const std::vector<TGet> & tgets);
  void recv_getMultiple(std::vector<TResult> & _return);
  void put(const std::string& table, const TPut& tput);
  void send_put(const std::string& table, const TPut& tput);
  void recv_put();
  bool checkAndPut(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TPut& tput);
  void send_checkAndPut(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TPut& tput);
  bool recv_checkAndPut();
  void putMultiple(const std::string& table, const std::vector<TPut> & tputs);
  void send_putMultiple(const std::string& table, const std::vector<TPut> & tputs);
  void recv_putMultiple();
  void deleteSingle(const std::string& table, const TDelete& tdelete);
  void send_deleteSingle(const std::string& table, const TDelete& tdelete);
  void recv_deleteSingle();
  void deleteMultiple(std::vector<TDelete> & _return, const std::string& table, const std::vector<TDelete> & tdeletes);
  void send_deleteMultiple(const std::string& table, const std::vector<TDelete> & tdeletes);
  void recv_deleteMultiple(std::vector<TDelete> & _return);
  bool checkAndDelete(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TDelete& tdelete);
  void send_checkAndDelete(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TDelete& tdelete);
  bool recv_checkAndDelete();
  void increment(TResult& _return, const std::string& table, const TIncrement& tincrement);
  void send_increment(const std::string& table, const TIncrement& tincrement);
  void recv_increment(TResult& _return);
  void append(TResult& _return, const std::string& table, const TAppend& tappend);
  void send_append(const std::string& table, const TAppend& tappend);
  void recv_append(TResult& _return);
  int32_t openScanner(const std::string& table, const TScan& tscan);
  void send_openScanner(const std::string& table, const TScan& tscan);
  int32_t recv_openScanner();
  void getScannerRows(std::vector<TResult> & _return, const int32_t scannerId, const int32_t numRows);
  void send_getScannerRows(const int32_t scannerId, const int32_t numRows);
  void recv_getScannerRows(std::vector<TResult> & _return);
  void closeScanner(const int32_t scannerId);
  void send_closeScanner(const int32_t scannerId);
  void recv_closeScanner();
  void mutateRow(const std::string& table, const TRowMutations& trowMutations);
  void send_mutateRow(const std::string& table, const TRowMutations& trowMutations);
  void recv_mutateRow();
  void getScannerResults(std::vector<TResult> & _return, const std::string& table, const TScan& tscan, const int32_t numRows);
  void send_getScannerResults(const std::string& table, const TScan& tscan, const int32_t numRows);
  void recv_getScannerResults(std::vector<TResult> & _return);
  void getRegionLocation(THRegionLocation& _return, const std::string& table, const std::string& row, const bool reload);
  void send_getRegionLocation(const std::string& table, const std::string& row, const bool reload);
  void recv_getRegionLocation(THRegionLocation& _return);
  void getAllRegionLocations(std::vector<THRegionLocation> & _return, const std::string& table);
  void send_getAllRegionLocations(const std::string& table);
  void recv_getAllRegionLocations(std::vector<THRegionLocation> & _return);
  bool checkAndMutate(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const TCompareOp::type compareOp, const std::string& value, const TRowMutations& rowMutations);
  void send_checkAndMutate(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const TCompareOp::type compareOp, const std::string& value, const TRowMutations& rowMutations);
  bool recv_checkAndMutate();
 protected:
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
};

class THBaseServiceProcessor : public ::apache::thrift::TDispatchProcessor {
 protected:
  boost::shared_ptr<THBaseServiceIf> iface_;
  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
 private:
  typedef  void (THBaseServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
  typedef std::map<std::string, ProcessFunction> ProcessMap;
  ProcessMap processMap_;
  void process_exists(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getMultiple(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_put(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_checkAndPut(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_putMultiple(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_deleteSingle(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_deleteMultiple(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_checkAndDelete(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_increment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_append(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_openScanner(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getScannerRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_closeScanner(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_mutateRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getScannerResults(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getRegionLocation(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getAllRegionLocations(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_checkAndMutate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
 public:
  THBaseServiceProcessor(boost::shared_ptr<THBaseServiceIf> iface) :
    iface_(iface) {
    processMap_["exists"] = &THBaseServiceProcessor::process_exists;
    processMap_["get"] = &THBaseServiceProcessor::process_get;
    processMap_["getMultiple"] = &THBaseServiceProcessor::process_getMultiple;
    processMap_["put"] = &THBaseServiceProcessor::process_put;
    processMap_["checkAndPut"] = &THBaseServiceProcessor::process_checkAndPut;
    processMap_["putMultiple"] = &THBaseServiceProcessor::process_putMultiple;
    processMap_["deleteSingle"] = &THBaseServiceProcessor::process_deleteSingle;
    processMap_["deleteMultiple"] = &THBaseServiceProcessor::process_deleteMultiple;
    processMap_["checkAndDelete"] = &THBaseServiceProcessor::process_checkAndDelete;
    processMap_["increment"] = &THBaseServiceProcessor::process_increment;
    processMap_["append"] = &THBaseServiceProcessor::process_append;
    processMap_["openScanner"] = &THBaseServiceProcessor::process_openScanner;
    processMap_["getScannerRows"] = &THBaseServiceProcessor::process_getScannerRows;
    processMap_["closeScanner"] = &THBaseServiceProcessor::process_closeScanner;
    processMap_["mutateRow"] = &THBaseServiceProcessor::process_mutateRow;
    processMap_["getScannerResults"] = &THBaseServiceProcessor::process_getScannerResults;
    processMap_["getRegionLocation"] = &THBaseServiceProcessor::process_getRegionLocation;
    processMap_["getAllRegionLocations"] = &THBaseServiceProcessor::process_getAllRegionLocations;
    processMap_["checkAndMutate"] = &THBaseServiceProcessor::process_checkAndMutate;
  }

  virtual ~THBaseServiceProcessor() {}
};

class THBaseServiceProcessorFactory : public ::apache::thrift::TProcessorFactory {
 public:
  THBaseServiceProcessorFactory(const ::boost::shared_ptr< THBaseServiceIfFactory >& handlerFactory) :
      handlerFactory_(handlerFactory) {}

  ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);

 protected:
  ::boost::shared_ptr< THBaseServiceIfFactory > handlerFactory_;
};

class THBaseServiceMultiface : virtual public THBaseServiceIf {
 public:
  THBaseServiceMultiface(std::vector<boost::shared_ptr<THBaseServiceIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~THBaseServiceMultiface() {}
 protected:
  std::vector<boost::shared_ptr<THBaseServiceIf> > ifaces_;
  THBaseServiceMultiface() {}
  void add(boost::shared_ptr<THBaseServiceIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  bool exists(const std::string& table, const TGet& tget) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->exists(table, tget);
    }
    return ifaces_[i]->exists(table, tget);
  }

  void get(TResult& _return, const std::string& table, const TGet& tget) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get(_return, table, tget);
    }
    ifaces_[i]->get(_return, table, tget);
    return;
  }

  void getMultiple(std::vector<TResult> & _return, const std::string& table, const std::vector<TGet> & tgets) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getMultiple(_return, table, tgets);
    }
    ifaces_[i]->getMultiple(_return, table, tgets);
    return;
  }

  void put(const std::string& table, const TPut& tput) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->put(table, tput);
    }
    ifaces_[i]->put(table, tput);
  }

  bool checkAndPut(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TPut& tput) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->checkAndPut(table, row, family, qualifier, value, tput);
    }
    return ifaces_[i]->checkAndPut(table, row, family, qualifier, value, tput);
  }

  void putMultiple(const std::string& table, const std::vector<TPut> & tputs) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->putMultiple(table, tputs);
    }
    ifaces_[i]->putMultiple(table, tputs);
  }

  void deleteSingle(const std::string& table, const TDelete& tdelete) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->deleteSingle(table, tdelete);
    }
    ifaces_[i]->deleteSingle(table, tdelete);
  }

  void deleteMultiple(std::vector<TDelete> & _return, const std::string& table, const std::vector<TDelete> & tdeletes) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->deleteMultiple(_return, table, tdeletes);
    }
    ifaces_[i]->deleteMultiple(_return, table, tdeletes);
    return;
  }

  bool checkAndDelete(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TDelete& tdelete) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->checkAndDelete(table, row, family, qualifier, value, tdelete);
    }
    return ifaces_[i]->checkAndDelete(table, row, family, qualifier, value, tdelete);
  }

  void increment(TResult& _return, const std::string& table, const TIncrement& tincrement) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->increment(_return, table, tincrement);
    }
    ifaces_[i]->increment(_return, table, tincrement);
    return;
  }

  void append(TResult& _return, const std::string& table, const TAppend& tappend) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->append(_return, table, tappend);
    }
    ifaces_[i]->append(_return, table, tappend);
    return;
  }

  int32_t openScanner(const std::string& table, const TScan& tscan) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->openScanner(table, tscan);
    }
    return ifaces_[i]->openScanner(table, tscan);
  }

  void getScannerRows(std::vector<TResult> & _return, const int32_t scannerId, const int32_t numRows) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getScannerRows(_return, scannerId, numRows);
    }
    ifaces_[i]->getScannerRows(_return, scannerId, numRows);
    return;
  }

  void closeScanner(const int32_t scannerId) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->closeScanner(scannerId);
    }
    ifaces_[i]->closeScanner(scannerId);
  }

  void mutateRow(const std::string& table, const TRowMutations& trowMutations) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->mutateRow(table, trowMutations);
    }
    ifaces_[i]->mutateRow(table, trowMutations);
  }

  void getScannerResults(std::vector<TResult> & _return, const std::string& table, const TScan& tscan, const int32_t numRows) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getScannerResults(_return, table, tscan, numRows);
    }
    ifaces_[i]->getScannerResults(_return, table, tscan, numRows);
    return;
  }

  void getRegionLocation(THRegionLocation& _return, const std::string& table, const std::string& row, const bool reload) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getRegionLocation(_return, table, row, reload);
    }
    ifaces_[i]->getRegionLocation(_return, table, row, reload);
    return;
  }

  void getAllRegionLocations(std::vector<THRegionLocation> & _return, const std::string& table) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getAllRegionLocations(_return, table);
    }
    ifaces_[i]->getAllRegionLocations(_return, table);
    return;
  }

  bool checkAndMutate(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const TCompareOp::type compareOp, const std::string& value, const TRowMutations& rowMutations) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->checkAndMutate(table, row, family, qualifier, compareOp, value, rowMutations);
    }
    return ifaces_[i]->checkAndMutate(table, row, family, qualifier, compareOp, value, rowMutations);
  }

};

// The 'concurrent' client is a thread safe client that correctly handles
// out of order responses.  It is slower than the regular client, so should
// only be used when you need to share a connection among multiple threads
class THBaseServiceConcurrentClient : virtual public THBaseServiceIf {
 public:
  THBaseServiceConcurrentClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot);
  }
  THBaseServiceConcurrentClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    setProtocol(iprot,oprot);
  }
 private:
  void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
  setProtocol(prot,prot);
  }
  void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  bool exists(const std::string& table, const TGet& tget);
  int32_t send_exists(const std::string& table, const TGet& tget);
  bool recv_exists(const int32_t seqid);
  void get(TResult& _return, const std::string& table, const TGet& tget);
  int32_t send_get(const std::string& table, const TGet& tget);
  void recv_get(TResult& _return, const int32_t seqid);
  void getMultiple(std::vector<TResult> & _return, const std::string& table, const std::vector<TGet> & tgets);
  int32_t send_getMultiple(const std::string& table, const std::vector<TGet> & tgets);
  void recv_getMultiple(std::vector<TResult> & _return, const int32_t seqid);
  void put(const std::string& table, const TPut& tput);
  int32_t send_put(const std::string& table, const TPut& tput);
  void recv_put(const int32_t seqid);
  bool checkAndPut(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TPut& tput);
  int32_t send_checkAndPut(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TPut& tput);
  bool recv_checkAndPut(const int32_t seqid);
  void putMultiple(const std::string& table, const std::vector<TPut> & tputs);
  int32_t send_putMultiple(const std::string& table, const std::vector<TPut> & tputs);
  void recv_putMultiple(const int32_t seqid);
  void deleteSingle(const std::string& table, const TDelete& tdelete);
  int32_t send_deleteSingle(const std::string& table, const TDelete& tdelete);
  void recv_deleteSingle(const int32_t seqid);
  void deleteMultiple(std::vector<TDelete> & _return, const std::string& table, const std::vector<TDelete> & tdeletes);
  int32_t send_deleteMultiple(const std::string& table, const std::vector<TDelete> & tdeletes);
  void recv_deleteMultiple(std::vector<TDelete> & _return, const int32_t seqid);
  bool checkAndDelete(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TDelete& tdelete);
  int32_t send_checkAndDelete(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const std::string& value, const TDelete& tdelete);
  bool recv_checkAndDelete(const int32_t seqid);
  void increment(TResult& _return, const std::string& table, const TIncrement& tincrement);
  int32_t send_increment(const std::string& table, const TIncrement& tincrement);
  void recv_increment(TResult& _return, const int32_t seqid);
  void append(TResult& _return, const std::string& table, const TAppend& tappend);
  int32_t send_append(const std::string& table, const TAppend& tappend);
  void recv_append(TResult& _return, const int32_t seqid);
  int32_t openScanner(const std::string& table, const TScan& tscan);
  int32_t send_openScanner(const std::string& table, const TScan& tscan);
  int32_t recv_openScanner(const int32_t seqid);
  void getScannerRows(std::vector<TResult> & _return, const int32_t scannerId, const int32_t numRows);
  int32_t send_getScannerRows(const int32_t scannerId, const int32_t numRows);
  void recv_getScannerRows(std::vector<TResult> & _return, const int32_t seqid);
  void closeScanner(const int32_t scannerId);
  int32_t send_closeScanner(const int32_t scannerId);
  void recv_closeScanner(const int32_t seqid);
  void mutateRow(const std::string& table, const TRowMutations& trowMutations);
  int32_t send_mutateRow(const std::string& table, const TRowMutations& trowMutations);
  void recv_mutateRow(const int32_t seqid);
  void getScannerResults(std::vector<TResult> & _return, const std::string& table, const TScan& tscan, const int32_t numRows);
  int32_t send_getScannerResults(const std::string& table, const TScan& tscan, const int32_t numRows);
  void recv_getScannerResults(std::vector<TResult> & _return, const int32_t seqid);
  void getRegionLocation(THRegionLocation& _return, const std::string& table, const std::string& row, const bool reload);
  int32_t send_getRegionLocation(const std::string& table, const std::string& row, const bool reload);
  void recv_getRegionLocation(THRegionLocation& _return, const int32_t seqid);
  void getAllRegionLocations(std::vector<THRegionLocation> & _return, const std::string& table);
  int32_t send_getAllRegionLocations(const std::string& table);
  void recv_getAllRegionLocations(std::vector<THRegionLocation> & _return, const int32_t seqid);
  bool checkAndMutate(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const TCompareOp::type compareOp, const std::string& value, const TRowMutations& rowMutations);
  int32_t send_checkAndMutate(const std::string& table, const std::string& row, const std::string& family, const std::string& qualifier, const TCompareOp::type compareOp, const std::string& value, const TRowMutations& rowMutations);
  bool recv_checkAndMutate(const int32_t seqid);
 protected:
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
  ::apache::thrift::async::TConcurrentClientSyncInfo sync_;
};

#ifdef _WIN32
  #pragma warning( pop )
#endif

}}}} // namespace

#endif