src/modules/db_cassandra/cassandra_types.h
c0a92201
 /**
  * Autogenerated by Thrift
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
 #ifndef cassandra_TYPES_H
 #define cassandra_TYPES_H
 
 #include <Thrift.h>
 #include <TApplicationException.h>
 #include <protocol/TProtocol.h>
 #include <transport/TTransport.h>
 
 
 
 namespace org { namespace apache { namespace cassandra {
 
 struct ConsistencyLevel {
   enum type {
     ONE = 1,
     QUORUM = 2,
     LOCAL_QUORUM = 3,
     EACH_QUORUM = 4,
     ALL = 5,
     ANY = 6,
     TWO = 7,
     THREE = 8
   };
 };
 
 extern const std::map<int, const char*> _ConsistencyLevel_VALUES_TO_NAMES;
 
 struct IndexOperator {
   enum type {
     EQ = 0,
     GTE = 1,
     GT = 2,
     LTE = 3,
     LT = 4
   };
 };
 
 extern const std::map<int, const char*> _IndexOperator_VALUES_TO_NAMES;
 
 struct IndexType {
   enum type {
     KEYS = 0,
     CUSTOM = 1
   };
 };
 
 extern const std::map<int, const char*> _IndexType_VALUES_TO_NAMES;
 
 struct Compression {
   enum type {
     GZIP = 1,
     NONE = 2
   };
 };
 
 extern const std::map<int, const char*> _Compression_VALUES_TO_NAMES;
 
 struct CqlResultType {
   enum type {
     ROWS = 1,
     VOID = 2,
     INT = 3
   };
 };
 
 extern const std::map<int, const char*> _CqlResultType_VALUES_TO_NAMES;
 
 typedef struct _Column__isset {
   _Column__isset() : value(false), timestamp(false), ttl(false) {}
   bool value;
   bool timestamp;
   bool ttl;
 } _Column__isset;
 
 class Column {
  public:
 
   static const char* ascii_fingerprint; // = "3EE0E1C5C844001B62F08125068292CC";
   static const uint8_t binary_fingerprint[16]; // = {0x3E,0xE0,0xE1,0xC5,0xC8,0x44,0x00,0x1B,0x62,0xF0,0x81,0x25,0x06,0x82,0x92,0xCC};
 
   Column() : name(""), value(""), timestamp(0), ttl(0) {
   }
 
   virtual ~Column() throw() {}
 
   std::string name;
   std::string value;
   int64_t timestamp;
   int32_t ttl;
 
   _Column__isset __isset;
 
   bool operator == (const Column & rhs) const
   {
     if (!(name == rhs.name))
       return false;
     if (__isset.value != rhs.__isset.value)
       return false;
     else if (__isset.value && !(value == rhs.value))
       return false;
     if (__isset.timestamp != rhs.__isset.timestamp)
       return false;
     else if (__isset.timestamp && !(timestamp == rhs.timestamp))
       return false;
     if (__isset.ttl != rhs.__isset.ttl)
       return false;
     else if (__isset.ttl && !(ttl == rhs.ttl))
       return false;
     return true;
   }
   bool operator != (const Column &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const Column & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class SuperColumn {
  public:
 
   static const char* ascii_fingerprint; // = "470EFC558004E98D92D604898305C04E";
   static const uint8_t binary_fingerprint[16]; // = {0x47,0x0E,0xFC,0x55,0x80,0x04,0xE9,0x8D,0x92,0xD6,0x04,0x89,0x83,0x05,0xC0,0x4E};
 
   SuperColumn() : name("") {
   }
 
   virtual ~SuperColumn() throw() {}
 
   std::string name;
   std::vector<Column>  columns;
 
   bool operator == (const SuperColumn & rhs) const
   {
     if (!(name == rhs.name))
       return false;
     if (!(columns == rhs.columns))
       return false;
     return true;
   }
   bool operator != (const SuperColumn &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const SuperColumn & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class CounterColumn {
  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};
 
   CounterColumn() : name(""), value(0) {
   }
 
   virtual ~CounterColumn() throw() {}
 
   std::string name;
   int64_t value;
 
   bool operator == (const CounterColumn & rhs) const
   {
     if (!(name == rhs.name))
       return false;
     if (!(value == rhs.value))
       return false;
     return true;
   }
   bool operator != (const CounterColumn &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const CounterColumn & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class CounterSuperColumn {
  public:
 
   static const char* ascii_fingerprint; // = "CD4C8C4BF7753E46DE417CDE369343A4";
   static const uint8_t binary_fingerprint[16]; // = {0xCD,0x4C,0x8C,0x4B,0xF7,0x75,0x3E,0x46,0xDE,0x41,0x7C,0xDE,0x36,0x93,0x43,0xA4};
 
   CounterSuperColumn() : name("") {
   }
 
   virtual ~CounterSuperColumn() throw() {}
 
   std::string name;
   std::vector<CounterColumn>  columns;
 
   bool operator == (const CounterSuperColumn & rhs) const
   {
     if (!(name == rhs.name))
       return false;
     if (!(columns == rhs.columns))
       return false;
     return true;
   }
   bool operator != (const CounterSuperColumn &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const CounterSuperColumn & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _ColumnOrSuperColumn__isset {
   _ColumnOrSuperColumn__isset() : column(false), super_column(false), counter_column(false), counter_super_column(false) {}
   bool column;
   bool super_column;
   bool counter_column;
   bool counter_super_column;
 } _ColumnOrSuperColumn__isset;
 
 class ColumnOrSuperColumn {
  public:
 
   static const char* ascii_fingerprint; // = "2B34AC9E80F1DAA3A2A63B1AB1841E61";
   static const uint8_t binary_fingerprint[16]; // = {0x2B,0x34,0xAC,0x9E,0x80,0xF1,0xDA,0xA3,0xA2,0xA6,0x3B,0x1A,0xB1,0x84,0x1E,0x61};
 
   ColumnOrSuperColumn() {
   }
 
   virtual ~ColumnOrSuperColumn() throw() {}
 
   Column column;
   SuperColumn super_column;
   CounterColumn counter_column;
   CounterSuperColumn counter_super_column;
 
   _ColumnOrSuperColumn__isset __isset;
 
   bool operator == (const ColumnOrSuperColumn & rhs) const
   {
     if (__isset.column != rhs.__isset.column)
       return false;
     else if (__isset.column && !(column == rhs.column))
       return false;
     if (__isset.super_column != rhs.__isset.super_column)
       return false;
     else if (__isset.super_column && !(super_column == rhs.super_column))
       return false;
     if (__isset.counter_column != rhs.__isset.counter_column)
       return false;
     else if (__isset.counter_column && !(counter_column == rhs.counter_column))
       return false;
     if (__isset.counter_super_column != rhs.__isset.counter_super_column)
       return false;
     else if (__isset.counter_super_column && !(counter_super_column == rhs.counter_super_column))
       return false;
     return true;
   }
   bool operator != (const ColumnOrSuperColumn &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const ColumnOrSuperColumn & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class NotFoundException : public ::apache::thrift::TException {
  public:
 
   static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
   static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
 
   NotFoundException() {
   }
 
   virtual ~NotFoundException() throw() {}
 
 
   bool operator == (const NotFoundException & /* rhs */) const
   {
     return true;
   }
   bool operator != (const NotFoundException &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const NotFoundException & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class InvalidRequestException : 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};
 
   InvalidRequestException() : why("") {
   }
 
   virtual ~InvalidRequestException() throw() {}
 
   std::string why;
 
   bool operator == (const InvalidRequestException & rhs) const
   {
     if (!(why == rhs.why))
       return false;
     return true;
   }
   bool operator != (const InvalidRequestException &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const InvalidRequestException & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class UnavailableException : public ::apache::thrift::TException {
  public:
 
   static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
   static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
 
   UnavailableException() {
   }
 
   virtual ~UnavailableException() throw() {}
 
 
   bool operator == (const UnavailableException & /* rhs */) const
   {
     return true;
   }
   bool operator != (const UnavailableException &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const UnavailableException & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class TimedOutException : public ::apache::thrift::TException {
  public:
 
   static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
   static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
 
   TimedOutException() {
   }
 
   virtual ~TimedOutException() throw() {}
 
 
   bool operator == (const TimedOutException & /* rhs */) const
   {
     return true;
   }
   bool operator != (const TimedOutException &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const TimedOutException & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class AuthenticationException : 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};
 
   AuthenticationException() : why("") {
   }
 
   virtual ~AuthenticationException() throw() {}
 
   std::string why;
 
   bool operator == (const AuthenticationException & rhs) const
   {
     if (!(why == rhs.why))
       return false;
     return true;
   }
   bool operator != (const AuthenticationException &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const AuthenticationException & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class AuthorizationException : 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};
 
   AuthorizationException() : why("") {
   }
 
   virtual ~AuthorizationException() throw() {}
 
   std::string why;
 
   bool operator == (const AuthorizationException & rhs) const
   {
     if (!(why == rhs.why))
       return false;
     return true;
   }
   bool operator != (const AuthorizationException &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const AuthorizationException & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class SchemaDisagreementException : public ::apache::thrift::TException {
  public:
 
   static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
   static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
 
   SchemaDisagreementException() {
   }
 
   virtual ~SchemaDisagreementException() throw() {}
 
 
   bool operator == (const SchemaDisagreementException & /* rhs */) const
   {
     return true;
   }
   bool operator != (const SchemaDisagreementException &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const SchemaDisagreementException & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _ColumnParent__isset {
   _ColumnParent__isset() : super_column(false) {}
   bool super_column;
 } _ColumnParent__isset;
 
 class ColumnParent {
  public:
 
   static const char* ascii_fingerprint; // = "0A13AE61181713A4100DFFB3EC293822";
   static const uint8_t binary_fingerprint[16]; // = {0x0A,0x13,0xAE,0x61,0x18,0x17,0x13,0xA4,0x10,0x0D,0xFF,0xB3,0xEC,0x29,0x38,0x22};
 
   ColumnParent() : column_family(""), super_column("") {
   }
 
   virtual ~ColumnParent() throw() {}
 
   std::string column_family;
   std::string super_column;
 
   _ColumnParent__isset __isset;
 
   bool operator == (const ColumnParent & rhs) const
   {
     if (!(column_family == rhs.column_family))
       return false;
     if (__isset.super_column != rhs.__isset.super_column)
       return false;
     else if (__isset.super_column && !(super_column == rhs.super_column))
       return false;
     return true;
   }
   bool operator != (const ColumnParent &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const ColumnParent & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _ColumnPath__isset {
   _ColumnPath__isset() : super_column(false), column(false) {}
   bool super_column;
   bool column;
 } _ColumnPath__isset;
 
 class ColumnPath {
  public:
 
   static const char* ascii_fingerprint; // = "606212895BCF63C757913CF35AEB3462";
   static const uint8_t binary_fingerprint[16]; // = {0x60,0x62,0x12,0x89,0x5B,0xCF,0x63,0xC7,0x57,0x91,0x3C,0xF3,0x5A,0xEB,0x34,0x62};
 
   ColumnPath() : column_family(""), super_column(""), column("") {
   }
 
   virtual ~ColumnPath() throw() {}
 
   std::string column_family;
   std::string super_column;
   std::string column;
 
   _ColumnPath__isset __isset;
 
   bool operator == (const ColumnPath & rhs) const
   {
     if (!(column_family == rhs.column_family))
       return false;
     if (__isset.super_column != rhs.__isset.super_column)
       return false;
     else if (__isset.super_column && !(super_column == rhs.super_column))
       return false;
     if (__isset.column != rhs.__isset.column)
       return false;
     else if (__isset.column && !(column == rhs.column))
       return false;
     return true;
   }
   bool operator != (const ColumnPath &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const ColumnPath & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class SliceRange {
  public:
 
   static const char* ascii_fingerprint; // = "184D24C9A0B8D4415E234DB649CAE740";
   static const uint8_t binary_fingerprint[16]; // = {0x18,0x4D,0x24,0xC9,0xA0,0xB8,0xD4,0x41,0x5E,0x23,0x4D,0xB6,0x49,0xCA,0xE7,0x40};
 
   SliceRange() : start(""), finish(""), reversed(false), count(100) {
   }
 
   virtual ~SliceRange() throw() {}
 
   std::string start;
   std::string finish;
   bool reversed;
   int32_t count;
 
   bool operator == (const SliceRange & rhs) const
   {
     if (!(start == rhs.start))
       return false;
     if (!(finish == rhs.finish))
       return false;
     if (!(reversed == rhs.reversed))
       return false;
     if (!(count == rhs.count))
       return false;
     return true;
   }
   bool operator != (const SliceRange &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const SliceRange & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _SlicePredicate__isset {
   _SlicePredicate__isset() : column_names(false), slice_range(false) {}
   bool column_names;
   bool slice_range;
 } _SlicePredicate__isset;
 
 class SlicePredicate {
  public:
 
   static const char* ascii_fingerprint; // = "F59D1D81C17DFFAF09988BF1C9CE5E27";
   static const uint8_t binary_fingerprint[16]; // = {0xF5,0x9D,0x1D,0x81,0xC1,0x7D,0xFF,0xAF,0x09,0x98,0x8B,0xF1,0xC9,0xCE,0x5E,0x27};
 
   SlicePredicate() {
   }
 
   virtual ~SlicePredicate() throw() {}
 
   std::vector<std::string>  column_names;
   SliceRange slice_range;
 
   _SlicePredicate__isset __isset;
 
   bool operator == (const SlicePredicate & rhs) const
   {
     if (__isset.column_names != rhs.__isset.column_names)
       return false;
     else if (__isset.column_names && !(column_names == rhs.column_names))
       return false;
     if (__isset.slice_range != rhs.__isset.slice_range)
       return false;
     else if (__isset.slice_range && !(slice_range == rhs.slice_range))
       return false;
     return true;
   }
   bool operator != (const SlicePredicate &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const SlicePredicate & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class IndexExpression {
  public:
 
   static const char* ascii_fingerprint; // = "D9F4CFE2F293A8B1052FD3031DD2C847";
   static const uint8_t binary_fingerprint[16]; // = {0xD9,0xF4,0xCF,0xE2,0xF2,0x93,0xA8,0xB1,0x05,0x2F,0xD3,0x03,0x1D,0xD2,0xC8,0x47};
 
   IndexExpression() : column_name(""), value("") {
   }
 
   virtual ~IndexExpression() throw() {}
 
   std::string column_name;
   IndexOperator::type op;
   std::string value;
 
   bool operator == (const IndexExpression & rhs) const
   {
     if (!(column_name == rhs.column_name))
       return false;
     if (!(op == rhs.op))
       return false;
     if (!(value == rhs.value))
       return false;
     return true;
   }
   bool operator != (const IndexExpression &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const IndexExpression & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class IndexClause {
  public:
 
   static const char* ascii_fingerprint; // = "9B551B9AB86120B0EEA9005C77FD3C1F";
   static const uint8_t binary_fingerprint[16]; // = {0x9B,0x55,0x1B,0x9A,0xB8,0x61,0x20,0xB0,0xEE,0xA9,0x00,0x5C,0x77,0xFD,0x3C,0x1F};
 
   IndexClause() : start_key(""), count(100) {
   }
 
   virtual ~IndexClause() throw() {}
 
   std::vector<IndexExpression>  expressions;
   std::string start_key;
   int32_t count;
 
   bool operator == (const IndexClause & rhs) const
   {
     if (!(expressions == rhs.expressions))
       return false;
     if (!(start_key == rhs.start_key))
       return false;
     if (!(count == rhs.count))
       return false;
     return true;
   }
   bool operator != (const IndexClause &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const IndexClause & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _KeyRange__isset {
   _KeyRange__isset() : start_key(false), end_key(false), start_token(false), end_token(false) {}
   bool start_key;
   bool end_key;
   bool start_token;
   bool end_token;
 } _KeyRange__isset;
 
 class KeyRange {
  public:
 
   static const char* ascii_fingerprint; // = "8F248C09AF1EC3656ABD8565EA1F59C1";
   static const uint8_t binary_fingerprint[16]; // = {0x8F,0x24,0x8C,0x09,0xAF,0x1E,0xC3,0x65,0x6A,0xBD,0x85,0x65,0xEA,0x1F,0x59,0xC1};
 
   KeyRange() : start_key(""), end_key(""), start_token(""), end_token(""), count(100) {
   }
 
   virtual ~KeyRange() throw() {}
 
   std::string start_key;
   std::string end_key;
   std::string start_token;
   std::string end_token;
   int32_t count;
 
   _KeyRange__isset __isset;
 
   bool operator == (const KeyRange & rhs) const
   {
     if (__isset.start_key != rhs.__isset.start_key)
       return false;
     else if (__isset.start_key && !(start_key == rhs.start_key))
       return false;
     if (__isset.end_key != rhs.__isset.end_key)
       return false;
     else if (__isset.end_key && !(end_key == rhs.end_key))
       return false;
     if (__isset.start_token != rhs.__isset.start_token)
       return false;
     else if (__isset.start_token && !(start_token == rhs.start_token))
       return false;
     if (__isset.end_token != rhs.__isset.end_token)
       return false;
     else if (__isset.end_token && !(end_token == rhs.end_token))
       return false;
     if (!(count == rhs.count))
       return false;
     return true;
   }
   bool operator != (const KeyRange &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const KeyRange & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class KeySlice {
  public:
 
   static const char* ascii_fingerprint; // = "D1568675B0C135C909E3169B72A4DA3D";
   static const uint8_t binary_fingerprint[16]; // = {0xD1,0x56,0x86,0x75,0xB0,0xC1,0x35,0xC9,0x09,0xE3,0x16,0x9B,0x72,0xA4,0xDA,0x3D};
 
   KeySlice() : key("") {
   }
 
   virtual ~KeySlice() throw() {}
 
   std::string key;
   std::vector<ColumnOrSuperColumn>  columns;
 
   bool operator == (const KeySlice & rhs) const
   {
     if (!(key == rhs.key))
       return false;
     if (!(columns == rhs.columns))
       return false;
     return true;
   }
   bool operator != (const KeySlice &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const KeySlice & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class KeyCount {
  public:
 
   static const char* ascii_fingerprint; // = "EEBC915CE44901401D881E6091423036";
   static const uint8_t binary_fingerprint[16]; // = {0xEE,0xBC,0x91,0x5C,0xE4,0x49,0x01,0x40,0x1D,0x88,0x1E,0x60,0x91,0x42,0x30,0x36};
 
   KeyCount() : key(""), count(0) {
   }
 
   virtual ~KeyCount() throw() {}
 
   std::string key;
   int32_t count;
 
   bool operator == (const KeyCount & rhs) const
   {
     if (!(key == rhs.key))
       return false;
     if (!(count == rhs.count))
       return false;
     return true;
   }
   bool operator != (const KeyCount &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const KeyCount & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _Deletion__isset {
   _Deletion__isset() : timestamp(false), super_column(false), predicate(false) {}
   bool timestamp;
   bool super_column;
   bool predicate;
 } _Deletion__isset;
 
 class Deletion {
  public:
 
   static const char* ascii_fingerprint; // = "40F33ECF1C932CA77C2414C4E6C60CBE";
   static const uint8_t binary_fingerprint[16]; // = {0x40,0xF3,0x3E,0xCF,0x1C,0x93,0x2C,0xA7,0x7C,0x24,0x14,0xC4,0xE6,0xC6,0x0C,0xBE};
 
   Deletion() : timestamp(0), super_column("") {
   }
 
   virtual ~Deletion() throw() {}
 
   int64_t timestamp;
   std::string super_column;
   SlicePredicate predicate;
 
   _Deletion__isset __isset;
 
   bool operator == (const Deletion & rhs) const
   {
     if (__isset.timestamp != rhs.__isset.timestamp)
       return false;
     else if (__isset.timestamp && !(timestamp == rhs.timestamp))
       return false;
     if (__isset.super_column != rhs.__isset.super_column)
       return false;
     else if (__isset.super_column && !(super_column == rhs.super_column))
       return false;
     if (__isset.predicate != rhs.__isset.predicate)
       return false;
     else if (__isset.predicate && !(predicate == rhs.predicate))
       return false;
     return true;
   }
   bool operator != (const Deletion &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const Deletion & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _Mutation__isset {
   _Mutation__isset() : column_or_supercolumn(false), deletion(false) {}
   bool column_or_supercolumn;
   bool deletion;
 } _Mutation__isset;
 
 class Mutation {
  public:
 
   static const char* ascii_fingerprint; // = "E8B65DF3979C6868F80DF81F8E769E63";
   static const uint8_t binary_fingerprint[16]; // = {0xE8,0xB6,0x5D,0xF3,0x97,0x9C,0x68,0x68,0xF8,0x0D,0xF8,0x1F,0x8E,0x76,0x9E,0x63};
 
   Mutation() {
   }
 
   virtual ~Mutation() throw() {}
 
   ColumnOrSuperColumn column_or_supercolumn;
   Deletion deletion;
 
   _Mutation__isset __isset;
 
   bool operator == (const Mutation & rhs) const
   {
     if (__isset.column_or_supercolumn != rhs.__isset.column_or_supercolumn)
       return false;
     else if (__isset.column_or_supercolumn && !(column_or_supercolumn == rhs.column_or_supercolumn))
       return false;
     if (__isset.deletion != rhs.__isset.deletion)
       return false;
     else if (__isset.deletion && !(deletion == rhs.deletion))
       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 _EndpointDetails__isset {
   _EndpointDetails__isset() : host(false), datacenter(false) {}
   bool host;
   bool datacenter;
 } _EndpointDetails__isset;
 
 class EndpointDetails {
  public:
 
   static const char* ascii_fingerprint; // = "07A9615F837F7D0A952B595DD3020972";
   static const uint8_t binary_fingerprint[16]; // = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
 
   EndpointDetails() : host(""), datacenter("") {
   }
 
   virtual ~EndpointDetails() throw() {}
 
   std::string host;
   std::string datacenter;
 
   _EndpointDetails__isset __isset;
 
   bool operator == (const EndpointDetails & rhs) const
   {
     if (!(host == rhs.host))
       return false;
     if (!(datacenter == rhs.datacenter))
       return false;
     return true;
   }
   bool operator != (const EndpointDetails &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const EndpointDetails & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _TokenRange__isset {
   _TokenRange__isset() : rpc_endpoints(false), endpoint_details(false) {}
   bool rpc_endpoints;
   bool endpoint_details;
 } _TokenRange__isset;
 
 class TokenRange {
  public:
 
   static const char* ascii_fingerprint; // = "B84955E63D0C14788839563285CBBDCF";
   static const uint8_t binary_fingerprint[16]; // = {0xB8,0x49,0x55,0xE6,0x3D,0x0C,0x14,0x78,0x88,0x39,0x56,0x32,0x85,0xCB,0xBD,0xCF};
 
   TokenRange() : start_token(""), end_token("") {
   }
 
   virtual ~TokenRange() throw() {}
 
   std::string start_token;
   std::string end_token;
   std::vector<std::string>  endpoints;
   std::vector<std::string>  rpc_endpoints;
   std::vector<EndpointDetails>  endpoint_details;
 
   _TokenRange__isset __isset;
 
   bool operator == (const TokenRange & rhs) const
   {
     if (!(start_token == rhs.start_token))
       return false;
     if (!(end_token == rhs.end_token))
       return false;
     if (!(endpoints == rhs.endpoints))
       return false;
     if (__isset.rpc_endpoints != rhs.__isset.rpc_endpoints)
       return false;
     else if (__isset.rpc_endpoints && !(rpc_endpoints == rhs.rpc_endpoints))
       return false;
     if (__isset.endpoint_details != rhs.__isset.endpoint_details)
       return false;
     else if (__isset.endpoint_details && !(endpoint_details == rhs.endpoint_details))
       return false;
     return true;
   }
   bool operator != (const TokenRange &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const TokenRange & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class AuthenticationRequest {
  public:
 
   static const char* ascii_fingerprint; // = "5EA2D527ECA3BA20C77AFC023EE8C05F";
   static const uint8_t binary_fingerprint[16]; // = {0x5E,0xA2,0xD5,0x27,0xEC,0xA3,0xBA,0x20,0xC7,0x7A,0xFC,0x02,0x3E,0xE8,0xC0,0x5F};
 
   AuthenticationRequest() {
   }
 
   virtual ~AuthenticationRequest() throw() {}
 
   std::map<std::string, std::string>  credentials;
 
   bool operator == (const AuthenticationRequest & rhs) const
   {
     if (!(credentials == rhs.credentials))
       return false;
     return true;
   }
   bool operator != (const AuthenticationRequest &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const AuthenticationRequest & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _ColumnDef__isset {
   _ColumnDef__isset() : index_type(false), index_name(false), index_options(false) {}
   bool index_type;
   bool index_name;
   bool index_options;
 } _ColumnDef__isset;
 
 class ColumnDef {
  public:
 
   static const char* ascii_fingerprint; // = "0D89CE83D7EDAD079AC3213ED1DCAA58";
   static const uint8_t binary_fingerprint[16]; // = {0x0D,0x89,0xCE,0x83,0xD7,0xED,0xAD,0x07,0x9A,0xC3,0x21,0x3E,0xD1,0xDC,0xAA,0x58};
 
   ColumnDef() : name(""), validation_class(""), index_name("") {
   }
 
   virtual ~ColumnDef() throw() {}
 
   std::string name;
   std::string validation_class;
   IndexType::type index_type;
   std::string index_name;
   std::map<std::string, std::string>  index_options;
 
   _ColumnDef__isset __isset;
 
   bool operator == (const ColumnDef & rhs) const
   {
     if (!(name == rhs.name))
       return false;
     if (!(validation_class == rhs.validation_class))
       return false;
     if (__isset.index_type != rhs.__isset.index_type)
       return false;
     else if (__isset.index_type && !(index_type == rhs.index_type))
       return false;
     if (__isset.index_name != rhs.__isset.index_name)
       return false;
     else if (__isset.index_name && !(index_name == rhs.index_name))
       return false;
     if (__isset.index_options != rhs.__isset.index_options)
       return false;
     else if (__isset.index_options && !(index_options == rhs.index_options))
       return false;
     return true;
   }
   bool operator != (const ColumnDef &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const ColumnDef & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _CfDef__isset {
   _CfDef__isset() : column_type(false), comparator_type(false), subcomparator_type(false), comment(false), row_cache_size(false), key_cache_size(false), read_repair_chance(false), column_metadata(false), gc_grace_seconds(false), default_validation_class(false), id(false), min_compaction_threshold(false), max_compaction_threshold(false), row_cache_save_period_in_seconds(false), key_cache_save_period_in_seconds(false), replicate_on_write(false), merge_shards_chance(false), key_validation_class(false), row_cache_provider(false), key_alias(false), compaction_strategy(false), compaction_strategy_options(false), row_cache_keys_to_save(false), compression_options(false) {}
   bool column_type;
   bool comparator_type;
   bool subcomparator_type;
   bool comment;
   bool row_cache_size;
   bool key_cache_size;
   bool read_repair_chance;
   bool column_metadata;
   bool gc_grace_seconds;
   bool default_validation_class;
   bool id;
   bool min_compaction_threshold;
   bool max_compaction_threshold;
   bool row_cache_save_period_in_seconds;
   bool key_cache_save_period_in_seconds;
   bool replicate_on_write;
   bool merge_shards_chance;
   bool key_validation_class;
   bool row_cache_provider;
   bool key_alias;
   bool compaction_strategy;
   bool compaction_strategy_options;
   bool row_cache_keys_to_save;
   bool compression_options;
 } _CfDef__isset;
 
 class CfDef {
  public:
 
   static const char* ascii_fingerprint; // = "0FA1E255DEA2A1E59044B44DA8536D18";
   static const uint8_t binary_fingerprint[16]; // = {0x0F,0xA1,0xE2,0x55,0xDE,0xA2,0xA1,0xE5,0x90,0x44,0xB4,0x4D,0xA8,0x53,0x6D,0x18};
 
   CfDef() : keyspace(""), name(""), column_type("Standard"), comparator_type("BytesType"), subcomparator_type(""), comment(""), row_cache_size(0), key_cache_size(200000), read_repair_chance(1), gc_grace_seconds(0), default_validation_class(""), id(0), min_compaction_threshold(0), max_compaction_threshold(0), row_cache_save_period_in_seconds(0), key_cache_save_period_in_seconds(0), replicate_on_write(0), merge_shards_chance(0), key_validation_class(""), row_cache_provider(""), key_alias(""), compaction_strategy(""), row_cache_keys_to_save(0) {
   }
 
   virtual ~CfDef() throw() {}
 
   std::string keyspace;
   std::string name;
   std::string column_type;
   std::string comparator_type;
   std::string subcomparator_type;
   std::string comment;
   double row_cache_size;
   double key_cache_size;
   double read_repair_chance;
   std::vector<ColumnDef>  column_metadata;
   int32_t gc_grace_seconds;
   std::string default_validation_class;
   int32_t id;
   int32_t min_compaction_threshold;
   int32_t max_compaction_threshold;
   int32_t row_cache_save_period_in_seconds;
   int32_t key_cache_save_period_in_seconds;
   bool replicate_on_write;
   double merge_shards_chance;
   std::string key_validation_class;
   std::string row_cache_provider;
   std::string key_alias;
   std::string compaction_strategy;
   std::map<std::string, std::string>  compaction_strategy_options;
   int32_t row_cache_keys_to_save;
   std::map<std::string, std::string>  compression_options;
 
   _CfDef__isset __isset;
 
   bool operator == (const CfDef & rhs) const
   {
     if (!(keyspace == rhs.keyspace))
       return false;
     if (!(name == rhs.name))
       return false;
     if (__isset.column_type != rhs.__isset.column_type)
       return false;
     else if (__isset.column_type && !(column_type == rhs.column_type))
       return false;
     if (__isset.comparator_type != rhs.__isset.comparator_type)
       return false;
     else if (__isset.comparator_type && !(comparator_type == rhs.comparator_type))
       return false;
     if (__isset.subcomparator_type != rhs.__isset.subcomparator_type)
       return false;
     else if (__isset.subcomparator_type && !(subcomparator_type == rhs.subcomparator_type))
       return false;
     if (__isset.comment != rhs.__isset.comment)
       return false;
     else if (__isset.comment && !(comment == rhs.comment))
       return false;
     if (__isset.row_cache_size != rhs.__isset.row_cache_size)
       return false;
     else if (__isset.row_cache_size && !(row_cache_size == rhs.row_cache_size))
       return false;
     if (__isset.key_cache_size != rhs.__isset.key_cache_size)
       return false;
     else if (__isset.key_cache_size && !(key_cache_size == rhs.key_cache_size))
       return false;
     if (__isset.read_repair_chance != rhs.__isset.read_repair_chance)
       return false;
     else if (__isset.read_repair_chance && !(read_repair_chance == rhs.read_repair_chance))
       return false;
     if (__isset.column_metadata != rhs.__isset.column_metadata)
       return false;
     else if (__isset.column_metadata && !(column_metadata == rhs.column_metadata))
       return false;
     if (__isset.gc_grace_seconds != rhs.__isset.gc_grace_seconds)
       return false;
     else if (__isset.gc_grace_seconds && !(gc_grace_seconds == rhs.gc_grace_seconds))
       return false;
     if (__isset.default_validation_class != rhs.__isset.default_validation_class)
       return false;
     else if (__isset.default_validation_class && !(default_validation_class == rhs.default_validation_class))
       return false;
     if (__isset.id != rhs.__isset.id)
       return false;
     else if (__isset.id && !(id == rhs.id))
       return false;
     if (__isset.min_compaction_threshold != rhs.__isset.min_compaction_threshold)
       return false;
     else if (__isset.min_compaction_threshold && !(min_compaction_threshold == rhs.min_compaction_threshold))
       return false;
     if (__isset.max_compaction_threshold != rhs.__isset.max_compaction_threshold)
       return false;
     else if (__isset.max_compaction_threshold && !(max_compaction_threshold == rhs.max_compaction_threshold))
       return false;
     if (__isset.row_cache_save_period_in_seconds != rhs.__isset.row_cache_save_period_in_seconds)
       return false;
     else if (__isset.row_cache_save_period_in_seconds && !(row_cache_save_period_in_seconds == rhs.row_cache_save_period_in_seconds))
       return false;
     if (__isset.key_cache_save_period_in_seconds != rhs.__isset.key_cache_save_period_in_seconds)
       return false;
     else if (__isset.key_cache_save_period_in_seconds && !(key_cache_save_period_in_seconds == rhs.key_cache_save_period_in_seconds))
       return false;
     if (__isset.replicate_on_write != rhs.__isset.replicate_on_write)
       return false;
     else if (__isset.replicate_on_write && !(replicate_on_write == rhs.replicate_on_write))
       return false;
     if (__isset.merge_shards_chance != rhs.__isset.merge_shards_chance)
       return false;
     else if (__isset.merge_shards_chance && !(merge_shards_chance == rhs.merge_shards_chance))
       return false;
     if (__isset.key_validation_class != rhs.__isset.key_validation_class)
       return false;
     else if (__isset.key_validation_class && !(key_validation_class == rhs.key_validation_class))
       return false;
     if (__isset.row_cache_provider != rhs.__isset.row_cache_provider)
       return false;
     else if (__isset.row_cache_provider && !(row_cache_provider == rhs.row_cache_provider))
       return false;
     if (__isset.key_alias != rhs.__isset.key_alias)
       return false;
     else if (__isset.key_alias && !(key_alias == rhs.key_alias))
       return false;
     if (__isset.compaction_strategy != rhs.__isset.compaction_strategy)
       return false;
     else if (__isset.compaction_strategy && !(compaction_strategy == rhs.compaction_strategy))
       return false;
     if (__isset.compaction_strategy_options != rhs.__isset.compaction_strategy_options)
       return false;
     else if (__isset.compaction_strategy_options && !(compaction_strategy_options == rhs.compaction_strategy_options))
       return false;
     if (__isset.row_cache_keys_to_save != rhs.__isset.row_cache_keys_to_save)
       return false;
     else if (__isset.row_cache_keys_to_save && !(row_cache_keys_to_save == rhs.row_cache_keys_to_save))
       return false;
     if (__isset.compression_options != rhs.__isset.compression_options)
       return false;
     else if (__isset.compression_options && !(compression_options == rhs.compression_options))
       return false;
     return true;
   }
   bool operator != (const CfDef &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const CfDef & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _KsDef__isset {
   _KsDef__isset() : strategy_options(false), replication_factor(false), durable_writes(false) {}
   bool strategy_options;
   bool replication_factor;
   bool durable_writes;
 } _KsDef__isset;
 
 class KsDef {
  public:
 
   static const char* ascii_fingerprint; // = "28433565DB1070CD6C4372A762397EFE";
   static const uint8_t binary_fingerprint[16]; // = {0x28,0x43,0x35,0x65,0xDB,0x10,0x70,0xCD,0x6C,0x43,0x72,0xA7,0x62,0x39,0x7E,0xFE};
 
   KsDef() : name(""), strategy_class(""), replication_factor(0), durable_writes(true) {
   }
 
   virtual ~KsDef() throw() {}
 
   std::string name;
   std::string strategy_class;
   std::map<std::string, std::string>  strategy_options;
   int32_t replication_factor;
   std::vector<CfDef>  cf_defs;
   bool durable_writes;
 
   _KsDef__isset __isset;
 
   bool operator == (const KsDef & rhs) const
   {
     if (!(name == rhs.name))
       return false;
     if (!(strategy_class == rhs.strategy_class))
       return false;
     if (__isset.strategy_options != rhs.__isset.strategy_options)
       return false;
     else if (__isset.strategy_options && !(strategy_options == rhs.strategy_options))
       return false;
     if (__isset.replication_factor != rhs.__isset.replication_factor)
       return false;
     else if (__isset.replication_factor && !(replication_factor == rhs.replication_factor))
       return false;
     if (!(cf_defs == rhs.cf_defs))
       return false;
     if (__isset.durable_writes != rhs.__isset.durable_writes)
       return false;
     else if (__isset.durable_writes && !(durable_writes == rhs.durable_writes))
       return false;
     return true;
   }
   bool operator != (const KsDef &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const KsDef & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class CqlRow {
  public:
 
   static const char* ascii_fingerprint; // = "470EFC558004E98D92D604898305C04E";
   static const uint8_t binary_fingerprint[16]; // = {0x47,0x0E,0xFC,0x55,0x80,0x04,0xE9,0x8D,0x92,0xD6,0x04,0x89,0x83,0x05,0xC0,0x4E};
 
   CqlRow() : key("") {
   }
 
   virtual ~CqlRow() throw() {}
 
   std::string key;
   std::vector<Column>  columns;
 
   bool operator == (const CqlRow & rhs) const
   {
     if (!(key == rhs.key))
       return false;
     if (!(columns == rhs.columns))
       return false;
     return true;
   }
   bool operator != (const CqlRow &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const CqlRow & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 
 class CqlMetadata {
  public:
 
   static const char* ascii_fingerprint; // = "B7C5A4AA9652C744A48EBC1C12D531E7";
   static const uint8_t binary_fingerprint[16]; // = {0xB7,0xC5,0xA4,0xAA,0x96,0x52,0xC7,0x44,0xA4,0x8E,0xBC,0x1C,0x12,0xD5,0x31,0xE7};
 
   CqlMetadata() : default_name_type(""), default_value_type("") {
   }
 
   virtual ~CqlMetadata() throw() {}
 
   std::map<std::string, std::string>  name_types;
   std::map<std::string, std::string>  value_types;
   std::string default_name_type;
   std::string default_value_type;
 
   bool operator == (const CqlMetadata & rhs) const
   {
     if (!(name_types == rhs.name_types))
       return false;
     if (!(value_types == rhs.value_types))
       return false;
     if (!(default_name_type == rhs.default_name_type))
       return false;
     if (!(default_value_type == rhs.default_value_type))
       return false;
     return true;
   }
   bool operator != (const CqlMetadata &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const CqlMetadata & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 typedef struct _CqlResult__isset {
   _CqlResult__isset() : rows(false), num(false), schema(false) {}
   bool rows;
   bool num;
   bool schema;
 } _CqlResult__isset;
 
 class CqlResult {
  public:
 
   static const char* ascii_fingerprint; // = "521B9CE5AF77539F7267F6952B609E81";
   static const uint8_t binary_fingerprint[16]; // = {0x52,0x1B,0x9C,0xE5,0xAF,0x77,0x53,0x9F,0x72,0x67,0xF6,0x95,0x2B,0x60,0x9E,0x81};
 
   CqlResult() : num(0) {
   }
 
   virtual ~CqlResult() throw() {}
 
   CqlResultType::type type;
   std::vector<CqlRow>  rows;
   int32_t num;
   CqlMetadata schema;
 
   _CqlResult__isset __isset;
 
   bool operator == (const CqlResult & rhs) const
   {
     if (!(type == rhs.type))
       return false;
     if (__isset.rows != rhs.__isset.rows)
       return false;
     else if (__isset.rows && !(rows == rhs.rows))
       return false;
     if (__isset.num != rhs.__isset.num)
       return false;
     else if (__isset.num && !(num == rhs.num))
       return false;
     if (__isset.schema != rhs.__isset.schema)
       return false;
     else if (__isset.schema && !(schema == rhs.schema))
       return false;
     return true;
   }
   bool operator != (const CqlResult &rhs) const {
     return !(*this == rhs);
   }
 
   bool operator < (const CqlResult & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
 }}} // namespace
 
 #endif