cassandra_types.h

#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