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

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

namespace cloudata {

class ThriftCloudataServiceIf {
 public:
  virtual ~ThriftCloudataServiceIf() {}
  virtual void listTables(std::vector<ThriftTableSchema> & _return) = 0;
  virtual void put(const std::string& tableName, const ThriftRow& row, const bool useSystemTimestamp) = 0;
  virtual void removeRow(const std::string& tableName, const std::string& rowKey) = 0;
  virtual void removeRowWithTime(const std::string& tableName, const std::string& rowKey, const std::string& timestamp) = 0;
  virtual void remove(const std::string& tableName, const std::string& rowKey, const std::string& columnName, const std::string& cellKey) = 0;
  virtual bool hasValue(const std::string& tableName, const std::string& columnName, const std::string& rowKey) = 0;
  virtual void getValue(std::string& _return, const std::string& tableName, const std::string& rowKey, const std::string& columnName, const std::string& cellKey) = 0;
  virtual void get(ThriftRow& _return, const std::string& tableName, const std::string& rowKey) = 0;
  virtual void getColumnRow(ThriftRow& _return, const std::string& tableName, const std::string& rowKey, const std::vector<std::string> & columnNames) = 0;
  virtual void createTable(const ThriftTableSchema& tableSchema) = 0;
  virtual bool existsTable(const std::string& tableName) = 0;
  virtual void dropTable(const std::string& tableName) = 0;
  virtual void truncateTable(const std::string& tableName, const bool clearPartitionInfo) = 0;
  virtual void truncateColumn(const std::string& tableName, const std::string& columnName) = 0;
  virtual void descTable(ThriftTableSchema& _return, const std::string& tableName) = 0;
  virtual void addColumn(const std::string& tableName, const std::string& addedColumnName) = 0;
};

class ThriftCloudataServiceNull : virtual public ThriftCloudataServiceIf {
 public:
  virtual ~ThriftCloudataServiceNull() {}
  void listTables(std::vector<ThriftTableSchema> & /* _return */) {
    return;
  }
  void put(const std::string& /* tableName */, const ThriftRow& /* row */, const bool /* useSystemTimestamp */) {
    return;
  }
  void removeRow(const std::string& /* tableName */, const std::string& /* rowKey */) {
    return;
  }
  void removeRowWithTime(const std::string& /* tableName */, const std::string& /* rowKey */, const std::string& /* timestamp */) {
    return;
  }
  void remove(const std::string& /* tableName */, const std::string& /* rowKey */, const std::string& /* columnName */, const std::string& /* cellKey */) {
    return;
  }
  bool hasValue(const std::string& /* tableName */, const std::string& /* columnName */, const std::string& /* rowKey */) {
    bool _return = false;
    return _return;
  }
  void getValue(std::string& /* _return */, const std::string& /* tableName */, const std::string& /* rowKey */, const std::string& /* columnName */, const std::string& /* cellKey */) {
    return;
  }
  void get(ThriftRow& /* _return */, const std::string& /* tableName */, const std::string& /* rowKey */) {
    return;
  }
  void getColumnRow(ThriftRow& /* _return */, const std::string& /* tableName */, const std::string& /* rowKey */, const std::vector<std::string> & /* columnNames */) {
    return;
  }
  void createTable(const ThriftTableSchema& /* tableSchema */) {
    return;
  }
  bool existsTable(const std::string& /* tableName */) {
    bool _return = false;
    return _return;
  }
  void dropTable(const std::string& /* tableName */) {
    return;
  }
  void truncateTable(const std::string& /* tableName */, const bool /* clearPartitionInfo */) {
    return;
  }
  void truncateColumn(const std::string& /* tableName */, const std::string& /* columnName */) {
    return;
  }
  void descTable(ThriftTableSchema& /* _return */, const std::string& /* tableName */) {
    return;
  }
  void addColumn(const std::string& /* tableName */, const std::string& /* addedColumnName */) {
    return;
  }
};

class ThriftCloudataService_listTables_args {
 public:

  ThriftCloudataService_listTables_args() {
  }

  virtual ~ThriftCloudataService_listTables_args() throw() {}


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

  bool operator < (const ThriftCloudataService_listTables_args & ) const;

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

};

class ThriftCloudataService_listTables_pargs {
 public:


  virtual ~ThriftCloudataService_listTables_pargs() throw() {}


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

};

class ThriftCloudataService_listTables_result {
 public:

  ThriftCloudataService_listTables_result() {
  }

  virtual ~ThriftCloudataService_listTables_result() throw() {}

  std::vector<ThriftTableSchema>  success;
  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_listTables_result & ) const;

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

};

class ThriftCloudataService_listTables_presult {
 public:


  virtual ~ThriftCloudataService_listTables_presult() throw() {}

  std::vector<ThriftTableSchema> * success;
  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_put_args {
 public:

  ThriftCloudataService_put_args() : tableName(""), useSystemTimestamp(0) {
  }

  virtual ~ThriftCloudataService_put_args() throw() {}

  std::string tableName;
  ThriftRow row;
  bool useSystemTimestamp;

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

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

  bool operator < (const ThriftCloudataService_put_args & ) const;

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

};

class ThriftCloudataService_put_pargs {
 public:


  virtual ~ThriftCloudataService_put_pargs() throw() {}

  const std::string* tableName;
  const ThriftRow* row;
  const bool* useSystemTimestamp;

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

};

class ThriftCloudataService_put_result {
 public:

  ThriftCloudataService_put_result() {
  }

  virtual ~ThriftCloudataService_put_result() throw() {}

  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_put_result & ) const;

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

};

class ThriftCloudataService_put_presult {
 public:


  virtual ~ThriftCloudataService_put_presult() throw() {}

  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_removeRow_args {
 public:

  ThriftCloudataService_removeRow_args() : tableName(""), rowKey("") {
  }

  virtual ~ThriftCloudataService_removeRow_args() throw() {}

  std::string tableName;
  std::string rowKey;

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

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

  bool operator < (const ThriftCloudataService_removeRow_args & ) const;

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

};

class ThriftCloudataService_removeRow_pargs {
 public:


  virtual ~ThriftCloudataService_removeRow_pargs() throw() {}

  const std::string* tableName;
  const std::string* rowKey;

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

};

class ThriftCloudataService_removeRow_result {
 public:

  ThriftCloudataService_removeRow_result() {
  }

  virtual ~ThriftCloudataService_removeRow_result() throw() {}

  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_removeRow_result & ) const;

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

};

class ThriftCloudataService_removeRow_presult {
 public:


  virtual ~ThriftCloudataService_removeRow_presult() throw() {}

  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_removeRowWithTime_args {
 public:

  ThriftCloudataService_removeRowWithTime_args() : tableName(""), rowKey(""), timestamp("") {
  }

  virtual ~ThriftCloudataService_removeRowWithTime_args() throw() {}

  std::string tableName;
  std::string rowKey;
  std::string timestamp;

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

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

  bool operator < (const ThriftCloudataService_removeRowWithTime_args & ) const;

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

};

class ThriftCloudataService_removeRowWithTime_pargs {
 public:


  virtual ~ThriftCloudataService_removeRowWithTime_pargs() throw() {}

  const std::string* tableName;
  const std::string* rowKey;
  const std::string* timestamp;

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

};

class ThriftCloudataService_removeRowWithTime_result {
 public:

  ThriftCloudataService_removeRowWithTime_result() {
  }

  virtual ~ThriftCloudataService_removeRowWithTime_result() throw() {}

  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_removeRowWithTime_result & ) const;

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

};

class ThriftCloudataService_removeRowWithTime_presult {
 public:


  virtual ~ThriftCloudataService_removeRowWithTime_presult() throw() {}

  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_remove_args {
 public:

  ThriftCloudataService_remove_args() : tableName(""), rowKey(""), columnName(""), cellKey("") {
  }

  virtual ~ThriftCloudataService_remove_args() throw() {}

  std::string tableName;
  std::string rowKey;
  std::string columnName;
  std::string cellKey;

  struct __isset {
    __isset() : tableName(false), rowKey(false), columnName(false), cellKey(false) {}
    bool tableName;
    bool rowKey;
    bool columnName;
    bool cellKey;
  } __isset;

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

  bool operator < (const ThriftCloudataService_remove_args & ) const;

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

};

class ThriftCloudataService_remove_pargs {
 public:


  virtual ~ThriftCloudataService_remove_pargs() throw() {}

  const std::string* tableName;
  const std::string* rowKey;
  const std::string* columnName;
  const std::string* cellKey;

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

};

class ThriftCloudataService_remove_result {
 public:

  ThriftCloudataService_remove_result() {
  }

  virtual ~ThriftCloudataService_remove_result() throw() {}

  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_remove_result & ) const;

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

};

class ThriftCloudataService_remove_presult {
 public:


  virtual ~ThriftCloudataService_remove_presult() throw() {}

  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_hasValue_args {
 public:

  ThriftCloudataService_hasValue_args() : tableName(""), columnName(""), rowKey("") {
  }

  virtual ~ThriftCloudataService_hasValue_args() throw() {}

  std::string tableName;
  std::string columnName;
  std::string rowKey;

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

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

  bool operator < (const ThriftCloudataService_hasValue_args & ) const;

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

};

class ThriftCloudataService_hasValue_pargs {
 public:


  virtual ~ThriftCloudataService_hasValue_pargs() throw() {}

  const std::string* tableName;
  const std::string* columnName;
  const std::string* rowKey;

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

};

class ThriftCloudataService_hasValue_result {
 public:

  ThriftCloudataService_hasValue_result() : success(0) {
  }

  virtual ~ThriftCloudataService_hasValue_result() throw() {}

  bool success;
  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_hasValue_result & ) const;

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

};

class ThriftCloudataService_hasValue_presult {
 public:


  virtual ~ThriftCloudataService_hasValue_presult() throw() {}

  bool* success;
  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_getValue_args {
 public:

  ThriftCloudataService_getValue_args() : tableName(""), rowKey(""), columnName(""), cellKey("") {
  }

  virtual ~ThriftCloudataService_getValue_args() throw() {}

  std::string tableName;
  std::string rowKey;
  std::string columnName;
  std::string cellKey;

  struct __isset {
    __isset() : tableName(false), rowKey(false), columnName(false), cellKey(false) {}
    bool tableName;
    bool rowKey;
    bool columnName;
    bool cellKey;
  } __isset;

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

  bool operator < (const ThriftCloudataService_getValue_args & ) const;

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

};

class ThriftCloudataService_getValue_pargs {
 public:


  virtual ~ThriftCloudataService_getValue_pargs() throw() {}

  const std::string* tableName;
  const std::string* rowKey;
  const std::string* columnName;
  const std::string* cellKey;

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

};

class ThriftCloudataService_getValue_result {
 public:

  ThriftCloudataService_getValue_result() : success("") {
  }

  virtual ~ThriftCloudataService_getValue_result() throw() {}

  std::string success;
  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_getValue_result & ) const;

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

};

class ThriftCloudataService_getValue_presult {
 public:


  virtual ~ThriftCloudataService_getValue_presult() throw() {}

  std::string* success;
  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_get_args {
 public:

  ThriftCloudataService_get_args() : tableName(""), rowKey("") {
  }

  virtual ~ThriftCloudataService_get_args() throw() {}

  std::string tableName;
  std::string rowKey;

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

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

  bool operator < (const ThriftCloudataService_get_args & ) const;

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

};

class ThriftCloudataService_get_pargs {
 public:


  virtual ~ThriftCloudataService_get_pargs() throw() {}

  const std::string* tableName;
  const std::string* rowKey;

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

};

class ThriftCloudataService_get_result {
 public:

  ThriftCloudataService_get_result() {
  }

  virtual ~ThriftCloudataService_get_result() throw() {}

  ThriftRow success;
  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_get_result & ) const;

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

};

class ThriftCloudataService_get_presult {
 public:


  virtual ~ThriftCloudataService_get_presult() throw() {}

  ThriftRow* success;
  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_getColumnRow_args {
 public:

  ThriftCloudataService_getColumnRow_args() : tableName(""), rowKey("") {
  }

  virtual ~ThriftCloudataService_getColumnRow_args() throw() {}

  std::string tableName;
  std::string rowKey;
  std::vector<std::string>  columnNames;

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

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

  bool operator < (const ThriftCloudataService_getColumnRow_args & ) const;

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

};

class ThriftCloudataService_getColumnRow_pargs {
 public:


  virtual ~ThriftCloudataService_getColumnRow_pargs() throw() {}

  const std::string* tableName;
  const std::string* rowKey;
  const std::vector<std::string> * columnNames;

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

};

class ThriftCloudataService_getColumnRow_result {
 public:

  ThriftCloudataService_getColumnRow_result() {
  }

  virtual ~ThriftCloudataService_getColumnRow_result() throw() {}

  ThriftRow success;
  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_getColumnRow_result & ) const;

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

};

class ThriftCloudataService_getColumnRow_presult {
 public:


  virtual ~ThriftCloudataService_getColumnRow_presult() throw() {}

  ThriftRow* success;
  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_createTable_args {
 public:

  ThriftCloudataService_createTable_args() {
  }

  virtual ~ThriftCloudataService_createTable_args() throw() {}

  ThriftTableSchema tableSchema;

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

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

  bool operator < (const ThriftCloudataService_createTable_args & ) const;

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

};

class ThriftCloudataService_createTable_pargs {
 public:


  virtual ~ThriftCloudataService_createTable_pargs() throw() {}

  const ThriftTableSchema* tableSchema;

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

};

class ThriftCloudataService_createTable_result {
 public:

  ThriftCloudataService_createTable_result() {
  }

  virtual ~ThriftCloudataService_createTable_result() throw() {}

  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_createTable_result & ) const;

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

};

class ThriftCloudataService_createTable_presult {
 public:


  virtual ~ThriftCloudataService_createTable_presult() throw() {}

  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_existsTable_args {
 public:

  ThriftCloudataService_existsTable_args() : tableName("") {
  }

  virtual ~ThriftCloudataService_existsTable_args() throw() {}

  std::string tableName;

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

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

  bool operator < (const ThriftCloudataService_existsTable_args & ) const;

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

};

class ThriftCloudataService_existsTable_pargs {
 public:


  virtual ~ThriftCloudataService_existsTable_pargs() throw() {}

  const std::string* tableName;

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

};

class ThriftCloudataService_existsTable_result {
 public:

  ThriftCloudataService_existsTable_result() : success(0) {
  }

  virtual ~ThriftCloudataService_existsTable_result() throw() {}

  bool success;
  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_existsTable_result & ) const;

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

};

class ThriftCloudataService_existsTable_presult {
 public:


  virtual ~ThriftCloudataService_existsTable_presult() throw() {}

  bool* success;
  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_dropTable_args {
 public:

  ThriftCloudataService_dropTable_args() : tableName("") {
  }

  virtual ~ThriftCloudataService_dropTable_args() throw() {}

  std::string tableName;

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

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

  bool operator < (const ThriftCloudataService_dropTable_args & ) const;

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

};

class ThriftCloudataService_dropTable_pargs {
 public:


  virtual ~ThriftCloudataService_dropTable_pargs() throw() {}

  const std::string* tableName;

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

};

class ThriftCloudataService_dropTable_result {
 public:

  ThriftCloudataService_dropTable_result() {
  }

  virtual ~ThriftCloudataService_dropTable_result() throw() {}

  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_dropTable_result & ) const;

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

};

class ThriftCloudataService_dropTable_presult {
 public:


  virtual ~ThriftCloudataService_dropTable_presult() throw() {}

  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_truncateTable_args {
 public:

  ThriftCloudataService_truncateTable_args() : tableName(""), clearPartitionInfo(0) {
  }

  virtual ~ThriftCloudataService_truncateTable_args() throw() {}

  std::string tableName;
  bool clearPartitionInfo;

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

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

  bool operator < (const ThriftCloudataService_truncateTable_args & ) const;

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

};

class ThriftCloudataService_truncateTable_pargs {
 public:


  virtual ~ThriftCloudataService_truncateTable_pargs() throw() {}

  const std::string* tableName;
  const bool* clearPartitionInfo;

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

};

class ThriftCloudataService_truncateTable_result {
 public:

  ThriftCloudataService_truncateTable_result() {
  }

  virtual ~ThriftCloudataService_truncateTable_result() throw() {}

  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_truncateTable_result & ) const;

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

};

class ThriftCloudataService_truncateTable_presult {
 public:


  virtual ~ThriftCloudataService_truncateTable_presult() throw() {}

  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_truncateColumn_args {
 public:

  ThriftCloudataService_truncateColumn_args() : tableName(""), columnName("") {
  }

  virtual ~ThriftCloudataService_truncateColumn_args() throw() {}

  std::string tableName;
  std::string columnName;

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

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

  bool operator < (const ThriftCloudataService_truncateColumn_args & ) const;

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

};

class ThriftCloudataService_truncateColumn_pargs {
 public:


  virtual ~ThriftCloudataService_truncateColumn_pargs() throw() {}

  const std::string* tableName;
  const std::string* columnName;

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

};

class ThriftCloudataService_truncateColumn_result {
 public:

  ThriftCloudataService_truncateColumn_result() {
  }

  virtual ~ThriftCloudataService_truncateColumn_result() throw() {}

  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_truncateColumn_result & ) const;

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

};

class ThriftCloudataService_truncateColumn_presult {
 public:


  virtual ~ThriftCloudataService_truncateColumn_presult() throw() {}

  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_descTable_args {
 public:

  ThriftCloudataService_descTable_args() : tableName("") {
  }

  virtual ~ThriftCloudataService_descTable_args() throw() {}

  std::string tableName;

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

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

  bool operator < (const ThriftCloudataService_descTable_args & ) const;

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

};

class ThriftCloudataService_descTable_pargs {
 public:


  virtual ~ThriftCloudataService_descTable_pargs() throw() {}

  const std::string* tableName;

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

};

class ThriftCloudataService_descTable_result {
 public:

  ThriftCloudataService_descTable_result() {
  }

  virtual ~ThriftCloudataService_descTable_result() throw() {}

  ThriftTableSchema success;
  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_descTable_result & ) const;

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

};

class ThriftCloudataService_descTable_presult {
 public:


  virtual ~ThriftCloudataService_descTable_presult() throw() {}

  ThriftTableSchema* success;
  ThriftIOException tioe;

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

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

};

class ThriftCloudataService_addColumn_args {
 public:

  ThriftCloudataService_addColumn_args() : tableName(""), addedColumnName("") {
  }

  virtual ~ThriftCloudataService_addColumn_args() throw() {}

  std::string tableName;
  std::string addedColumnName;

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

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

  bool operator < (const ThriftCloudataService_addColumn_args & ) const;

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

};

class ThriftCloudataService_addColumn_pargs {
 public:


  virtual ~ThriftCloudataService_addColumn_pargs() throw() {}

  const std::string* tableName;
  const std::string* addedColumnName;

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

};

class ThriftCloudataService_addColumn_result {
 public:

  ThriftCloudataService_addColumn_result() {
  }

  virtual ~ThriftCloudataService_addColumn_result() throw() {}

  ThriftIOException tioe;

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

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

  bool operator < (const ThriftCloudataService_addColumn_result & ) const;

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

};

class ThriftCloudataService_addColumn_presult {
 public:


  virtual ~ThriftCloudataService_addColumn_presult() throw() {}

  ThriftIOException tioe;

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

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

};

class ThriftCloudataServiceClient : virtual public ThriftCloudataServiceIf {
 public:
  ThriftCloudataServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
    piprot_(prot),
    poprot_(prot) {
    iprot_ = prot.get();
    oprot_ = prot.get();
  }
  ThriftCloudataServiceClient(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();
  }
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void listTables(std::vector<ThriftTableSchema> & _return);
  void send_listTables();
  void recv_listTables(std::vector<ThriftTableSchema> & _return);
  void put(const std::string& tableName, const ThriftRow& row, const bool useSystemTimestamp);
  void send_put(const std::string& tableName, const ThriftRow& row, const bool useSystemTimestamp);
  void recv_put();
  void removeRow(const std::string& tableName, const std::string& rowKey);
  void send_removeRow(const std::string& tableName, const std::string& rowKey);
  void recv_removeRow();
  void removeRowWithTime(const std::string& tableName, const std::string& rowKey, const std::string& timestamp);
  void send_removeRowWithTime(const std::string& tableName, const std::string& rowKey, const std::string& timestamp);
  void recv_removeRowWithTime();
  void remove(const std::string& tableName, const std::string& rowKey, const std::string& columnName, const std::string& cellKey);
  void send_remove(const std::string& tableName, const std::string& rowKey, const std::string& columnName, const std::string& cellKey);
  void recv_remove();
  bool hasValue(const std::string& tableName, const std::string& columnName, const std::string& rowKey);
  void send_hasValue(const std::string& tableName, const std::string& columnName, const std::string& rowKey);
  bool recv_hasValue();
  void getValue(std::string& _return, const std::string& tableName, const std::string& rowKey, const std::string& columnName, const std::string& cellKey);
  void send_getValue(const std::string& tableName, const std::string& rowKey, const std::string& columnName, const std::string& cellKey);
  void recv_getValue(std::string& _return);
  void get(ThriftRow& _return, const std::string& tableName, const std::string& rowKey);
  void send_get(const std::string& tableName, const std::string& rowKey);
  void recv_get(ThriftRow& _return);
  void getColumnRow(ThriftRow& _return, const std::string& tableName, const std::string& rowKey, const std::vector<std::string> & columnNames);
  void send_getColumnRow(const std::string& tableName, const std::string& rowKey, const std::vector<std::string> & columnNames);
  void recv_getColumnRow(ThriftRow& _return);
  void createTable(const ThriftTableSchema& tableSchema);
  void send_createTable(const ThriftTableSchema& tableSchema);
  void recv_createTable();
  bool existsTable(const std::string& tableName);
  void send_existsTable(const std::string& tableName);
  bool recv_existsTable();
  void dropTable(const std::string& tableName);
  void send_dropTable(const std::string& tableName);
  void recv_dropTable();
  void truncateTable(const std::string& tableName, const bool clearPartitionInfo);
  void send_truncateTable(const std::string& tableName, const bool clearPartitionInfo);
  void recv_truncateTable();
  void truncateColumn(const std::string& tableName, const std::string& columnName);
  void send_truncateColumn(const std::string& tableName, const std::string& columnName);
  void recv_truncateColumn();
  void descTable(ThriftTableSchema& _return, const std::string& tableName);
  void send_descTable(const std::string& tableName);
  void recv_descTable(ThriftTableSchema& _return);
  void addColumn(const std::string& tableName, const std::string& addedColumnName);
  void send_addColumn(const std::string& tableName, const std::string& addedColumnName);
  void recv_addColumn();
 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 ThriftCloudataServiceProcessor : virtual public ::apache::thrift::TProcessor {
 protected:
  boost::shared_ptr<ThriftCloudataServiceIf> iface_;
  virtual bool process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid);
 private:
  std::map<std::string, void (ThriftCloudataServiceProcessor::*)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*)> processMap_;
  void process_listTables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_put(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_removeRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_removeRowWithTime(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_remove(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_hasValue(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_getValue(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_getColumnRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_createTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_existsTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_dropTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_truncateTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_truncateColumn(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_descTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  void process_addColumn(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 public:
  ThriftCloudataServiceProcessor(boost::shared_ptr<ThriftCloudataServiceIf> iface) :
    iface_(iface) {
    processMap_["listTables"] = &ThriftCloudataServiceProcessor::process_listTables;
    processMap_["put"] = &ThriftCloudataServiceProcessor::process_put;
    processMap_["removeRow"] = &ThriftCloudataServiceProcessor::process_removeRow;
    processMap_["removeRowWithTime"] = &ThriftCloudataServiceProcessor::process_removeRowWithTime;
    processMap_["remove"] = &ThriftCloudataServiceProcessor::process_remove;
    processMap_["hasValue"] = &ThriftCloudataServiceProcessor::process_hasValue;
    processMap_["getValue"] = &ThriftCloudataServiceProcessor::process_getValue;
    processMap_["get"] = &ThriftCloudataServiceProcessor::process_get;
    processMap_["getColumnRow"] = &ThriftCloudataServiceProcessor::process_getColumnRow;
    processMap_["createTable"] = &ThriftCloudataServiceProcessor::process_createTable;
    processMap_["existsTable"] = &ThriftCloudataServiceProcessor::process_existsTable;
    processMap_["dropTable"] = &ThriftCloudataServiceProcessor::process_dropTable;
    processMap_["truncateTable"] = &ThriftCloudataServiceProcessor::process_truncateTable;
    processMap_["truncateColumn"] = &ThriftCloudataServiceProcessor::process_truncateColumn;
    processMap_["descTable"] = &ThriftCloudataServiceProcessor::process_descTable;
    processMap_["addColumn"] = &ThriftCloudataServiceProcessor::process_addColumn;
  }

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

class ThriftCloudataServiceMultiface : virtual public ThriftCloudataServiceIf {
 public:
  ThriftCloudataServiceMultiface(std::vector<boost::shared_ptr<ThriftCloudataServiceIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~ThriftCloudataServiceMultiface() {}
 protected:
  std::vector<boost::shared_ptr<ThriftCloudataServiceIf> > ifaces_;
  ThriftCloudataServiceMultiface() {}
  void add(boost::shared_ptr<ThriftCloudataServiceIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void listTables(std::vector<ThriftTableSchema> & _return) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->listTables(_return);
        return;
      } else {
        ifaces_[i]->listTables(_return);
      }
    }
  }

  void put(const std::string& tableName, const ThriftRow& row, const bool useSystemTimestamp) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->put(tableName, row, useSystemTimestamp);
    }
  }

  void removeRow(const std::string& tableName, const std::string& rowKey) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->removeRow(tableName, rowKey);
    }
  }

  void removeRowWithTime(const std::string& tableName, const std::string& rowKey, const std::string& timestamp) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->removeRowWithTime(tableName, rowKey, timestamp);
    }
  }

  void remove(const std::string& tableName, const std::string& rowKey, const std::string& columnName, const std::string& cellKey) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->remove(tableName, rowKey, columnName, cellKey);
    }
  }

  bool hasValue(const std::string& tableName, const std::string& columnName, const std::string& rowKey) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        return ifaces_[i]->hasValue(tableName, columnName, rowKey);
      } else {
        ifaces_[i]->hasValue(tableName, columnName, rowKey);
      }
    }
  }

  void getValue(std::string& _return, const std::string& tableName, const std::string& rowKey, const std::string& columnName, const std::string& cellKey) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        ifaces_[i]->getValue(_return, tableName, rowKey, columnName, cellKey);
        return;
      } else {
        ifaces_[i]->getValue(_return, tableName, rowKey, columnName, cellKey);
      }
    }
  }

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

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

  void createTable(const ThriftTableSchema& tableSchema) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->createTable(tableSchema);
    }
  }

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

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

  void truncateTable(const std::string& tableName, const bool clearPartitionInfo) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->truncateTable(tableName, clearPartitionInfo);
    }
  }

  void truncateColumn(const std::string& tableName, const std::string& columnName) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->truncateColumn(tableName, columnName);
    }
  }

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

  void addColumn(const std::string& tableName, const std::string& addedColumnName) {
    uint32_t sz = ifaces_.size();
    for (uint32_t i = 0; i < sz; ++i) {
      ifaces_[i]->addColumn(tableName, addedColumnName);
    }
  }

};

} // namespace

#endif
