path: root/storage/cassandra/gen-cpp/cassandra_types.h

/**
 * Autogenerated by Thrift Compiler (0.8.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef cassandra_TYPES_H
#define cassandra_TYPES_H

#include <inttypes.h>
#include <netinet/in.h>

#include <thrift/Thrift.h>
#include <thrift/TApplicationException.h>
#include <thrift/protocol/TProtocol.h>
#include <thrift/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;

  void __set_name(const std::string& val) {
    name = val;
  }

  void __set_value(const std::string& val) {
    value = val;
    __isset.value = true;
  }

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

  void __set_ttl(const int32_t val) {
    ttl = val;
    __isset.ttl = true;
  }

  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;

  void __set_name(const std::string& val) {
    name = val;
  }

  void __set_columns(const std::vector<Column> & val) {
    columns = val;
  }

  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;

  void __set_name(const std::string& val) {
    name = val;
  }

  void __set_value(const int64_t val) {
    value = val;
  }

  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;

  void __set_name(const std::string& val) {
    name = val;
  }

  void __set_columns(const std::vector<CounterColumn> & val) {
    columns = val;
  }

  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;

  void __set_column(const Column& val) {
    column = val;
    __isset.column = true;
  }

  void __set_super_column(const SuperColumn& val) {
    super_column = val;
    __isset.super_column = true;
  }

  void __set_counter_column(const CounterColumn& val) {
    counter_column = val;
    __isset.counter_column = true;
  }

  void __set_counter_super_column(const CounterSuperColumn& val) {
    counter_super_column = val;
    __isset.counter_super_column = true;
  }

  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;

  void __set_why(const std::string& val) {
    why = val;
  }

  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;

  void __set_why(const std::string& val) {
    why = val;
  }

  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;

  void __set_why(const std::string& val) {
    why = val;
  }

  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;

  void __set_column_family(const std::string& val) {
    column_family = val;
  }

  void __set_super_column(const std::string& val) {
    super_column = val;
    __isset.super_column = true;
  }

  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;

  void __set_column_family(const std::string& val) {
    column_family = val;
  }

  void __set_super_column(const std::string& val) {
    super_column = val;
    __isset.super_column = true;
  }

  void __set_column(const std::string& val) {
    column = val;
    __isset.column = true;
  }

  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;

  void __set_start(const std::string& val) {
    start = val;
  }

  void __set_finish(const std::string& val) {
    finish = val;
  }

  void __set_reversed(const bool val) {
    reversed = val;
  }

  void __set_count(const int32_t val) {
    count = val;
  }

  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;

  void __set_column_names(const std::vector<std::string> & val) {
    column_names = val;
    __isset.column_names = true;
  }

  void __set_slice_range(const SliceRange& val) {
    slice_range = val;
    __isset.slice_range = true;
  }

  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(""), op((IndexOperator::type)0), value("") {
  }

  virtual ~IndexExpression() throw() {}

  std::string column_name;
  IndexOperator::type op;
  std::string value;

  void __set_column_name(const std::string& val) {
    column_name = val;
  }

  void __set_op(const IndexOperator::type val) {
    op = val;
  }

  void __set_value(const std::string& val) {
    value = val;
  }

  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;

  void __set_expressions(const std::vector<IndexExpression> & val) {
    expressions = val;
  }

  void __set_start_key(const std::string& val) {
    start_key = val;
  }

  void __set_count(const int32_t val) {
    count = val;
  }

  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), row_filter(false) {}
  bool start_key;
  bool end_key;
  bool start_token;
  bool end_token;
  bool row_filter;
} _KeyRange__isset;

class KeyRange {
 public:

  static const char* ascii_fingerprint; // = "A6EC82FA0980B91C7C8EB013C61CA1B0";
  static const uint8_t binary_fingerprint[16]; // = {0xA6,0xEC,0x82,0xFA,0x09,0x80,0xB9,0x1C,0x7C,0x8E,0xB0,0x13,0xC6,0x1C,0xA1,0xB0};

  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;
  std::vector<IndexExpression>  row_filter;
  int32_t count;

  _KeyRange__isset __isset;

  void __set_start_key(const std::string& val) {
    start_key = val;
    __isset.start_key = true;
  }

  void __set_end_key(const std::string& val) {
    end_key = val;
    __isset.end_key = true;
  }

  void __set_start_token(const std::string& val) {
    start_token = val;
    __isset.start_token = true;
  }

  void __set_end_token(const std::string& val) {
    end_token = val;
    __isset.end_token = true;
  }

  void __set_row_filter(const std::vector<IndexExpression> & val) {
    row_filter = val;
    __isset.row_filter = true;
  }

  void __set_count(const int32_t val) {
    count = val;
  }

  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 (__isset.row_filter != rhs.__isset.row_filter)
      return false;
    else if (__isset.row_filter && !(row_filter == rhs.row_filter))
      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;

  void __set_key(const std::string& val) {
    key = val;
  }

  void __set_columns(const std::vector<ColumnOrSuperColumn> & val) {
    columns = val;
  }

  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;

  void __set_key(const std::string& val) {
    key = val;
  }

  void __set_count(const int32_t val) {
    count = val;
  }

  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;

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

  void __set_super_column(const std::string& val) {
    super_column = val;
    __isset.super_column = true;
  }

  void __set_predicate(const SlicePredicate& val) {
    predicate = val;
    __isset.predicate = true;
  }

  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;

  void __set_column_or_supercolumn(const ColumnOrSuperColumn& val) {
    column_or_supercolumn = val;
    __isset.column_or_supercolumn = true;
  }

  void __set_deletion(const Deletion& val) {
    deletion = val;
    __isset.deletion = true;
  }

  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), rack(false) {}
  bool host;
  bool datacenter;
  bool rack;
} _EndpointDetails__isset;

class EndpointDetails {
 public:

  static const char* ascii_fingerprint; // = "F4A50F0EC638C7F66026F9B6678FD89B";
  static const uint8_t binary_fingerprint[16]; // = {0xF4,0xA5,0x0F,0x0E,0xC6,0x38,0xC7,0xF6,0x60,0x26,0xF9,0xB6,0x67,0x8F,0xD8,0x9B};

  EndpointDetails() : host(""), datacenter(""), rack("") {
  }

  virtual ~EndpointDetails() throw() {}

  std::string host;
  std::string datacenter;
  std::string rack;

  _EndpointDetails__isset __isset;

  void __set_host(const std::string& val) {
    host = val;
  }

  void __set_datacenter(const std::string& val) {
    datacenter = val;
  }

  void __set_rack(const std::string& val) {
    rack = val;
    __isset.rack = true;
  }

  bool operator == (const EndpointDetails & rhs) const
  {
    if (!(host == rhs.host))
      return false;
    if (!(datacenter == rhs.datacenter))
      return false;
    if (__isset.rack != rhs.__isset.rack)
      return false;
    else if (__isset.rack && !(rack == rhs.rack))
      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; // = "832268DC4CD6B17EE8881FC57EA04679";
  static const uint8_t binary_fingerprint[16]; // = {0x83,0x22,0x68,0xDC,0x4C,0xD6,0xB1,0x7E,0xE8,0x88,0x1F,0xC5,0x7E,0xA0,0x46,0x79};

  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;

  void __set_start_token(const std::string& val) {
    start_token = val;
  }

  void __set_end_token(const std::string& val) {
    end_token = val;
  }

  void __set_endpoints(const std::vector<std::string> & val) {
    endpoints = val;
  }

  void __set_rpc_endpoints(const std::vector<std::string> & val) {
    rpc_endpoints = val;
    __isset.rpc_endpoints = true;
  }

  void __set_endpoint_details(const std::vector<EndpointDetails> & val) {
    endpoint_details = val;
    __isset.endpoint_details = true;
  }

  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;

  void __set_credentials(const std::map<std::string, std::string> & val) {
    credentials = val;
  }

  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_type((IndexType::type)0), 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;

  void __set_name(const std::string& val) {
    name = val;
  }

  void __set_validation_class(const std::string& val) {
    validation_class = val;
  }

  void __set_index_type(const IndexType::type val) {
    index_type = val;
    __isset.index_type = true;
  }

  void __set_index_name(const std::string& val) {
    index_name = val;
    __isset.index_name = true;
  }

  void __set_index_options(const std::map<std::string, std::string> & val) {
    index_options = val;
    __isset.index_options = true;
  }

  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), 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), replicate_on_write(false), key_validation_class(false), key_alias(false), compaction_strategy(false), compaction_strategy_options(false), compression_options(false), bloom_filter_fp_chance(false), caching(false), dclocal_read_repair_chance(false), row_cache_size(false), key_cache_size(false), row_cache_save_period_in_seconds(false), key_cache_save_period_in_seconds(false), memtable_flush_after_mins(false), memtable_throughput_in_mb(false), memtable_operations_in_millions(false), merge_shards_chance(false), row_cache_provider(false), row_cache_keys_to_save(false) {}
  bool column_type;
  bool comparator_type;
  bool subcomparator_type;
  bool comment;
  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 replicate_on_write;
  bool key_validation_class;
  bool key_alias;
  bool compaction_strategy;
  bool compaction_strategy_options;
  bool compression_options;
  bool bloom_filter_fp_chance;
  bool caching;
  bool dclocal_read_repair_chance;
  bool row_cache_size;
  bool key_cache_size;
  bool row_cache_save_period_in_seconds;
  bool key_cache_save_period_in_seconds;
  bool memtable_flush_after_mins;
  bool memtable_throughput_in_mb;
  bool memtable_operations_in_millions;
  bool merge_shards_chance;
  bool row_cache_provider;
  bool row_cache_keys_to_save;
} _CfDef__isset;

class CfDef {
 public:

  static const char* ascii_fingerprint; // = "231A260521B5DD99EFBCCBDD8768CA7D";
  static const uint8_t binary_fingerprint[16]; // = {0x23,0x1A,0x26,0x05,0x21,0xB5,0xDD,0x99,0xEF,0xBC,0xCB,0xDD,0x87,0x68,0xCA,0x7D};

  CfDef() : keyspace(""), name(""), column_type("Standard"), comparator_type("BytesType"), subcomparator_type(""), comment(""), read_repair_chance(0), gc_grace_seconds(0), default_validation_class(""), id(0), min_compaction_threshold(0), max_compaction_threshold(0), replicate_on_write(0), key_validation_class(""), key_alias(""), compaction_strategy(""), bloom_filter_fp_chance(0), caching("keys_only"), dclocal_read_repair_chance(0), row_cache_size(0), key_cache_size(0), row_cache_save_period_in_seconds(0), key_cache_save_period_in_seconds(0), memtable_flush_after_mins(0), memtable_throughput_in_mb(0), memtable_operations_in_millions(0), merge_shards_chance(0), row_cache_provider(""), 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 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;
  bool replicate_on_write;
  std::string key_validation_class;
  std::string key_alias;
  std::string compaction_strategy;
  std::map<std::string, std::string>  compaction_strategy_options;
  std::map<std::string, std::string>  compression_options;
  double bloom_filter_fp_chance;
  std::string caching;
  double dclocal_read_repair_chance;
  double row_cache_size;
  double key_cache_size;
  int32_t row_cache_save_period_in_seconds;
  int32_t key_cache_save_period_in_seconds;
  int32_t memtable_flush_after_mins;
  int32_t memtable_throughput_in_mb;
  double memtable_operations_in_millions;
  double merge_shards_chance;
  std::string row_cache_provider;
  int32_t row_cache_keys_to_save;

  _CfDef__isset __isset;

  void __set_keyspace(const std::string& val) {
    keyspace = val;
  }

  void __set_name(const std::string& val) {
    name = val;
  }

  void __set_column_type(const std::string& val) {
    column_type = val;
    __isset.column_type = true;
  }

  void __set_comparator_type(const std::string& val) {
    comparator_type = val;
    __isset.comparator_type = true;
  }

  void __set_subcomparator_type(const std::string& val) {
    subcomparator_type = val;
    __isset.subcomparator_type = true;
  }

  void __set_comment(const std::string& val) {
    comment = val;
    __isset.comment = true;
  }

  void __set_read_repair_chance(const double val) {
    read_repair_chance = val;
    __isset.read_repair_chance = true;
  }

  void __set_column_metadata(const std::vector<ColumnDef> & val) {
    column_metadata = val;
    __isset.column_metadata = true;
  }

  void __set_gc_grace_seconds(const int32_t val) {
    gc_grace_seconds = val;
    __isset.gc_grace_seconds = true;
  }

  void __set_default_validation_class(const std::string& val) {
    default_validation_class = val;
    __isset.default_validation_class = true;
  }

  void __set_id(const int32_t val) {
    id = val;
    __isset.id = true;
  }

  void __set_min_compaction_threshold(const int32_t val) {
    min_compaction_threshold = val;
    __isset.min_compaction_threshold = true;
  }

  void __set_max_compaction_threshold(const int32_t val) {
    max_compaction_threshold = val;
    __isset.max_compaction_threshold = true;
  }

  void __set_replicate_on_write(const bool val) {
    replicate_on_write = val;
    __isset.replicate_on_write = true;
  }

  void __set_key_validation_class(const std::string& val) {
    key_validation_class = val;
    __isset.key_validation_class = true;
  }

  void __set_key_alias(const std::string& val) {
    key_alias = val;
    __isset.key_alias = true;
  }

  void __set_compaction_strategy(const std::string& val) {
    compaction_strategy = val;
    __isset.compaction_strategy = true;
  }

  void __set_compaction_strategy_options(const std::map<std::string, std::string> & val) {
    compaction_strategy_options = val;
    __isset.compaction_strategy_options = true;
  }

  void __set_compression_options(const std::map<std::string, std::string> & val) {
    compression_options = val;
    __isset.compression_options = true;
  }

  void __set_bloom_filter_fp_chance(const double val) {
    bloom_filter_fp_chance = val;
    __isset.bloom_filter_fp_chance = true;
  }

  void __set_caching(const std::string& val) {
    caching = val;
    __isset.caching = true;
  }

  void __set_dclocal_read_repair_chance(const double val) {
    dclocal_read_repair_chance = val;
    __isset.dclocal_read_repair_chance = true;
  }

  void __set_row_cache_size(const double val) {
    row_cache_size = val;
    __isset.row_cache_size = true;
  }

  void __set_key_cache_size(const double val) {
    key_cache_size = val;
    __isset.key_cache_size = true;
  }

  void __set_row_cache_save_period_in_seconds(const int32_t val) {
    row_cache_save_period_in_seconds = val;
    __isset.row_cache_save_period_in_seconds = true;
  }

  void __set_key_cache_save_period_in_seconds(const int32_t val) {
    key_cache_save_period_in_seconds = val;
    __isset.key_cache_save_period_in_seconds = true;
  }

  void __set_memtable_flush_after_mins(const int32_t val) {
    memtable_flush_after_mins = val;
    __isset.memtable_flush_after_mins = true;
  }

  void __set_memtable_throughput_in_mb(const int32_t val) {
    memtable_throughput_in_mb = val;
    __isset.memtable_throughput_in_mb = true;
  }

  void __set_memtable_operations_in_millions(const double val) {
    memtable_operations_in_millions = val;
    __isset.memtable_operations_in_millions = true;
  }

  void __set_merge_shards_chance(const double val) {
    merge_shards_chance = val;
    __isset.merge_shards_chance = true;
  }

  void __set_row_cache_provider(const std::string& val) {
    row_cache_provider = val;
    __isset.row_cache_provider = true;
  }

  void __set_row_cache_keys_to_save(const int32_t val) {
    row_cache_keys_to_save = val;
    __isset.row_cache_keys_to_save = true;
  }

  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.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.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.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.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.compression_options != rhs.__isset.compression_options)
      return false;
    else if (__isset.compression_options && !(compression_options == rhs.compression_options))
      return false;
    if (__isset.bloom_filter_fp_chance != rhs.__isset.bloom_filter_fp_chance)
      return false;
    else if (__isset.bloom_filter_fp_chance && !(bloom_filter_fp_chance == rhs.bloom_filter_fp_chance))
      return false;
    if (__isset.caching != rhs.__isset.caching)
      return false;
    else if (__isset.caching && !(caching == rhs.caching))
      return false;
    if (__isset.dclocal_read_repair_chance != rhs.__isset.dclocal_read_repair_chance)
      return false;
    else if (__isset.dclocal_read_repair_chance && !(dclocal_read_repair_chance == rhs.dclocal_read_repair_chance))
      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.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.memtable_flush_after_mins != rhs.__isset.memtable_flush_after_mins)
      return false;
    else if (__isset.memtable_flush_after_mins && !(memtable_flush_after_mins == rhs.memtable_flush_after_mins))
      return false;
    if (__isset.memtable_throughput_in_mb != rhs.__isset.memtable_throughput_in_mb)
      return false;
    else if (__isset.memtable_throughput_in_mb && !(memtable_throughput_in_mb == rhs.memtable_throughput_in_mb))
      return false;
    if (__isset.memtable_operations_in_millions != rhs.__isset.memtable_operations_in_millions)
      return false;
    else if (__isset.memtable_operations_in_millions && !(memtable_operations_in_millions == rhs.memtable_operations_in_millions))
      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.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.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;
    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; // = "0767851B6476EB3777A21E59E912E11A";
  static const uint8_t binary_fingerprint[16]; // = {0x07,0x67,0x85,0x1B,0x64,0x76,0xEB,0x37,0x77,0xA2,0x1E,0x59,0xE9,0x12,0xE1,0x1A};

  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;

  void __set_name(const std::string& val) {
    name = val;
  }

  void __set_strategy_class(const std::string& val) {
    strategy_class = val;
  }

  void __set_strategy_options(const std::map<std::string, std::string> & val) {
    strategy_options = val;
    __isset.strategy_options = true;
  }

  void __set_replication_factor(const int32_t val) {
    replication_factor = val;
    __isset.replication_factor = true;
  }

  void __set_cf_defs(const std::vector<CfDef> & val) {
    cf_defs = val;
  }

  void __set_durable_writes(const bool val) {
    durable_writes = val;
    __isset.durable_writes = true;
  }

  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;

  void __set_key(const std::string& val) {
    key = val;
  }

  void __set_columns(const std::vector<Column> & val) {
    columns = val;
  }

  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;

  void __set_name_types(const std::map<std::string, std::string> & val) {
    name_types = val;
  }

  void __set_value_types(const std::map<std::string, std::string> & val) {
    value_types = val;
  }

  void __set_default_name_type(const std::string& val) {
    default_name_type = val;
  }

  void __set_default_value_type(const std::string& val) {
    default_value_type = val;
  }

  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() : type((CqlResultType::type)0), num(0) {
  }

  virtual ~CqlResult() throw() {}

  CqlResultType::type type;
  std::vector<CqlRow>  rows;
  int32_t num;
  CqlMetadata schema;

  _CqlResult__isset __isset;

  void __set_type(const CqlResultType::type val) {
    type = val;
  }

  void __set_rows(const std::vector<CqlRow> & val) {
    rows = val;
    __isset.rows = true;
  }

  void __set_num(const int32_t val) {
    num = val;
    __isset.num = true;
  }

  void __set_schema(const CqlMetadata& val) {
    schema = val;
    __isset.schema = true;
  }

  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;

};

typedef struct _CqlPreparedResult__isset {
  _CqlPreparedResult__isset() : variable_types(false), variable_names(false) {}
  bool variable_types;
  bool variable_names;
} _CqlPreparedResult__isset;

class CqlPreparedResult {
 public:

  static const char* ascii_fingerprint; // = "7E1663EC688DFDC28722BF36F9F64E6F";
  static const uint8_t binary_fingerprint[16]; // = {0x7E,0x16,0x63,0xEC,0x68,0x8D,0xFD,0xC2,0x87,0x22,0xBF,0x36,0xF9,0xF6,0x4E,0x6F};

  CqlPreparedResult() : itemId(0), count(0) {
  }

  virtual ~CqlPreparedResult() throw() {}

  int32_t itemId;
  int32_t count;
  std::vector<std::string>  variable_types;
  std::vector<std::string>  variable_names;

  _CqlPreparedResult__isset __isset;

  void __set_itemId(const int32_t val) {
    itemId = val;
  }

  void __set_count(const int32_t val) {
    count = val;
  }

  void __set_variable_types(const std::vector<std::string> & val) {
    variable_types = val;
    __isset.variable_types = true;
  }

  void __set_variable_names(const std::vector<std::string> & val) {
    variable_names = val;
    __isset.variable_names = true;
  }

  bool operator == (const CqlPreparedResult & rhs) const
  {
    if (!(itemId == rhs.itemId))
      return false;
    if (!(count == rhs.count))
      return false;
    if (__isset.variable_types != rhs.__isset.variable_types)
      return false;
    else if (__isset.variable_types && !(variable_types == rhs.variable_types))
      return false;
    if (__isset.variable_names != rhs.__isset.variable_names)
      return false;
    else if (__isset.variable_names && !(variable_names == rhs.variable_names))
      return false;
    return true;
  }
  bool operator != (const CqlPreparedResult &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const CqlPreparedResult & ) const;

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

};

}}} // namespace

#endif