Hbase_types.h

Go to the documentation of this file.

#ifndef Hbase_TYPES_H
#define Hbase_TYPES_H

#include <stdint.h>
#include <Thrift.h>
#include <TApplicationException.h>
#include <protocol/TProtocol.h>
#include <transport/TTransport.h>



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

typedef std::string Text;

typedef std::string Bytes;

typedef int32_t ScannerID;

typedef struct _TCell__isset {
  _TCell__isset() : value(false), timestamp(false) {}
  bool value;
  bool timestamp;
} _TCell__isset;

class TCell {
 public:

  static const char* ascii_fingerprint; // = "1CCCF6FC31CFD1D61BBBB1BAF3590620";
  static const uint8_t binary_fingerprint[16]; // = {0x1C,0xCC,0xF6,0xFC,0x31,0xCF,0xD1,0xD6,0x1B,0xBB,0xB1,0xBA,0xF3,0x59,0x06,0x20};

  TCell() : value(""), timestamp(0) {
  }

  virtual ~TCell() throw() {}

  Bytes value;
  int64_t timestamp;

  _TCell__isset __isset;

  void __set_value(const Bytes& val) {
    value = val;
  }

  void __set_timestamp(const int64_t val) {
    timestamp = val;
  }

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

  bool operator < (const TCell & ) const;

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

};

typedef struct _ColumnDescriptor__isset {
  _ColumnDescriptor__isset() : name(false), maxVersions(false), compression(false), inMemory(false), bloomFilterType(false), bloomFilterVectorSize(false), bloomFilterNbHashes(false), blockCacheEnabled(false), timeToLive(false) {}
  bool name;
  bool maxVersions;
  bool compression;
  bool inMemory;
  bool bloomFilterType;
  bool bloomFilterVectorSize;
  bool bloomFilterNbHashes;
  bool blockCacheEnabled;
  bool timeToLive;
} _ColumnDescriptor__isset;

class ColumnDescriptor {
 public:

  static const char* ascii_fingerprint; // = "3B18638852FDF9DD911BC1174265F92E";
  static const uint8_t binary_fingerprint[16]; // = {0x3B,0x18,0x63,0x88,0x52,0xFD,0xF9,0xDD,0x91,0x1B,0xC1,0x17,0x42,0x65,0xF9,0x2E};

  ColumnDescriptor() : name(""), maxVersions(3), compression("NONE"), inMemory(false), bloomFilterType("NONE"), bloomFilterVectorSize(0), bloomFilterNbHashes(0), blockCacheEnabled(false), timeToLive(-1) {
  }

  virtual ~ColumnDescriptor() throw() {}

  Text name;
  int32_t maxVersions;
  std::string compression;
  bool inMemory;
  std::string bloomFilterType;
  int32_t bloomFilterVectorSize;
  int32_t bloomFilterNbHashes;
  bool blockCacheEnabled;
  int32_t timeToLive;

  _ColumnDescriptor__isset __isset;

  void __set_name(const Text& val) {
    name = val;
  }

  void __set_maxVersions(const int32_t val) {
    maxVersions = val;
  }

  void __set_compression(const std::string& val) {
    compression = val;
  }

  void __set_inMemory(const bool val) {
    inMemory = val;
  }

  void __set_bloomFilterType(const std::string& val) {
    bloomFilterType = val;
  }

  void __set_bloomFilterVectorSize(const int32_t val) {
    bloomFilterVectorSize = val;
  }

  void __set_bloomFilterNbHashes(const int32_t val) {
    bloomFilterNbHashes = val;
  }

  void __set_blockCacheEnabled(const bool val) {
    blockCacheEnabled = val;
  }

  void __set_timeToLive(const int32_t val) {
    timeToLive = val;
  }

  bool operator == (const ColumnDescriptor & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(maxVersions == rhs.maxVersions))
      return false;
    if (!(compression == rhs.compression))
      return false;
    if (!(inMemory == rhs.inMemory))
      return false;
    if (!(bloomFilterType == rhs.bloomFilterType))
      return false;
    if (!(bloomFilterVectorSize == rhs.bloomFilterVectorSize))
      return false;
    if (!(bloomFilterNbHashes == rhs.bloomFilterNbHashes))
      return false;
    if (!(blockCacheEnabled == rhs.blockCacheEnabled))
      return false;
    if (!(timeToLive == rhs.timeToLive))
      return false;
    return true;
  }
  bool operator != (const ColumnDescriptor &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ColumnDescriptor & ) const;

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

};

typedef struct _TRegionInfo__isset {
  _TRegionInfo__isset() : startKey(false), endKey(false), id(false), name(false), version(false), serverName(false), port(false) {}
  bool startKey;
  bool endKey;
  bool id;
  bool name;
  bool version;
  bool serverName;
  bool port;
} _TRegionInfo__isset;

class TRegionInfo {
 public:

  static const char* ascii_fingerprint; // = "B58AB7A239831F8614F7B6709C89DC7B";
  static const uint8_t binary_fingerprint[16]; // = {0xB5,0x8A,0xB7,0xA2,0x39,0x83,0x1F,0x86,0x14,0xF7,0xB6,0x70,0x9C,0x89,0xDC,0x7B};

  TRegionInfo() : startKey(""), endKey(""), id(0), name(""), version(0), serverName(""), port(0) {
  }

  virtual ~TRegionInfo() throw() {}

  Text startKey;
  Text endKey;
  int64_t id;
  Text name;
  int8_t version;
  Text serverName;
  int32_t port;

  _TRegionInfo__isset __isset;

  void __set_startKey(const Text& val) {
    startKey = val;
  }

  void __set_endKey(const Text& val) {
    endKey = val;
  }

  void __set_id(const int64_t val) {
    id = val;
  }

  void __set_name(const Text& val) {
    name = val;
  }

  void __set_version(const int8_t val) {
    version = val;
  }

  void __set_serverName(const Text& val) {
    serverName = val;
  }

  void __set_port(const int32_t val) {
    port = val;
  }

  bool operator == (const TRegionInfo & rhs) const
  {
    if (!(startKey == rhs.startKey))
      return false;
    if (!(endKey == rhs.endKey))
      return false;
    if (!(id == rhs.id))
      return false;
    if (!(name == rhs.name))
      return false;
    if (!(version == rhs.version))
      return false;
    if (!(serverName == rhs.serverName))
      return false;
    if (!(port == rhs.port))
      return false;
    return true;
  }
  bool operator != (const TRegionInfo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TRegionInfo & ) const;

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

};

typedef struct _Mutation__isset {
  _Mutation__isset() : isDelete(false), column(false), value(false) {}
  bool isDelete;
  bool column;
  bool value;
} _Mutation__isset;

class Mutation {
 public:

  static const char* ascii_fingerprint; // = "DC8F62AF23854A1A6849A2A157CCCA65";
  static const uint8_t binary_fingerprint[16]; // = {0xDC,0x8F,0x62,0xAF,0x23,0x85,0x4A,0x1A,0x68,0x49,0xA2,0xA1,0x57,0xCC,0xCA,0x65};

  Mutation() : isDelete(false), column(""), value("") {
  }

  virtual ~Mutation() throw() {}

  bool isDelete;
  Text column;
  Text value;

  _Mutation__isset __isset;

  void __set_isDelete(const bool val) {
    isDelete = val;
  }

  void __set_column(const Text& val) {
    column = val;
  }

  void __set_value(const Text& val) {
    value = val;
  }

  bool operator == (const Mutation & rhs) const
  {
    if (!(isDelete == rhs.isDelete))
      return false;
    if (!(column == rhs.column))
      return false;
    if (!(value == rhs.value))
      return false;
    return true;
  }
  bool operator != (const Mutation &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Mutation & ) const;

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

};

typedef struct _BatchMutation__isset {
  _BatchMutation__isset() : row(false), mutations(false) {}
  bool row;
  bool mutations;
} _BatchMutation__isset;

class BatchMutation {
 public:

  static const char* ascii_fingerprint; // = "7849EEBF8BB50169F3D2F0DD635BD8ED";
  static const uint8_t binary_fingerprint[16]; // = {0x78,0x49,0xEE,0xBF,0x8B,0xB5,0x01,0x69,0xF3,0xD2,0xF0,0xDD,0x63,0x5B,0xD8,0xED};

  BatchMutation() : row("") {
  }

  virtual ~BatchMutation() throw() {}

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

  _BatchMutation__isset __isset;

  void __set_row(const Text& val) {
    row = val;
  }

  void __set_mutations(const std::vector<Mutation> & val) {
    mutations = val;
  }

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

  bool operator < (const BatchMutation & ) const;

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

};

typedef struct _TRowResult__isset {
  _TRowResult__isset() : row(false), columns(false) {}
  bool row;
  bool columns;
} _TRowResult__isset;

class TRowResult {
 public:

  static const char* ascii_fingerprint; // = "AE98EA4F344566FAFE04FA5E5823D1ED";
  static const uint8_t binary_fingerprint[16]; // = {0xAE,0x98,0xEA,0x4F,0x34,0x45,0x66,0xFA,0xFE,0x04,0xFA,0x5E,0x58,0x23,0xD1,0xED};

  TRowResult() : row("") {
  }

  virtual ~TRowResult() throw() {}

  Text row;
  std::map<Text, TCell>  columns;

  _TRowResult__isset __isset;

  void __set_row(const Text& val) {
    row = val;
  }

  void __set_columns(const std::map<Text, TCell> & val) {
    columns = val;
  }

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

  bool operator < (const TRowResult & ) const;

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

};

typedef struct _TScan__isset {
  _TScan__isset() : startRow(false), stopRow(false), timestamp(false), columns(false), caching(false), filterString(false) {}
  bool startRow;
  bool stopRow;
  bool timestamp;
  bool columns;
  bool caching;
  bool filterString;
} _TScan__isset;

class TScan {
 public:

  static const char* ascii_fingerprint; // = "2C111FDF8CD162886ECCCBB9C9051083";
  static const uint8_t binary_fingerprint[16]; // = {0x2C,0x11,0x1F,0xDF,0x8C,0xD1,0x62,0x88,0x6E,0xCC,0xCB,0xB9,0xC9,0x05,0x10,0x83};

  TScan() : startRow(""), stopRow(""), timestamp(0), caching(0), filterString("") {
  }

  virtual ~TScan() throw() {}

  Text startRow;
  Text stopRow;
  int64_t timestamp;
  std::vector<Text>  columns;
  int32_t caching;
  Text filterString;

  _TScan__isset __isset;

  void __set_startRow(const Text& val) {
    startRow = val;
    __isset.startRow = true;
  }

  void __set_stopRow(const Text& val) {
    stopRow = val;
    __isset.stopRow = true;
  }

  void __set_timestamp(const int64_t val) {
    timestamp = val;
    __isset.timestamp = true;
  }

  void __set_columns(const std::vector<Text> & val) {
    columns = val;
    __isset.columns = true;
  }

  void __set_caching(const int32_t val) {
    caching = val;
    __isset.caching = true;
  }

  void __set_filterString(const Text& val) {
    filterString = val;
    __isset.filterString = true;
  }

  bool operator == (const TScan & rhs) const
  {
    if (__isset.startRow != rhs.__isset.startRow)
      return false;
    else if (__isset.startRow && !(startRow == rhs.startRow))
      return false;
    if (__isset.stopRow != rhs.__isset.stopRow)
      return false;
    else if (__isset.stopRow && !(stopRow == rhs.stopRow))
      return false;
    if (__isset.timestamp != rhs.__isset.timestamp)
      return false;
    else if (__isset.timestamp && !(timestamp == rhs.timestamp))
      return false;
    if (__isset.columns != rhs.__isset.columns)
      return false;
    else if (__isset.columns && !(columns == rhs.columns))
      return false;
    if (__isset.caching != rhs.__isset.caching)
      return false;
    else if (__isset.caching && !(caching == rhs.caching))
      return false;
    if (__isset.filterString != rhs.__isset.filterString)
      return false;
    else if (__isset.filterString && !(filterString == rhs.filterString))
      return false;
    return true;
  }
  bool operator != (const TScan &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TScan & ) const;

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

};

typedef struct _IOError__isset {
  _IOError__isset() : message(false) {}
  bool message;
} _IOError__isset;

class IOError : public ::apache::thrift::TException {
 public:

  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};

  IOError() : message("") {
  }

  virtual ~IOError() throw() {}

  std::string message;

  _IOError__isset __isset;

  void __set_message(const std::string& val) {
    message = val;
  }

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

  bool operator < (const IOError & ) const;

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

};

typedef struct _IllegalArgument__isset {
  _IllegalArgument__isset() : message(false) {}
  bool message;
} _IllegalArgument__isset;

class IllegalArgument : public ::apache::thrift::TException {
 public:

  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};

  IllegalArgument() : message("") {
  }

  virtual ~IllegalArgument() throw() {}

  std::string message;

  _IllegalArgument__isset __isset;

  void __set_message(const std::string& val) {
    message = val;
  }

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

  bool operator < (const IllegalArgument & ) const;

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

};

typedef struct _AlreadyExists__isset {
  _AlreadyExists__isset() : message(false) {}
  bool message;
} _AlreadyExists__isset;

class AlreadyExists : public ::apache::thrift::TException {
 public:

  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};

  AlreadyExists() : message("") {
  }

  virtual ~AlreadyExists() throw() {}

  std::string message;

  _AlreadyExists__isset __isset;

  void __set_message(const std::string& val) {
    message = val;
  }

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

  bool operator < (const AlreadyExists & ) const;

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

};

}}}} // namespace

#endif