Hbase_types.h ( File view )

  • By 1106110976 2013-09-10
  • View(s):8
  • Download(s):0
  • Point(s): 1
			/**
 * Autogenerated by Thrift Compiler (0.9.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef Hbase_TYPES_H
#define Hbase_TYPES_H
#include "stdafx.h"
#include <thrift/Thrift.h>
#include <thrift/TApplicationException.h>
#include <thrift/protocol/TProtocol.h>
#include <thrift/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;


};

void swap(TCell &a, TCell &b);

typedef struct _ColumnDescriptor__isset {

  _ColumnDescriptor__isset() : name(false), maxVersions(true), compression(true), inMemory(true), bloomFilterType(true), bloomFilterVectorSize(true), bloomFilterNbHashes(true), blockCacheEnabled(true), timeToLive(true) {

}
  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;


};

void swap(ColumnDescriptor &a, ColumnDescriptor &b);

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;


};

void swap(TRegionInfo &a, TRegionInfo &b);

typedef struct _Mutation__isset {

  _Mutation__isset() : isDelete(true), column(false), value(false), writeToWAL(true) {

}
  bool isDelete;
  bool column;
  bool value;
  bool writeToWAL;

} _Mutation__isset;

class Mutation {

 public:

  static const char* ascii_fingerprint; // = "CD9E9D4A6406AD402C90440434AE18A0";
  static const uint8_t binary_fingerprint[16]; // = {
0xCD,0x9E,0x9D,0x4A,0x64,0x06,0xAD,0x40,0x2C,0x90,0x44,0x04,0x34,0xAE,0x18,0xA0
};

  Mutation() : isDelete(false), column(), value(), writeToWAL(true) {

  
}

  virtual ~Mutation() throw() {

}

  bool isDelete;
  Text column;
  Text value;
  bool writeToWAL;

  _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;
  
}

  void __set_writeToWAL(const bool val) {

    writeToWAL = 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;
    if (!(writeToWAL == rhs.writeToWAL))
      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;


};

void swap(Mutation &a, Mutation &b);

typedef struct _BatchMutation__isset {

  _BatchMutation__isset() : row(false), mutations(false) {

}
  bool row;
  bool mutations;

} _BatchMutation__isset;

class BatchMutation {

 public:

  static const char* ascii_fingerprint; // = "4B8A4A9E051CAFF532E1C0D54F6AD2AB";
  static const uint8_t binary_fingerprint[16]; // = {
0x4B,0x8A,0x4A,0x9E,0x05,0x1C,0xAF,0xF5,0x32,0xE1,0xC0,0xD5,0x4F,0x6A,0xD2,0xAB
};

  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;


};

void swap(BatchMutation &a, BatchMutation &b);

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 {

  
...
...
(Not finished, please download and read the complete file)
			
...
Expand> <Close

Want complete source code? Download it here

Point(s): 1

Download
0 lines left, continue to read
Sponsored links

File list

Tips: You can preview the content of files by clicking file names^_^
Name Size Date
01.96 kB
01.96 kB
LibHbase.dll1.11 MB2012-12-22|21:40
01.96 kB
Hbase.h170.78 kB2012-12-22|21:38
Hbase_constants.h424.00 B2012-12-16|22:44
Hbase_types.h15.98 kB2012-12-22|12:29
01.96 kB
LibHbased.lib190.79 kB2012-12-22|21:40
...
Sponsored links

Hbase_types.h (269.81 kB)

Need 1 point
Your Point(s)

Your Point isn't enough.

Get point immediately by PayPal

More(Debit card / Credit card / PayPal Credit / Online Banking)

Submit your source codes. Get more point

LOGIN

Don't have an account? Register now
Need any help?
Mail to: support@codeforge.com

切换到中文版?

CodeForge Chinese Version
CodeForge English Version

Where are you going?

^_^"Oops ...

Sorry!This guy is mysterious, its blog hasn't been opened, try another, please!
OK

Warm tip!

CodeForge to FavoriteFavorite by Ctrl+D