diff --git a/src/modules/db_cassandra/Cassandra.h b/src/modules/db_cassandra/Cassandra.h index 1946c7d94fc..7551da8fdfc 100644 --- a/src/modules/db_cassandra/Cassandra.h +++ b/src/modules/db_cassandra/Cassandra.h @@ -9,4085 +9,4885 @@ #include #include "cassandra_types.h" -namespace org { namespace apache { namespace cassandra { - -class CassandraIf { - public: - virtual ~CassandraIf() {} - virtual void login(const AuthenticationRequest& auth_request) = 0; - virtual void set_keyspace(const std::string& keyspace) = 0; - virtual void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) = 0; - virtual void get_slice(std::vector & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0; - virtual int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0; - virtual void multiget_slice(std::map > & _return, const std::vector & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0; - virtual void multiget_count(std::map & _return, const std::vector & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0; - virtual void get_range_slices(std::vector & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) = 0; - virtual void get_indexed_slices(std::vector & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level) = 0; - virtual void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) = 0; - virtual void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) = 0; - virtual void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) = 0; - virtual void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) = 0; - virtual void batch_mutate(const std::map > > & mutation_map, const ConsistencyLevel::type consistency_level) = 0; - virtual void truncate(const std::string& cfname) = 0; - virtual void describe_schema_versions(std::map > & _return) = 0; - virtual void describe_keyspaces(std::vector & _return) = 0; - virtual void describe_cluster_name(std::string& _return) = 0; - virtual void describe_version(std::string& _return) = 0; - virtual void describe_ring(std::vector & _return, const std::string& keyspace) = 0; - virtual void describe_partitioner(std::string& _return) = 0; - virtual void describe_snitch(std::string& _return) = 0; - virtual void describe_keyspace(KsDef& _return, const std::string& keyspace) = 0; - virtual void describe_splits(std::vector & _return, const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split) = 0; - virtual void system_add_column_family(std::string& _return, const CfDef& cf_def) = 0; - virtual void system_drop_column_family(std::string& _return, const std::string& column_family) = 0; - virtual void system_add_keyspace(std::string& _return, const KsDef& ks_def) = 0; - virtual void system_drop_keyspace(std::string& _return, const std::string& keyspace) = 0; - virtual void system_update_keyspace(std::string& _return, const KsDef& ks_def) = 0; - virtual void system_update_column_family(std::string& _return, const CfDef& cf_def) = 0; - virtual void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression) = 0; -}; - -class CassandraNull : virtual public CassandraIf { - public: - virtual ~CassandraNull() {} - void login(const AuthenticationRequest& /* auth_request */) { - return; - } - void set_keyspace(const std::string& /* keyspace */) { - return; - } - void get(ColumnOrSuperColumn& /* _return */, const std::string& /* key */, const ColumnPath& /* column_path */, const ConsistencyLevel::type /* consistency_level */) { - return; - } - void get_slice(std::vector & /* _return */, const std::string& /* key */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) { - return; - } - int32_t get_count(const std::string& /* key */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) { - int32_t _return = 0; - return _return; - } - void multiget_slice(std::map > & /* _return */, const std::vector & /* keys */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) { - return; - } - void multiget_count(std::map & /* _return */, const std::vector & /* keys */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) { - return; - } - void get_range_slices(std::vector & /* _return */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const KeyRange& /* range */, const ConsistencyLevel::type /* consistency_level */) { - return; - } - void get_indexed_slices(std::vector & /* _return */, const ColumnParent& /* column_parent */, const IndexClause& /* index_clause */, const SlicePredicate& /* column_predicate */, const ConsistencyLevel::type /* consistency_level */) { - return; - } - void insert(const std::string& /* key */, const ColumnParent& /* column_parent */, const Column& /* column */, const ConsistencyLevel::type /* consistency_level */) { - return; - } - void add(const std::string& /* key */, const ColumnParent& /* column_parent */, const CounterColumn& /* column */, const ConsistencyLevel::type /* consistency_level */) { - return; - } - void remove(const std::string& /* key */, const ColumnPath& /* column_path */, const int64_t /* timestamp */, const ConsistencyLevel::type /* consistency_level */) { - return; - } - void remove_counter(const std::string& /* key */, const ColumnPath& /* path */, const ConsistencyLevel::type /* consistency_level */) { - return; - } - void batch_mutate(const std::map > > & /* mutation_map */, const ConsistencyLevel::type /* consistency_level */) { - return; - } - void truncate(const std::string& /* cfname */) { - return; - } - void describe_schema_versions(std::map > & /* _return */) { - return; - } - void describe_keyspaces(std::vector & /* _return */) { - return; - } - void describe_cluster_name(std::string& /* _return */) { - return; - } - void describe_version(std::string& /* _return */) { - return; - } - void describe_ring(std::vector & /* _return */, const std::string& /* keyspace */) { - return; - } - void describe_partitioner(std::string& /* _return */) { - return; - } - void describe_snitch(std::string& /* _return */) { - return; - } - void describe_keyspace(KsDef& /* _return */, const std::string& /* keyspace */) { - return; - } - void describe_splits(std::vector & /* _return */, const std::string& /* cfName */, const std::string& /* start_token */, const std::string& /* end_token */, const int32_t /* keys_per_split */) { - return; - } - void system_add_column_family(std::string& /* _return */, const CfDef& /* cf_def */) { - return; - } - void system_drop_column_family(std::string& /* _return */, const std::string& /* column_family */) { - return; - } - void system_add_keyspace(std::string& /* _return */, const KsDef& /* ks_def */) { - return; - } - void system_drop_keyspace(std::string& /* _return */, const std::string& /* keyspace */) { - return; - } - void system_update_keyspace(std::string& /* _return */, const KsDef& /* ks_def */) { - return; - } - void system_update_column_family(std::string& /* _return */, const CfDef& /* cf_def */) { - return; - } - void execute_cql_query(CqlResult& /* _return */, const std::string& /* query */, const Compression::type /* compression */) { - return; - } -}; - - -class Cassandra_login_args { - public: - - Cassandra_login_args() { - } - - virtual ~Cassandra_login_args() throw() {} - - AuthenticationRequest auth_request; - - bool operator == (const Cassandra_login_args & rhs) const - { - if (!(auth_request == rhs.auth_request)) - return false; - return true; - } - bool operator != (const Cassandra_login_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_login_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_login_pargs { - public: - - - virtual ~Cassandra_login_pargs() throw() {} - - const AuthenticationRequest* auth_request; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_login_result__isset { - _Cassandra_login_result__isset() : authnx(false), authzx(false) {} - bool authnx; - bool authzx; +namespace org { +namespace apache { +namespace cassandra { + +class CassandraIf +{ +public: + virtual ~CassandraIf() + { + } + virtual void login(const AuthenticationRequest &auth_request) = 0; + virtual void set_keyspace(const std::string &keyspace) = 0; + virtual void get(ColumnOrSuperColumn &_return, const std::string &key, + const ColumnPath &column_path, + const ConsistencyLevel::type consistency_level) = 0; + virtual void get_slice(std::vector &_return, + const std::string &key, const ColumnParent &column_parent, + const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level) = 0; + virtual int32_t get_count(const std::string &key, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level) = 0; + virtual void multiget_slice( + std::map> &_return, + const std::vector &keys, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level) = 0; + virtual void multiget_count(std::map &_return, + const std::vector &keys, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level) = 0; + virtual void get_range_slices(std::vector &_return, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const KeyRange &range, + const ConsistencyLevel::type consistency_level) = 0; + virtual void get_indexed_slices(std::vector &_return, + const ColumnParent &column_parent, const IndexClause &index_clause, + const SlicePredicate &column_predicate, + const ConsistencyLevel::type consistency_level) = 0; + virtual void insert(const std::string &key, + const ColumnParent &column_parent, const Column &column, + const ConsistencyLevel::type consistency_level) = 0; + virtual void add(const std::string &key, const ColumnParent &column_parent, + const CounterColumn &column, + const ConsistencyLevel::type consistency_level) = 0; + virtual void remove(const std::string &key, const ColumnPath &column_path, + const int64_t timestamp, + const ConsistencyLevel::type consistency_level) = 0; + virtual void remove_counter(const std::string &key, const ColumnPath &path, + const ConsistencyLevel::type consistency_level) = 0; + virtual void batch_mutate( + const std::map>> &mutation_map, + const ConsistencyLevel::type consistency_level) = 0; + virtual void truncate(const std::string &cfname) = 0; + virtual void describe_schema_versions( + std::map> &_return) = 0; + virtual void describe_keyspaces(std::vector &_return) = 0; + virtual void describe_cluster_name(std::string &_return) = 0; + virtual void describe_version(std::string &_return) = 0; + virtual void describe_ring( + std::vector &_return, const std::string &keyspace) = 0; + virtual void describe_partitioner(std::string &_return) = 0; + virtual void describe_snitch(std::string &_return) = 0; + virtual void describe_keyspace( + KsDef &_return, const std::string &keyspace) = 0; + virtual void describe_splits(std::vector &_return, + const std::string &cfName, const std::string &start_token, + const std::string &end_token, const int32_t keys_per_split) = 0; + virtual void system_add_column_family( + std::string &_return, const CfDef &cf_def) = 0; + virtual void system_drop_column_family( + std::string &_return, const std::string &column_family) = 0; + virtual void system_add_keyspace( + std::string &_return, const KsDef &ks_def) = 0; + virtual void system_drop_keyspace( + std::string &_return, const std::string &keyspace) = 0; + virtual void system_update_keyspace( + std::string &_return, const KsDef &ks_def) = 0; + virtual void system_update_column_family( + std::string &_return, const CfDef &cf_def) = 0; + virtual void execute_cql_query(CqlResult &_return, const std::string &query, + const Compression::type compression) = 0; +}; + +class CassandraNull : virtual public CassandraIf +{ +public: + virtual ~CassandraNull() + { + } + void login(const AuthenticationRequest & /* auth_request */) + { + return; + } + void set_keyspace(const std::string & /* keyspace */) + { + return; + } + void get(ColumnOrSuperColumn & /* _return */, const std::string & /* key */, + const ColumnPath & /* column_path */, + const ConsistencyLevel::type /* consistency_level */) + { + return; + } + void get_slice(std::vector & /* _return */, + const std::string & /* key */, + const ColumnParent & /* column_parent */, + const SlicePredicate & /* predicate */, + const ConsistencyLevel::type /* consistency_level */) + { + return; + } + int32_t get_count(const std::string & /* key */, + const ColumnParent & /* column_parent */, + const SlicePredicate & /* predicate */, + const ConsistencyLevel::type /* consistency_level */) + { + int32_t _return = 0; + return _return; + } + void multiget_slice(std::map> + & /* _return */, + const std::vector & /* keys */, + const ColumnParent & /* column_parent */, + const SlicePredicate & /* predicate */, + const ConsistencyLevel::type /* consistency_level */) + { + return; + } + void multiget_count(std::map & /* _return */, + const std::vector & /* keys */, + const ColumnParent & /* column_parent */, + const SlicePredicate & /* predicate */, + const ConsistencyLevel::type /* consistency_level */) + { + return; + } + void get_range_slices(std::vector & /* _return */, + const ColumnParent & /* column_parent */, + const SlicePredicate & /* predicate */, + const KeyRange & /* range */, + const ConsistencyLevel::type /* consistency_level */) + { + return; + } + void get_indexed_slices(std::vector & /* _return */, + const ColumnParent & /* column_parent */, + const IndexClause & /* index_clause */, + const SlicePredicate & /* column_predicate */, + const ConsistencyLevel::type /* consistency_level */) + { + return; + } + void insert(const std::string & /* key */, + const ColumnParent & /* column_parent */, + const Column & /* column */, + const ConsistencyLevel::type /* consistency_level */) + { + return; + } + void add(const std::string & /* key */, + const ColumnParent & /* column_parent */, + const CounterColumn & /* column */, + const ConsistencyLevel::type /* consistency_level */) + { + return; + } + void remove(const std::string & /* key */, + const ColumnPath & /* column_path */, const int64_t /* timestamp */, + const ConsistencyLevel::type /* consistency_level */) + { + return; + } + void remove_counter(const std::string & /* key */, + const ColumnPath & /* path */, + const ConsistencyLevel::type /* consistency_level */) + { + return; + } + void batch_mutate(const std::map>> + & /* mutation_map */, + const ConsistencyLevel::type /* consistency_level */) + { + return; + } + void truncate(const std::string & /* cfname */) + { + return; + } + void describe_schema_versions( + std::map> & /* _return */) + { + return; + } + void describe_keyspaces(std::vector & /* _return */) + { + return; + } + void describe_cluster_name(std::string & /* _return */) + { + return; + } + void describe_version(std::string & /* _return */) + { + return; + } + void describe_ring(std::vector & /* _return */, + const std::string & /* keyspace */) + { + return; + } + void describe_partitioner(std::string & /* _return */) + { + return; + } + void describe_snitch(std::string & /* _return */) + { + return; + } + void describe_keyspace( + KsDef & /* _return */, const std::string & /* keyspace */) + { + return; + } + void describe_splits(std::vector & /* _return */, + const std::string & /* cfName */, + const std::string & /* start_token */, + const std::string & /* end_token */, + const int32_t /* keys_per_split */) + { + return; + } + void system_add_column_family( + std::string & /* _return */, const CfDef & /* cf_def */) + { + return; + } + void system_drop_column_family(std::string & /* _return */, + const std::string & /* column_family */) + { + return; + } + void system_add_keyspace( + std::string & /* _return */, const KsDef & /* ks_def */) + { + return; + } + void system_drop_keyspace( + std::string & /* _return */, const std::string & /* keyspace */) + { + return; + } + void system_update_keyspace( + std::string & /* _return */, const KsDef & /* ks_def */) + { + return; + } + void system_update_column_family( + std::string & /* _return */, const CfDef & /* cf_def */) + { + return; + } + void execute_cql_query(CqlResult & /* _return */, + const std::string & /* query */, + const Compression::type /* compression */) + { + return; + } +}; + + +class Cassandra_login_args +{ +public: + Cassandra_login_args() + { + } + + virtual ~Cassandra_login_args() throw() + { + } + + AuthenticationRequest auth_request; + + bool operator==(const Cassandra_login_args &rhs) const + { + if(!(auth_request == rhs.auth_request)) + return false; + return true; + } + bool operator!=(const Cassandra_login_args &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_login_args &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + + +class Cassandra_login_pargs +{ +public: + virtual ~Cassandra_login_pargs() throw() + { + } + + const AuthenticationRequest *auth_request; + + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_login_result__isset +{ + _Cassandra_login_result__isset() : authnx(false), authzx(false) + { + } + bool authnx; + bool authzx; } _Cassandra_login_result__isset; -class Cassandra_login_result { - public: - - Cassandra_login_result() { - } - - virtual ~Cassandra_login_result() throw() {} - - AuthenticationException authnx; - AuthorizationException authzx; - - _Cassandra_login_result__isset __isset; - - bool operator == (const Cassandra_login_result & rhs) const - { - if (!(authnx == rhs.authnx)) - return false; - if (!(authzx == rhs.authzx)) - return false; - return true; - } - bool operator != (const Cassandra_login_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_login_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_login_presult__isset { - _Cassandra_login_presult__isset() : authnx(false), authzx(false) {} - bool authnx; - bool authzx; +class Cassandra_login_result +{ +public: + Cassandra_login_result() + { + } + + virtual ~Cassandra_login_result() throw() + { + } + + AuthenticationException authnx; + AuthorizationException authzx; + + _Cassandra_login_result__isset __isset; + + bool operator==(const Cassandra_login_result &rhs) const + { + if(!(authnx == rhs.authnx)) + return false; + if(!(authzx == rhs.authzx)) + return false; + return true; + } + bool operator!=(const Cassandra_login_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_login_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_login_presult__isset +{ + _Cassandra_login_presult__isset() : authnx(false), authzx(false) + { + } + bool authnx; + bool authzx; } _Cassandra_login_presult__isset; -class Cassandra_login_presult { - public: - - - virtual ~Cassandra_login_presult() throw() {} +class Cassandra_login_presult +{ +public: + virtual ~Cassandra_login_presult() throw() + { + } - AuthenticationException authnx; - AuthorizationException authzx; + AuthenticationException authnx; + AuthorizationException authzx; - _Cassandra_login_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + _Cassandra_login_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -class Cassandra_set_keyspace_args { - public: - - Cassandra_set_keyspace_args() : keyspace("") { - } +class Cassandra_set_keyspace_args +{ +public: + Cassandra_set_keyspace_args() : keyspace("") + { + } - virtual ~Cassandra_set_keyspace_args() throw() {} + virtual ~Cassandra_set_keyspace_args() throw() + { + } - std::string keyspace; + std::string keyspace; - bool operator == (const Cassandra_set_keyspace_args & rhs) const - { - if (!(keyspace == rhs.keyspace)) - return false; - return true; - } - bool operator != (const Cassandra_set_keyspace_args &rhs) const { - return !(*this == rhs); - } + bool operator==(const Cassandra_set_keyspace_args &rhs) const + { + if(!(keyspace == rhs.keyspace)) + return false; + return true; + } + bool operator!=(const Cassandra_set_keyspace_args &rhs) const + { + return !(*this == rhs); + } - bool operator < (const Cassandra_set_keyspace_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_set_keyspace_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -class Cassandra_set_keyspace_pargs { - public: - +class Cassandra_set_keyspace_pargs +{ +public: + virtual ~Cassandra_set_keyspace_pargs() throw() + { + } - virtual ~Cassandra_set_keyspace_pargs() throw() {} - - const std::string* keyspace; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + const std::string *keyspace; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_set_keyspace_result__isset { - _Cassandra_set_keyspace_result__isset() : ire(false) {} - bool ire; +typedef struct _Cassandra_set_keyspace_result__isset +{ + _Cassandra_set_keyspace_result__isset() : ire(false) + { + } + bool ire; } _Cassandra_set_keyspace_result__isset; -class Cassandra_set_keyspace_result { - public: - - Cassandra_set_keyspace_result() { - } - - virtual ~Cassandra_set_keyspace_result() throw() {} +class Cassandra_set_keyspace_result +{ +public: + Cassandra_set_keyspace_result() + { + } - InvalidRequestException ire; + virtual ~Cassandra_set_keyspace_result() throw() + { + } - _Cassandra_set_keyspace_result__isset __isset; + InvalidRequestException ire; - bool operator == (const Cassandra_set_keyspace_result & rhs) const - { - if (!(ire == rhs.ire)) - return false; - return true; - } - bool operator != (const Cassandra_set_keyspace_result &rhs) const { - return !(*this == rhs); - } + _Cassandra_set_keyspace_result__isset __isset; - bool operator < (const Cassandra_set_keyspace_result & ) const; + bool operator==(const Cassandra_set_keyspace_result &rhs) const + { + if(!(ire == rhs.ire)) + return false; + return true; + } + bool operator!=(const Cassandra_set_keyspace_result &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_set_keyspace_result &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_set_keyspace_presult__isset { - _Cassandra_set_keyspace_presult__isset() : ire(false) {} - bool ire; +typedef struct _Cassandra_set_keyspace_presult__isset +{ + _Cassandra_set_keyspace_presult__isset() : ire(false) + { + } + bool ire; } _Cassandra_set_keyspace_presult__isset; -class Cassandra_set_keyspace_presult { - public: +class Cassandra_set_keyspace_presult +{ +public: + virtual ~Cassandra_set_keyspace_presult() throw() + { + } + InvalidRequestException ire; - virtual ~Cassandra_set_keyspace_presult() throw() {} - - InvalidRequestException ire; - - _Cassandra_set_keyspace_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + _Cassandra_set_keyspace_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -class Cassandra_get_args { - public: - - Cassandra_get_args() : key("") { - consistency_level = (ConsistencyLevel::type)1; +class Cassandra_get_args +{ +public: + Cassandra_get_args() : key("") + { + consistency_level = (ConsistencyLevel::type)1; + } - } + virtual ~Cassandra_get_args() throw() + { + } - virtual ~Cassandra_get_args() throw() {} + std::string key; + ColumnPath column_path; + ConsistencyLevel::type consistency_level; - std::string key; - ColumnPath column_path; - ConsistencyLevel::type consistency_level; + bool operator==(const Cassandra_get_args &rhs) const + { + if(!(key == rhs.key)) + return false; + if(!(column_path == rhs.column_path)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_get_args &rhs) const + { + return !(*this == rhs); + } - bool operator == (const Cassandra_get_args & rhs) const - { - if (!(key == rhs.key)) - return false; - if (!(column_path == rhs.column_path)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_get_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_get_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_get_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -class Cassandra_get_pargs { - public: - - - virtual ~Cassandra_get_pargs() throw() {} +class Cassandra_get_pargs +{ +public: + virtual ~Cassandra_get_pargs() throw() + { + } - const std::string* key; - const ColumnPath* column_path; - const ConsistencyLevel::type* consistency_level; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + const std::string *key; + const ColumnPath *column_path; + const ConsistencyLevel::type *consistency_level; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_get_result__isset { - _Cassandra_get_result__isset() : success(false), ire(false), nfe(false), ue(false), te(false) {} - bool success; - bool ire; - bool nfe; - bool ue; - bool te; +typedef struct _Cassandra_get_result__isset +{ + _Cassandra_get_result__isset() + : success(false), ire(false), nfe(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool nfe; + bool ue; + bool te; } _Cassandra_get_result__isset; -class Cassandra_get_result { - public: - - Cassandra_get_result() { - } - - virtual ~Cassandra_get_result() throw() {} - - ColumnOrSuperColumn success; - InvalidRequestException ire; - NotFoundException nfe; - UnavailableException ue; - TimedOutException te; - - _Cassandra_get_result__isset __isset; - - bool operator == (const Cassandra_get_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(nfe == rhs.nfe)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_get_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_get_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_get_presult__isset { - _Cassandra_get_presult__isset() : success(false), ire(false), nfe(false), ue(false), te(false) {} - bool success; - bool ire; - bool nfe; - bool ue; - bool te; +class Cassandra_get_result +{ +public: + Cassandra_get_result() + { + } + + virtual ~Cassandra_get_result() throw() + { + } + + ColumnOrSuperColumn success; + InvalidRequestException ire; + NotFoundException nfe; + UnavailableException ue; + TimedOutException te; + + _Cassandra_get_result__isset __isset; + + bool operator==(const Cassandra_get_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(nfe == rhs.nfe)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_get_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_get_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_get_presult__isset +{ + _Cassandra_get_presult__isset() + : success(false), ire(false), nfe(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool nfe; + bool ue; + bool te; } _Cassandra_get_presult__isset; -class Cassandra_get_presult { - public: - - - virtual ~Cassandra_get_presult() throw() {} - - ColumnOrSuperColumn* success; - InvalidRequestException ire; - NotFoundException nfe; - UnavailableException ue; - TimedOutException te; - - _Cassandra_get_presult__isset __isset; +class Cassandra_get_presult +{ +public: + virtual ~Cassandra_get_presult() throw() + { + } + + ColumnOrSuperColumn *success; + InvalidRequestException ire; + NotFoundException nfe; + UnavailableException ue; + TimedOutException te; + + _Cassandra_get_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); +}; + + +class Cassandra_get_slice_args +{ +public: + Cassandra_get_slice_args() : key("") + { + consistency_level = (ConsistencyLevel::type)1; + } + + virtual ~Cassandra_get_slice_args() throw() + { + } + + std::string key; + ColumnParent column_parent; + SlicePredicate predicate; + ConsistencyLevel::type consistency_level; + + bool operator==(const Cassandra_get_slice_args &rhs) const + { + if(!(key == rhs.key)) + return false; + if(!(column_parent == rhs.column_parent)) + return false; + if(!(predicate == rhs.predicate)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_get_slice_args &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_get_slice_args &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + + +class Cassandra_get_slice_pargs +{ +public: + virtual ~Cassandra_get_slice_pargs() throw() + { + } + + const std::string *key; + const ColumnParent *column_parent; + const SlicePredicate *predicate; + const ConsistencyLevel::type *consistency_level; + + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_get_slice_result__isset +{ + _Cassandra_get_slice_result__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_get_slice_result__isset; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); +class Cassandra_get_slice_result +{ +public: + Cassandra_get_slice_result() + { + } + + virtual ~Cassandra_get_slice_result() throw() + { + } + + std::vector success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_get_slice_result__isset __isset; + + bool operator==(const Cassandra_get_slice_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_get_slice_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_get_slice_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_get_slice_presult__isset +{ + _Cassandra_get_slice_presult__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_get_slice_presult__isset; -}; +class Cassandra_get_slice_presult +{ +public: + virtual ~Cassandra_get_slice_presult() throw() + { + } + + std::vector *success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_get_slice_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); +}; + + +class Cassandra_get_count_args +{ +public: + Cassandra_get_count_args() : key("") + { + consistency_level = (ConsistencyLevel::type)1; + } + + virtual ~Cassandra_get_count_args() throw() + { + } + + std::string key; + ColumnParent column_parent; + SlicePredicate predicate; + ConsistencyLevel::type consistency_level; + + bool operator==(const Cassandra_get_count_args &rhs) const + { + if(!(key == rhs.key)) + return false; + if(!(column_parent == rhs.column_parent)) + return false; + if(!(predicate == rhs.predicate)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_get_count_args &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_get_count_args &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + + +class Cassandra_get_count_pargs +{ +public: + virtual ~Cassandra_get_count_pargs() throw() + { + } + + const std::string *key; + const ColumnParent *column_parent; + const SlicePredicate *predicate; + const ConsistencyLevel::type *consistency_level; + + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_get_count_result__isset +{ + _Cassandra_get_count_result__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_get_count_result__isset; +class Cassandra_get_count_result +{ +public: + Cassandra_get_count_result() : success(0) + { + } + + virtual ~Cassandra_get_count_result() throw() + { + } + + int32_t success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_get_count_result__isset __isset; + + bool operator==(const Cassandra_get_count_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_get_count_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_get_count_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_get_count_presult__isset +{ + _Cassandra_get_count_presult__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_get_count_presult__isset; -class Cassandra_get_slice_args { - public: +class Cassandra_get_count_presult +{ +public: + virtual ~Cassandra_get_count_presult() throw() + { + } + + int32_t *success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_get_count_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); +}; + + +class Cassandra_multiget_slice_args +{ +public: + Cassandra_multiget_slice_args() + { + consistency_level = (ConsistencyLevel::type)1; + } + + virtual ~Cassandra_multiget_slice_args() throw() + { + } + + std::vector keys; + ColumnParent column_parent; + SlicePredicate predicate; + ConsistencyLevel::type consistency_level; + + bool operator==(const Cassandra_multiget_slice_args &rhs) const + { + if(!(keys == rhs.keys)) + return false; + if(!(column_parent == rhs.column_parent)) + return false; + if(!(predicate == rhs.predicate)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_multiget_slice_args &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_multiget_slice_args &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + + +class Cassandra_multiget_slice_pargs +{ +public: + virtual ~Cassandra_multiget_slice_pargs() throw() + { + } + + const std::vector *keys; + const ColumnParent *column_parent; + const SlicePredicate *predicate; + const ConsistencyLevel::type *consistency_level; + + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_multiget_slice_result__isset +{ + _Cassandra_multiget_slice_result__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_multiget_slice_result__isset; - Cassandra_get_slice_args() : key("") { - consistency_level = (ConsistencyLevel::type)1; +class Cassandra_multiget_slice_result +{ +public: + Cassandra_multiget_slice_result() + { + } + + virtual ~Cassandra_multiget_slice_result() throw() + { + } + + std::map> success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_multiget_slice_result__isset __isset; + + bool operator==(const Cassandra_multiget_slice_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_multiget_slice_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_multiget_slice_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_multiget_slice_presult__isset +{ + _Cassandra_multiget_slice_presult__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_multiget_slice_presult__isset; - } +class Cassandra_multiget_slice_presult +{ +public: + virtual ~Cassandra_multiget_slice_presult() throw() + { + } + + std::map> *success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_multiget_slice_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); +}; + + +class Cassandra_multiget_count_args +{ +public: + Cassandra_multiget_count_args() + { + consistency_level = (ConsistencyLevel::type)1; + } + + virtual ~Cassandra_multiget_count_args() throw() + { + } + + std::vector keys; + ColumnParent column_parent; + SlicePredicate predicate; + ConsistencyLevel::type consistency_level; + + bool operator==(const Cassandra_multiget_count_args &rhs) const + { + if(!(keys == rhs.keys)) + return false; + if(!(column_parent == rhs.column_parent)) + return false; + if(!(predicate == rhs.predicate)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_multiget_count_args &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_multiget_count_args &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + + +class Cassandra_multiget_count_pargs +{ +public: + virtual ~Cassandra_multiget_count_pargs() throw() + { + } + + const std::vector *keys; + const ColumnParent *column_parent; + const SlicePredicate *predicate; + const ConsistencyLevel::type *consistency_level; + + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_multiget_count_result__isset +{ + _Cassandra_multiget_count_result__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_multiget_count_result__isset; - virtual ~Cassandra_get_slice_args() throw() {} +class Cassandra_multiget_count_result +{ +public: + Cassandra_multiget_count_result() + { + } + + virtual ~Cassandra_multiget_count_result() throw() + { + } + + std::map success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_multiget_count_result__isset __isset; + + bool operator==(const Cassandra_multiget_count_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_multiget_count_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_multiget_count_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_multiget_count_presult__isset +{ + _Cassandra_multiget_count_presult__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_multiget_count_presult__isset; - std::string key; - ColumnParent column_parent; - SlicePredicate predicate; - ConsistencyLevel::type consistency_level; +class Cassandra_multiget_count_presult +{ +public: + virtual ~Cassandra_multiget_count_presult() throw() + { + } + + std::map *success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_multiget_count_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); +}; + + +class Cassandra_get_range_slices_args +{ +public: + Cassandra_get_range_slices_args() + { + consistency_level = (ConsistencyLevel::type)1; + } + + virtual ~Cassandra_get_range_slices_args() throw() + { + } + + ColumnParent column_parent; + SlicePredicate predicate; + KeyRange range; + ConsistencyLevel::type consistency_level; + + bool operator==(const Cassandra_get_range_slices_args &rhs) const + { + if(!(column_parent == rhs.column_parent)) + return false; + if(!(predicate == rhs.predicate)) + return false; + if(!(range == rhs.range)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_get_range_slices_args &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_get_range_slices_args &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + + +class Cassandra_get_range_slices_pargs +{ +public: + virtual ~Cassandra_get_range_slices_pargs() throw() + { + } + + const ColumnParent *column_parent; + const SlicePredicate *predicate; + const KeyRange *range; + const ConsistencyLevel::type *consistency_level; + + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_get_range_slices_result__isset +{ + _Cassandra_get_range_slices_result__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_get_range_slices_result__isset; - bool operator == (const Cassandra_get_slice_args & rhs) const - { - if (!(key == rhs.key)) - return false; - if (!(column_parent == rhs.column_parent)) - return false; - if (!(predicate == rhs.predicate)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_get_slice_args &rhs) const { - return !(*this == rhs); - } +class Cassandra_get_range_slices_result +{ +public: + Cassandra_get_range_slices_result() + { + } + + virtual ~Cassandra_get_range_slices_result() throw() + { + } + + std::vector success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_get_range_slices_result__isset __isset; + + bool operator==(const Cassandra_get_range_slices_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_get_range_slices_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_get_range_slices_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_get_range_slices_presult__isset +{ + _Cassandra_get_range_slices_presult__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_get_range_slices_presult__isset; - bool operator < (const Cassandra_get_slice_args & ) const; +class Cassandra_get_range_slices_presult +{ +public: + virtual ~Cassandra_get_range_slices_presult() throw() + { + } + + std::vector *success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_get_range_slices_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); +}; + + +class Cassandra_get_indexed_slices_args +{ +public: + Cassandra_get_indexed_slices_args() + { + consistency_level = (ConsistencyLevel::type)1; + } + + virtual ~Cassandra_get_indexed_slices_args() throw() + { + } + + ColumnParent column_parent; + IndexClause index_clause; + SlicePredicate column_predicate; + ConsistencyLevel::type consistency_level; + + bool operator==(const Cassandra_get_indexed_slices_args &rhs) const + { + if(!(column_parent == rhs.column_parent)) + return false; + if(!(index_clause == rhs.index_clause)) + return false; + if(!(column_predicate == rhs.column_predicate)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_get_indexed_slices_args &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_get_indexed_slices_args &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + + +class Cassandra_get_indexed_slices_pargs +{ +public: + virtual ~Cassandra_get_indexed_slices_pargs() throw() + { + } + + const ColumnParent *column_parent; + const IndexClause *index_clause; + const SlicePredicate *column_predicate; + const ConsistencyLevel::type *consistency_level; + + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_get_indexed_slices_result__isset +{ + _Cassandra_get_indexed_slices_result__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_get_indexed_slices_result__isset; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; +class Cassandra_get_indexed_slices_result +{ +public: + Cassandra_get_indexed_slices_result() + { + } + + virtual ~Cassandra_get_indexed_slices_result() throw() + { + } + + std::vector success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_get_indexed_slices_result__isset __isset; + + bool operator==(const Cassandra_get_indexed_slices_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_get_indexed_slices_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_get_indexed_slices_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_get_indexed_slices_presult__isset +{ + _Cassandra_get_indexed_slices_presult__isset() + : success(false), ire(false), ue(false), te(false) + { + } + bool success; + bool ire; + bool ue; + bool te; +} _Cassandra_get_indexed_slices_presult__isset; -}; +class Cassandra_get_indexed_slices_presult +{ +public: + virtual ~Cassandra_get_indexed_slices_presult() throw() + { + } + + std::vector *success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_get_indexed_slices_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); +}; + + +class Cassandra_insert_args +{ +public: + Cassandra_insert_args() : key("") + { + consistency_level = (ConsistencyLevel::type)1; + } + + virtual ~Cassandra_insert_args() throw() + { + } + + std::string key; + ColumnParent column_parent; + Column column; + ConsistencyLevel::type consistency_level; + + bool operator==(const Cassandra_insert_args &rhs) const + { + if(!(key == rhs.key)) + return false; + if(!(column_parent == rhs.column_parent)) + return false; + if(!(column == rhs.column)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_insert_args &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_insert_args &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + + +class Cassandra_insert_pargs +{ +public: + virtual ~Cassandra_insert_pargs() throw() + { + } + + const std::string *key; + const ColumnParent *column_parent; + const Column *column; + const ConsistencyLevel::type *consistency_level; + + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_insert_result__isset +{ + _Cassandra_insert_result__isset() : ire(false), ue(false), te(false) + { + } + bool ire; + bool ue; + bool te; +} _Cassandra_insert_result__isset; +class Cassandra_insert_result +{ +public: + Cassandra_insert_result() + { + } + + virtual ~Cassandra_insert_result() throw() + { + } + + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_insert_result__isset __isset; + + bool operator==(const Cassandra_insert_result &rhs) const + { + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_insert_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_insert_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_insert_presult__isset +{ + _Cassandra_insert_presult__isset() : ire(false), ue(false), te(false) + { + } + bool ire; + bool ue; + bool te; +} _Cassandra_insert_presult__isset; -class Cassandra_get_slice_pargs { - public: +class Cassandra_insert_presult +{ +public: + virtual ~Cassandra_insert_presult() throw() + { + } + + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_insert_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); +}; + + +class Cassandra_add_args +{ +public: + Cassandra_add_args() : key("") + { + consistency_level = (ConsistencyLevel::type)1; + } + + virtual ~Cassandra_add_args() throw() + { + } + + std::string key; + ColumnParent column_parent; + CounterColumn column; + ConsistencyLevel::type consistency_level; + + bool operator==(const Cassandra_add_args &rhs) const + { + if(!(key == rhs.key)) + return false; + if(!(column_parent == rhs.column_parent)) + return false; + if(!(column == rhs.column)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_add_args &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_add_args &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + + +class Cassandra_add_pargs +{ +public: + virtual ~Cassandra_add_pargs() throw() + { + } + + const std::string *key; + const ColumnParent *column_parent; + const CounterColumn *column; + const ConsistencyLevel::type *consistency_level; + + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_add_result__isset +{ + _Cassandra_add_result__isset() : ire(false), ue(false), te(false) + { + } + bool ire; + bool ue; + bool te; +} _Cassandra_add_result__isset; +class Cassandra_add_result +{ +public: + Cassandra_add_result() + { + } + + virtual ~Cassandra_add_result() throw() + { + } + + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_add_result__isset __isset; + + bool operator==(const Cassandra_add_result &rhs) const + { + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_add_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_add_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_add_presult__isset +{ + _Cassandra_add_presult__isset() : ire(false), ue(false), te(false) + { + } + bool ire; + bool ue; + bool te; +} _Cassandra_add_presult__isset; - virtual ~Cassandra_get_slice_pargs() throw() {} +class Cassandra_add_presult +{ +public: + virtual ~Cassandra_add_presult() throw() + { + } - const std::string* key; - const ColumnParent* column_parent; - const SlicePredicate* predicate; - const ConsistencyLevel::type* consistency_level; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_add_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -typedef struct _Cassandra_get_slice_result__isset { - _Cassandra_get_slice_result__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_get_slice_result__isset; - -class Cassandra_get_slice_result { - public: - - Cassandra_get_slice_result() { - } - - virtual ~Cassandra_get_slice_result() throw() {} +typedef struct _Cassandra_remove_args__isset +{ + _Cassandra_remove_args__isset() : consistency_level(false) + { + } + bool consistency_level; +} _Cassandra_remove_args__isset; - std::vector success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; +class Cassandra_remove_args +{ +public: + Cassandra_remove_args() : key(""), timestamp(0) + { + consistency_level = (ConsistencyLevel::type)1; + } + + virtual ~Cassandra_remove_args() throw() + { + } + + std::string key; + ColumnPath column_path; + int64_t timestamp; + ConsistencyLevel::type consistency_level; + + _Cassandra_remove_args__isset __isset; + + bool operator==(const Cassandra_remove_args &rhs) const + { + if(!(key == rhs.key)) + return false; + if(!(column_path == rhs.column_path)) + return false; + if(!(timestamp == rhs.timestamp)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_remove_args &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_remove_args &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + + +class Cassandra_remove_pargs +{ +public: + virtual ~Cassandra_remove_pargs() throw() + { + } + + const std::string *key; + const ColumnPath *column_path; + const int64_t *timestamp; + const ConsistencyLevel::type *consistency_level; + + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_remove_result__isset +{ + _Cassandra_remove_result__isset() : ire(false), ue(false), te(false) + { + } + bool ire; + bool ue; + bool te; +} _Cassandra_remove_result__isset; - _Cassandra_get_slice_result__isset __isset; +class Cassandra_remove_result +{ +public: + Cassandra_remove_result() + { + } + + virtual ~Cassandra_remove_result() throw() + { + } + + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_remove_result__isset __isset; + + bool operator==(const Cassandra_remove_result &rhs) const + { + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_remove_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_remove_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_remove_presult__isset +{ + _Cassandra_remove_presult__isset() : ire(false), ue(false), te(false) + { + } + bool ire; + bool ue; + bool te; +} _Cassandra_remove_presult__isset; - bool operator == (const Cassandra_get_slice_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_get_slice_result &rhs) const { - return !(*this == rhs); - } +class Cassandra_remove_presult +{ +public: + virtual ~Cassandra_remove_presult() throw() + { + } - bool operator < (const Cassandra_get_slice_result & ) const; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_remove_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -typedef struct _Cassandra_get_slice_presult__isset { - _Cassandra_get_slice_presult__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_get_slice_presult__isset; - -class Cassandra_get_slice_presult { - public: +class Cassandra_remove_counter_args +{ +public: + Cassandra_remove_counter_args() : key("") + { + consistency_level = (ConsistencyLevel::type)1; + } - virtual ~Cassandra_get_slice_presult() throw() {} + virtual ~Cassandra_remove_counter_args() throw() + { + } - std::vector * success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; + std::string key; + ColumnPath path; + ConsistencyLevel::type consistency_level; - _Cassandra_get_slice_presult__isset __isset; + bool operator==(const Cassandra_remove_counter_args &rhs) const + { + if(!(key == rhs.key)) + return false; + if(!(path == rhs.path)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_remove_counter_args &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + bool operator<(const Cassandra_remove_counter_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -class Cassandra_get_count_args { - public: - - Cassandra_get_count_args() : key("") { - consistency_level = (ConsistencyLevel::type)1; - - } - - virtual ~Cassandra_get_count_args() throw() {} - - std::string key; - ColumnParent column_parent; - SlicePredicate predicate; - ConsistencyLevel::type consistency_level; +class Cassandra_remove_counter_pargs +{ +public: + virtual ~Cassandra_remove_counter_pargs() throw() + { + } - bool operator == (const Cassandra_get_count_args & rhs) const - { - if (!(key == rhs.key)) - return false; - if (!(column_parent == rhs.column_parent)) - return false; - if (!(predicate == rhs.predicate)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_get_count_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_get_count_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + const std::string *key; + const ColumnPath *path; + const ConsistencyLevel::type *consistency_level; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; +typedef struct _Cassandra_remove_counter_result__isset +{ + _Cassandra_remove_counter_result__isset() : ire(false), ue(false), te(false) + { + } + bool ire; + bool ue; + bool te; +} _Cassandra_remove_counter_result__isset; -class Cassandra_get_count_pargs { - public: - +class Cassandra_remove_counter_result +{ +public: + Cassandra_remove_counter_result() + { + } + + virtual ~Cassandra_remove_counter_result() throw() + { + } + + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_remove_counter_result__isset __isset; + + bool operator==(const Cassandra_remove_counter_result &rhs) const + { + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_remove_counter_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_remove_counter_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_remove_counter_presult__isset +{ + _Cassandra_remove_counter_presult__isset() + : ire(false), ue(false), te(false) + { + } + bool ire; + bool ue; + bool te; +} _Cassandra_remove_counter_presult__isset; - virtual ~Cassandra_get_count_pargs() throw() {} +class Cassandra_remove_counter_presult +{ +public: + virtual ~Cassandra_remove_counter_presult() throw() + { + } - const std::string* key; - const ColumnParent* column_parent; - const SlicePredicate* predicate; - const ConsistencyLevel::type* consistency_level; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_remove_counter_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -typedef struct _Cassandra_get_count_result__isset { - _Cassandra_get_count_result__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_get_count_result__isset; - -class Cassandra_get_count_result { - public: - - Cassandra_get_count_result() : success(0) { - } - virtual ~Cassandra_get_count_result() throw() {} +class Cassandra_batch_mutate_args +{ +public: + Cassandra_batch_mutate_args() + { + consistency_level = (ConsistencyLevel::type)1; + } - int32_t success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; + virtual ~Cassandra_batch_mutate_args() throw() + { + } - _Cassandra_get_count_result__isset __isset; + std::map>> + mutation_map; + ConsistencyLevel::type consistency_level; - bool operator == (const Cassandra_get_count_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_get_count_result &rhs) const { - return !(*this == rhs); - } + bool operator==(const Cassandra_batch_mutate_args &rhs) const + { + if(!(mutation_map == rhs.mutation_map)) + return false; + if(!(consistency_level == rhs.consistency_level)) + return false; + return true; + } + bool operator!=(const Cassandra_batch_mutate_args &rhs) const + { + return !(*this == rhs); + } - bool operator < (const Cassandra_get_count_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_batch_mutate_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_get_count_presult__isset { - _Cassandra_get_count_presult__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_get_count_presult__isset; - -class Cassandra_get_count_presult { - public: - - virtual ~Cassandra_get_count_presult() throw() {} +class Cassandra_batch_mutate_pargs +{ +public: + virtual ~Cassandra_batch_mutate_pargs() throw() + { + } - int32_t* success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; - - _Cassandra_get_count_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + const std::map>> + *mutation_map; + const ConsistencyLevel::type *consistency_level; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; +typedef struct _Cassandra_batch_mutate_result__isset +{ + _Cassandra_batch_mutate_result__isset() : ire(false), ue(false), te(false) + { + } + bool ire; + bool ue; + bool te; +} _Cassandra_batch_mutate_result__isset; -class Cassandra_multiget_slice_args { - public: - - Cassandra_multiget_slice_args() { - consistency_level = (ConsistencyLevel::type)1; - - } - - virtual ~Cassandra_multiget_slice_args() throw() {} - - std::vector keys; - ColumnParent column_parent; - SlicePredicate predicate; - ConsistencyLevel::type consistency_level; +class Cassandra_batch_mutate_result +{ +public: + Cassandra_batch_mutate_result() + { + } + + virtual ~Cassandra_batch_mutate_result() throw() + { + } + + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + + _Cassandra_batch_mutate_result__isset __isset; + + bool operator==(const Cassandra_batch_mutate_result &rhs) const + { + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + return true; + } + bool operator!=(const Cassandra_batch_mutate_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_batch_mutate_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_batch_mutate_presult__isset +{ + _Cassandra_batch_mutate_presult__isset() : ire(false), ue(false), te(false) + { + } + bool ire; + bool ue; + bool te; +} _Cassandra_batch_mutate_presult__isset; - bool operator == (const Cassandra_multiget_slice_args & rhs) const - { - if (!(keys == rhs.keys)) - return false; - if (!(column_parent == rhs.column_parent)) - return false; - if (!(predicate == rhs.predicate)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_multiget_slice_args &rhs) const { - return !(*this == rhs); - } +class Cassandra_batch_mutate_presult +{ +public: + virtual ~Cassandra_batch_mutate_presult() throw() + { + } - bool operator < (const Cassandra_multiget_slice_args & ) const; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_batch_mutate_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -class Cassandra_multiget_slice_pargs { - public: +class Cassandra_truncate_args +{ +public: + Cassandra_truncate_args() : cfname("") + { + } + virtual ~Cassandra_truncate_args() throw() + { + } - virtual ~Cassandra_multiget_slice_pargs() throw() {} + std::string cfname; - const std::vector * keys; - const ColumnParent* column_parent; - const SlicePredicate* predicate; - const ConsistencyLevel::type* consistency_level; + bool operator==(const Cassandra_truncate_args &rhs) const + { + if(!(cfname == rhs.cfname)) + return false; + return true; + } + bool operator!=(const Cassandra_truncate_args &rhs) const + { + return !(*this == rhs); + } - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_truncate_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_multiget_slice_result__isset { - _Cassandra_multiget_slice_result__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_multiget_slice_result__isset; - -class Cassandra_multiget_slice_result { - public: - - Cassandra_multiget_slice_result() { - } - - virtual ~Cassandra_multiget_slice_result() throw() {} - std::map > success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; +class Cassandra_truncate_pargs +{ +public: + virtual ~Cassandra_truncate_pargs() throw() + { + } - _Cassandra_multiget_slice_result__isset __isset; - - bool operator == (const Cassandra_multiget_slice_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_multiget_slice_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_multiget_slice_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + const std::string *cfname; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_multiget_slice_presult__isset { - _Cassandra_multiget_slice_presult__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_multiget_slice_presult__isset; - -class Cassandra_multiget_slice_presult { - public: - +typedef struct _Cassandra_truncate_result__isset +{ + _Cassandra_truncate_result__isset() : ire(false), ue(false) + { + } + bool ire; + bool ue; +} _Cassandra_truncate_result__isset; - virtual ~Cassandra_multiget_slice_presult() throw() {} +class Cassandra_truncate_result +{ +public: + Cassandra_truncate_result() + { + } + + virtual ~Cassandra_truncate_result() throw() + { + } + + InvalidRequestException ire; + UnavailableException ue; + + _Cassandra_truncate_result__isset __isset; + + bool operator==(const Cassandra_truncate_result &rhs) const + { + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + return true; + } + bool operator!=(const Cassandra_truncate_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_truncate_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_truncate_presult__isset +{ + _Cassandra_truncate_presult__isset() : ire(false), ue(false) + { + } + bool ire; + bool ue; +} _Cassandra_truncate_presult__isset; - std::map > * success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; +class Cassandra_truncate_presult +{ +public: + virtual ~Cassandra_truncate_presult() throw() + { + } - _Cassandra_multiget_slice_presult__isset __isset; + InvalidRequestException ire; + UnavailableException ue; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + _Cassandra_truncate_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -class Cassandra_multiget_count_args { - public: +class Cassandra_describe_schema_versions_args +{ +public: + Cassandra_describe_schema_versions_args() + { + } - Cassandra_multiget_count_args() { - consistency_level = (ConsistencyLevel::type)1; + virtual ~Cassandra_describe_schema_versions_args() throw() + { + } - } - virtual ~Cassandra_multiget_count_args() throw() {} + bool operator==( + const Cassandra_describe_schema_versions_args & /* rhs */) const + { + return true; + } + bool operator!=(const Cassandra_describe_schema_versions_args &rhs) const + { + return !(*this == rhs); + } - std::vector keys; - ColumnParent column_parent; - SlicePredicate predicate; - ConsistencyLevel::type consistency_level; - - bool operator == (const Cassandra_multiget_count_args & rhs) const - { - if (!(keys == rhs.keys)) - return false; - if (!(column_parent == rhs.column_parent)) - return false; - if (!(predicate == rhs.predicate)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_multiget_count_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_multiget_count_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_describe_schema_versions_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -class Cassandra_multiget_count_pargs { - public: - +class Cassandra_describe_schema_versions_pargs +{ +public: + virtual ~Cassandra_describe_schema_versions_pargs() throw() + { + } - virtual ~Cassandra_multiget_count_pargs() throw() {} - - const std::vector * keys; - const ColumnParent* column_parent; - const SlicePredicate* predicate; - const ConsistencyLevel::type* consistency_level; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_multiget_count_result__isset { - _Cassandra_multiget_count_result__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_multiget_count_result__isset; - -class Cassandra_multiget_count_result { - public: - - Cassandra_multiget_count_result() { - } - - virtual ~Cassandra_multiget_count_result() throw() {} - - std::map success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; +typedef struct _Cassandra_describe_schema_versions_result__isset +{ + _Cassandra_describe_schema_versions_result__isset() + : success(false), ire(false) + { + } + bool success; + bool ire; +} _Cassandra_describe_schema_versions_result__isset; - _Cassandra_multiget_count_result__isset __isset; +class Cassandra_describe_schema_versions_result +{ +public: + Cassandra_describe_schema_versions_result() + { + } + + virtual ~Cassandra_describe_schema_versions_result() throw() + { + } + + std::map> success; + InvalidRequestException ire; + + _Cassandra_describe_schema_versions_result__isset __isset; + + bool operator==(const Cassandra_describe_schema_versions_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_schema_versions_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_describe_schema_versions_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_describe_schema_versions_presult__isset +{ + _Cassandra_describe_schema_versions_presult__isset() + : success(false), ire(false) + { + } + bool success; + bool ire; +} _Cassandra_describe_schema_versions_presult__isset; - bool operator == (const Cassandra_multiget_count_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_multiget_count_result &rhs) const { - return !(*this == rhs); - } +class Cassandra_describe_schema_versions_presult +{ +public: + virtual ~Cassandra_describe_schema_versions_presult() throw() + { + } - bool operator < (const Cassandra_multiget_count_result & ) const; + std::map> *success; + InvalidRequestException ire; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_describe_schema_versions_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -typedef struct _Cassandra_multiget_count_presult__isset { - _Cassandra_multiget_count_presult__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_multiget_count_presult__isset; - -class Cassandra_multiget_count_presult { - public: +class Cassandra_describe_keyspaces_args +{ +public: + Cassandra_describe_keyspaces_args() + { + } - virtual ~Cassandra_multiget_count_presult() throw() {} + virtual ~Cassandra_describe_keyspaces_args() throw() + { + } - std::map * success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; - _Cassandra_multiget_count_presult__isset __isset; + bool operator==(const Cassandra_describe_keyspaces_args & /* rhs */) const + { + return true; + } + bool operator!=(const Cassandra_describe_keyspaces_args &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + bool operator<(const Cassandra_describe_keyspaces_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -class Cassandra_get_range_slices_args { - public: +class Cassandra_describe_keyspaces_pargs +{ +public: + virtual ~Cassandra_describe_keyspaces_pargs() throw() + { + } - Cassandra_get_range_slices_args() { - consistency_level = (ConsistencyLevel::type)1; - } + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; - virtual ~Cassandra_get_range_slices_args() throw() {} +typedef struct _Cassandra_describe_keyspaces_result__isset +{ + _Cassandra_describe_keyspaces_result__isset() : success(false), ire(false) + { + } + bool success; + bool ire; +} _Cassandra_describe_keyspaces_result__isset; - ColumnParent column_parent; - SlicePredicate predicate; - KeyRange range; - ConsistencyLevel::type consistency_level; +class Cassandra_describe_keyspaces_result +{ +public: + Cassandra_describe_keyspaces_result() + { + } + + virtual ~Cassandra_describe_keyspaces_result() throw() + { + } + + std::vector success; + InvalidRequestException ire; + + _Cassandra_describe_keyspaces_result__isset __isset; + + bool operator==(const Cassandra_describe_keyspaces_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_keyspaces_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_describe_keyspaces_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_describe_keyspaces_presult__isset +{ + _Cassandra_describe_keyspaces_presult__isset() : success(false), ire(false) + { + } + bool success; + bool ire; +} _Cassandra_describe_keyspaces_presult__isset; - bool operator == (const Cassandra_get_range_slices_args & rhs) const - { - if (!(column_parent == rhs.column_parent)) - return false; - if (!(predicate == rhs.predicate)) - return false; - if (!(range == rhs.range)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_get_range_slices_args &rhs) const { - return !(*this == rhs); - } +class Cassandra_describe_keyspaces_presult +{ +public: + virtual ~Cassandra_describe_keyspaces_presult() throw() + { + } - bool operator < (const Cassandra_get_range_slices_args & ) const; + std::vector *success; + InvalidRequestException ire; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_describe_keyspaces_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -class Cassandra_get_range_slices_pargs { - public: +class Cassandra_describe_cluster_name_args +{ +public: + Cassandra_describe_cluster_name_args() + { + } + virtual ~Cassandra_describe_cluster_name_args() throw() + { + } - virtual ~Cassandra_get_range_slices_pargs() throw() {} - const ColumnParent* column_parent; - const SlicePredicate* predicate; - const KeyRange* range; - const ConsistencyLevel::type* consistency_level; + bool operator==( + const Cassandra_describe_cluster_name_args & /* rhs */) const + { + return true; + } + bool operator!=(const Cassandra_describe_cluster_name_args &rhs) const + { + return !(*this == rhs); + } - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_describe_cluster_name_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_get_range_slices_result__isset { - _Cassandra_get_range_slices_result__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_get_range_slices_result__isset; - -class Cassandra_get_range_slices_result { - public: - - Cassandra_get_range_slices_result() { - } - - virtual ~Cassandra_get_range_slices_result() throw() {} - - std::vector success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; - - _Cassandra_get_range_slices_result__isset __isset; - bool operator == (const Cassandra_get_range_slices_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_get_range_slices_result &rhs) const { - return !(*this == rhs); - } +class Cassandra_describe_cluster_name_pargs +{ +public: + virtual ~Cassandra_describe_cluster_name_pargs() throw() + { + } - bool operator < (const Cassandra_get_range_slices_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_get_range_slices_presult__isset { - _Cassandra_get_range_slices_presult__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_get_range_slices_presult__isset; +typedef struct _Cassandra_describe_cluster_name_result__isset +{ + _Cassandra_describe_cluster_name_result__isset() : success(false) + { + } + bool success; +} _Cassandra_describe_cluster_name_result__isset; -class Cassandra_get_range_slices_presult { - public: +class Cassandra_describe_cluster_name_result +{ +public: + Cassandra_describe_cluster_name_result() : success("") + { + } + virtual ~Cassandra_describe_cluster_name_result() throw() + { + } - virtual ~Cassandra_get_range_slices_presult() throw() {} + std::string success; - std::vector * success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; + _Cassandra_describe_cluster_name_result__isset __isset; - _Cassandra_get_range_slices_presult__isset __isset; + bool operator==(const Cassandra_describe_cluster_name_result &rhs) const + { + if(!(success == rhs.success)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_cluster_name_result &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + bool operator<(const Cassandra_describe_cluster_name_result &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; +typedef struct _Cassandra_describe_cluster_name_presult__isset +{ + _Cassandra_describe_cluster_name_presult__isset() : success(false) + { + } + bool success; +} _Cassandra_describe_cluster_name_presult__isset; -class Cassandra_get_indexed_slices_args { - public: - - Cassandra_get_indexed_slices_args() { - consistency_level = (ConsistencyLevel::type)1; - - } - - virtual ~Cassandra_get_indexed_slices_args() throw() {} - - ColumnParent column_parent; - IndexClause index_clause; - SlicePredicate column_predicate; - ConsistencyLevel::type consistency_level; - - bool operator == (const Cassandra_get_indexed_slices_args & rhs) const - { - if (!(column_parent == rhs.column_parent)) - return false; - if (!(index_clause == rhs.index_clause)) - return false; - if (!(column_predicate == rhs.column_predicate)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_get_indexed_slices_args &rhs) const { - return !(*this == rhs); - } +class Cassandra_describe_cluster_name_presult +{ +public: + virtual ~Cassandra_describe_cluster_name_presult() throw() + { + } - bool operator < (const Cassandra_get_indexed_slices_args & ) const; + std::string *success; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_describe_cluster_name_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -class Cassandra_get_indexed_slices_pargs { - public: +class Cassandra_describe_version_args +{ +public: + Cassandra_describe_version_args() + { + } + virtual ~Cassandra_describe_version_args() throw() + { + } - virtual ~Cassandra_get_indexed_slices_pargs() throw() {} - const ColumnParent* column_parent; - const IndexClause* index_clause; - const SlicePredicate* column_predicate; - const ConsistencyLevel::type* consistency_level; + bool operator==(const Cassandra_describe_version_args & /* rhs */) const + { + return true; + } + bool operator!=(const Cassandra_describe_version_args &rhs) const + { + return !(*this == rhs); + } - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_describe_version_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_get_indexed_slices_result__isset { - _Cassandra_get_indexed_slices_result__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_get_indexed_slices_result__isset; - -class Cassandra_get_indexed_slices_result { - public: - - Cassandra_get_indexed_slices_result() { - } - - virtual ~Cassandra_get_indexed_slices_result() throw() {} - - std::vector success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; - - _Cassandra_get_indexed_slices_result__isset __isset; - - bool operator == (const Cassandra_get_indexed_slices_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_get_indexed_slices_result &rhs) const { - return !(*this == rhs); - } - bool operator < (const Cassandra_get_indexed_slices_result & ) const; +class Cassandra_describe_version_pargs +{ +public: + virtual ~Cassandra_describe_version_pargs() throw() + { + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_get_indexed_slices_presult__isset { - _Cassandra_get_indexed_slices_presult__isset() : success(false), ire(false), ue(false), te(false) {} - bool success; - bool ire; - bool ue; - bool te; -} _Cassandra_get_indexed_slices_presult__isset; +typedef struct _Cassandra_describe_version_result__isset +{ + _Cassandra_describe_version_result__isset() : success(false) + { + } + bool success; +} _Cassandra_describe_version_result__isset; -class Cassandra_get_indexed_slices_presult { - public: +class Cassandra_describe_version_result +{ +public: + Cassandra_describe_version_result() : success("") + { + } + virtual ~Cassandra_describe_version_result() throw() + { + } - virtual ~Cassandra_get_indexed_slices_presult() throw() {} + std::string success; - std::vector * success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; + _Cassandra_describe_version_result__isset __isset; - _Cassandra_get_indexed_slices_presult__isset __isset; + bool operator==(const Cassandra_describe_version_result &rhs) const + { + if(!(success == rhs.success)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_version_result &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + bool operator<(const Cassandra_describe_version_result &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; +typedef struct _Cassandra_describe_version_presult__isset +{ + _Cassandra_describe_version_presult__isset() : success(false) + { + } + bool success; +} _Cassandra_describe_version_presult__isset; -class Cassandra_insert_args { - public: - - Cassandra_insert_args() : key("") { - consistency_level = (ConsistencyLevel::type)1; - - } - - virtual ~Cassandra_insert_args() throw() {} - - std::string key; - ColumnParent column_parent; - Column column; - ConsistencyLevel::type consistency_level; - - bool operator == (const Cassandra_insert_args & rhs) const - { - if (!(key == rhs.key)) - return false; - if (!(column_parent == rhs.column_parent)) - return false; - if (!(column == rhs.column)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_insert_args &rhs) const { - return !(*this == rhs); - } +class Cassandra_describe_version_presult +{ +public: + virtual ~Cassandra_describe_version_presult() throw() + { + } - bool operator < (const Cassandra_insert_args & ) const; + std::string *success; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_describe_version_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -class Cassandra_insert_pargs { - public: +class Cassandra_describe_ring_args +{ +public: + Cassandra_describe_ring_args() : keyspace("") + { + } + virtual ~Cassandra_describe_ring_args() throw() + { + } - virtual ~Cassandra_insert_pargs() throw() {} + std::string keyspace; - const std::string* key; - const ColumnParent* column_parent; - const Column* column; - const ConsistencyLevel::type* consistency_level; + bool operator==(const Cassandra_describe_ring_args &rhs) const + { + if(!(keyspace == rhs.keyspace)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_ring_args &rhs) const + { + return !(*this == rhs); + } - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_describe_ring_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_insert_result__isset { - _Cassandra_insert_result__isset() : ire(false), ue(false), te(false) {} - bool ire; - bool ue; - bool te; -} _Cassandra_insert_result__isset; - -class Cassandra_insert_result { - public: - - Cassandra_insert_result() { - } - - virtual ~Cassandra_insert_result() throw() {} - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; +class Cassandra_describe_ring_pargs +{ +public: + virtual ~Cassandra_describe_ring_pargs() throw() + { + } - _Cassandra_insert_result__isset __isset; - - bool operator == (const Cassandra_insert_result & rhs) const - { - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_insert_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_insert_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + const std::string *keyspace; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_insert_presult__isset { - _Cassandra_insert_presult__isset() : ire(false), ue(false), te(false) {} - bool ire; - bool ue; - bool te; -} _Cassandra_insert_presult__isset; - -class Cassandra_insert_presult { - public: - +typedef struct _Cassandra_describe_ring_result__isset +{ + _Cassandra_describe_ring_result__isset() : success(false), ire(false) + { + } + bool success; + bool ire; +} _Cassandra_describe_ring_result__isset; - virtual ~Cassandra_insert_presult() throw() {} +class Cassandra_describe_ring_result +{ +public: + Cassandra_describe_ring_result() + { + } + + virtual ~Cassandra_describe_ring_result() throw() + { + } + + std::vector success; + InvalidRequestException ire; + + _Cassandra_describe_ring_result__isset __isset; + + bool operator==(const Cassandra_describe_ring_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_ring_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_describe_ring_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_describe_ring_presult__isset +{ + _Cassandra_describe_ring_presult__isset() : success(false), ire(false) + { + } + bool success; + bool ire; +} _Cassandra_describe_ring_presult__isset; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; +class Cassandra_describe_ring_presult +{ +public: + virtual ~Cassandra_describe_ring_presult() throw() + { + } - _Cassandra_insert_presult__isset __isset; + std::vector *success; + InvalidRequestException ire; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + _Cassandra_describe_ring_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -class Cassandra_add_args { - public: +class Cassandra_describe_partitioner_args +{ +public: + Cassandra_describe_partitioner_args() + { + } - Cassandra_add_args() : key("") { - consistency_level = (ConsistencyLevel::type)1; + virtual ~Cassandra_describe_partitioner_args() throw() + { + } - } - virtual ~Cassandra_add_args() throw() {} + bool operator==(const Cassandra_describe_partitioner_args & /* rhs */) const + { + return true; + } + bool operator!=(const Cassandra_describe_partitioner_args &rhs) const + { + return !(*this == rhs); + } - std::string key; - ColumnParent column_parent; - CounterColumn column; - ConsistencyLevel::type consistency_level; - - bool operator == (const Cassandra_add_args & rhs) const - { - if (!(key == rhs.key)) - return false; - if (!(column_parent == rhs.column_parent)) - return false; - if (!(column == rhs.column)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_add_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_add_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_describe_partitioner_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -class Cassandra_add_pargs { - public: - +class Cassandra_describe_partitioner_pargs +{ +public: + virtual ~Cassandra_describe_partitioner_pargs() throw() + { + } - virtual ~Cassandra_add_pargs() throw() {} - - const std::string* key; - const ColumnParent* column_parent; - const CounterColumn* column; - const ConsistencyLevel::type* consistency_level; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_add_result__isset { - _Cassandra_add_result__isset() : ire(false), ue(false), te(false) {} - bool ire; - bool ue; - bool te; -} _Cassandra_add_result__isset; - -class Cassandra_add_result { - public: - - Cassandra_add_result() { - } +typedef struct _Cassandra_describe_partitioner_result__isset +{ + _Cassandra_describe_partitioner_result__isset() : success(false) + { + } + bool success; +} _Cassandra_describe_partitioner_result__isset; - virtual ~Cassandra_add_result() throw() {} +class Cassandra_describe_partitioner_result +{ +public: + Cassandra_describe_partitioner_result() : success("") + { + } - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; + virtual ~Cassandra_describe_partitioner_result() throw() + { + } - _Cassandra_add_result__isset __isset; + std::string success; - bool operator == (const Cassandra_add_result & rhs) const - { - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_add_result &rhs) const { - return !(*this == rhs); - } + _Cassandra_describe_partitioner_result__isset __isset; - bool operator < (const Cassandra_add_result & ) const; + bool operator==(const Cassandra_describe_partitioner_result &rhs) const + { + if(!(success == rhs.success)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_partitioner_result &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_describe_partitioner_result &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_add_presult__isset { - _Cassandra_add_presult__isset() : ire(false), ue(false), te(false) {} - bool ire; - bool ue; - bool te; -} _Cassandra_add_presult__isset; - -class Cassandra_add_presult { - public: - - - virtual ~Cassandra_add_presult() throw() {} +typedef struct _Cassandra_describe_partitioner_presult__isset +{ + _Cassandra_describe_partitioner_presult__isset() : success(false) + { + } + bool success; +} _Cassandra_describe_partitioner_presult__isset; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; +class Cassandra_describe_partitioner_presult +{ +public: + virtual ~Cassandra_describe_partitioner_presult() throw() + { + } - _Cassandra_add_presult__isset __isset; + std::string *success; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + _Cassandra_describe_partitioner_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -typedef struct _Cassandra_remove_args__isset { - _Cassandra_remove_args__isset() : consistency_level(false) {} - bool consistency_level; -} _Cassandra_remove_args__isset; - -class Cassandra_remove_args { - public: - - Cassandra_remove_args() : key(""), timestamp(0) { - consistency_level = (ConsistencyLevel::type)1; - - } - - virtual ~Cassandra_remove_args() throw() {} - std::string key; - ColumnPath column_path; - int64_t timestamp; - ConsistencyLevel::type consistency_level; +class Cassandra_describe_snitch_args +{ +public: + Cassandra_describe_snitch_args() + { + } - _Cassandra_remove_args__isset __isset; + virtual ~Cassandra_describe_snitch_args() throw() + { + } - bool operator == (const Cassandra_remove_args & rhs) const - { - if (!(key == rhs.key)) - return false; - if (!(column_path == rhs.column_path)) - return false; - if (!(timestamp == rhs.timestamp)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_remove_args &rhs) const { - return !(*this == rhs); - } - bool operator < (const Cassandra_remove_args & ) const; + bool operator==(const Cassandra_describe_snitch_args & /* rhs */) const + { + return true; + } + bool operator!=(const Cassandra_describe_snitch_args &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_describe_snitch_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -class Cassandra_remove_pargs { - public: +class Cassandra_describe_snitch_pargs +{ +public: + virtual ~Cassandra_describe_snitch_pargs() throw() + { + } - virtual ~Cassandra_remove_pargs() throw() {} - - const std::string* key; - const ColumnPath* column_path; - const int64_t* timestamp; - const ConsistencyLevel::type* consistency_level; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_remove_result__isset { - _Cassandra_remove_result__isset() : ire(false), ue(false), te(false) {} - bool ire; - bool ue; - bool te; -} _Cassandra_remove_result__isset; - -class Cassandra_remove_result { - public: - - Cassandra_remove_result() { - } +typedef struct _Cassandra_describe_snitch_result__isset +{ + _Cassandra_describe_snitch_result__isset() : success(false) + { + } + bool success; +} _Cassandra_describe_snitch_result__isset; - virtual ~Cassandra_remove_result() throw() {} +class Cassandra_describe_snitch_result +{ +public: + Cassandra_describe_snitch_result() : success("") + { + } - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; + virtual ~Cassandra_describe_snitch_result() throw() + { + } - _Cassandra_remove_result__isset __isset; + std::string success; - bool operator == (const Cassandra_remove_result & rhs) const - { - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_remove_result &rhs) const { - return !(*this == rhs); - } + _Cassandra_describe_snitch_result__isset __isset; - bool operator < (const Cassandra_remove_result & ) const; + bool operator==(const Cassandra_describe_snitch_result &rhs) const + { + if(!(success == rhs.success)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_snitch_result &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_describe_snitch_result &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_remove_presult__isset { - _Cassandra_remove_presult__isset() : ire(false), ue(false), te(false) {} - bool ire; - bool ue; - bool te; -} _Cassandra_remove_presult__isset; - -class Cassandra_remove_presult { - public: - - - virtual ~Cassandra_remove_presult() throw() {} +typedef struct _Cassandra_describe_snitch_presult__isset +{ + _Cassandra_describe_snitch_presult__isset() : success(false) + { + } + bool success; +} _Cassandra_describe_snitch_presult__isset; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; +class Cassandra_describe_snitch_presult +{ +public: + virtual ~Cassandra_describe_snitch_presult() throw() + { + } - _Cassandra_remove_presult__isset __isset; + std::string *success; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + _Cassandra_describe_snitch_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -class Cassandra_remove_counter_args { - public: +class Cassandra_describe_keyspace_args +{ +public: + Cassandra_describe_keyspace_args() : keyspace("") + { + } - Cassandra_remove_counter_args() : key("") { - consistency_level = (ConsistencyLevel::type)1; + virtual ~Cassandra_describe_keyspace_args() throw() + { + } - } + std::string keyspace; - virtual ~Cassandra_remove_counter_args() throw() {} + bool operator==(const Cassandra_describe_keyspace_args &rhs) const + { + if(!(keyspace == rhs.keyspace)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_keyspace_args &rhs) const + { + return !(*this == rhs); + } - std::string key; - ColumnPath path; - ConsistencyLevel::type consistency_level; - - bool operator == (const Cassandra_remove_counter_args & rhs) const - { - if (!(key == rhs.key)) - return false; - if (!(path == rhs.path)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_remove_counter_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_remove_counter_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_describe_keyspace_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -class Cassandra_remove_counter_pargs { - public: - +class Cassandra_describe_keyspace_pargs +{ +public: + virtual ~Cassandra_describe_keyspace_pargs() throw() + { + } - virtual ~Cassandra_remove_counter_pargs() throw() {} - - const std::string* key; - const ColumnPath* path; - const ConsistencyLevel::type* consistency_level; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + const std::string *keyspace; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_remove_counter_result__isset { - _Cassandra_remove_counter_result__isset() : ire(false), ue(false), te(false) {} - bool ire; - bool ue; - bool te; -} _Cassandra_remove_counter_result__isset; - -class Cassandra_remove_counter_result { - public: - - Cassandra_remove_counter_result() { - } +typedef struct _Cassandra_describe_keyspace_result__isset +{ + _Cassandra_describe_keyspace_result__isset() + : success(false), nfe(false), ire(false) + { + } + bool success; + bool nfe; + bool ire; +} _Cassandra_describe_keyspace_result__isset; - virtual ~Cassandra_remove_counter_result() throw() {} +class Cassandra_describe_keyspace_result +{ +public: + Cassandra_describe_keyspace_result() + { + } + + virtual ~Cassandra_describe_keyspace_result() throw() + { + } + + KsDef success; + NotFoundException nfe; + InvalidRequestException ire; + + _Cassandra_describe_keyspace_result__isset __isset; + + bool operator==(const Cassandra_describe_keyspace_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(nfe == rhs.nfe)) + return false; + if(!(ire == rhs.ire)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_keyspace_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_describe_keyspace_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_describe_keyspace_presult__isset +{ + _Cassandra_describe_keyspace_presult__isset() + : success(false), nfe(false), ire(false) + { + } + bool success; + bool nfe; + bool ire; +} _Cassandra_describe_keyspace_presult__isset; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; +class Cassandra_describe_keyspace_presult +{ +public: + virtual ~Cassandra_describe_keyspace_presult() throw() + { + } + + KsDef *success; + NotFoundException nfe; + InvalidRequestException ire; + + _Cassandra_describe_keyspace_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); +}; + + +class Cassandra_describe_splits_args +{ +public: + Cassandra_describe_splits_args() + : cfName(""), start_token(""), end_token(""), keys_per_split(0) + { + } + + virtual ~Cassandra_describe_splits_args() throw() + { + } + + std::string cfName; + std::string start_token; + std::string end_token; + int32_t keys_per_split; + + bool operator==(const Cassandra_describe_splits_args &rhs) const + { + if(!(cfName == rhs.cfName)) + return false; + if(!(start_token == rhs.start_token)) + return false; + if(!(end_token == rhs.end_token)) + return false; + if(!(keys_per_split == rhs.keys_per_split)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_splits_args &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_describe_splits_args &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + + +class Cassandra_describe_splits_pargs +{ +public: + virtual ~Cassandra_describe_splits_pargs() throw() + { + } + + const std::string *cfName; + const std::string *start_token; + const std::string *end_token; + const int32_t *keys_per_split; + + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_describe_splits_result__isset +{ + _Cassandra_describe_splits_result__isset() : success(false), ire(false) + { + } + bool success; + bool ire; +} _Cassandra_describe_splits_result__isset; - _Cassandra_remove_counter_result__isset __isset; +class Cassandra_describe_splits_result +{ +public: + Cassandra_describe_splits_result() + { + } + + virtual ~Cassandra_describe_splits_result() throw() + { + } + + std::vector success; + InvalidRequestException ire; + + _Cassandra_describe_splits_result__isset __isset; + + bool operator==(const Cassandra_describe_splits_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + return true; + } + bool operator!=(const Cassandra_describe_splits_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_describe_splits_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_describe_splits_presult__isset +{ + _Cassandra_describe_splits_presult__isset() : success(false), ire(false) + { + } + bool success; + bool ire; +} _Cassandra_describe_splits_presult__isset; - bool operator == (const Cassandra_remove_counter_result & rhs) const - { - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_remove_counter_result &rhs) const { - return !(*this == rhs); - } +class Cassandra_describe_splits_presult +{ +public: + virtual ~Cassandra_describe_splits_presult() throw() + { + } - bool operator < (const Cassandra_remove_counter_result & ) const; + std::vector *success; + InvalidRequestException ire; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_describe_splits_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -typedef struct _Cassandra_remove_counter_presult__isset { - _Cassandra_remove_counter_presult__isset() : ire(false), ue(false), te(false) {} - bool ire; - bool ue; - bool te; -} _Cassandra_remove_counter_presult__isset; - -class Cassandra_remove_counter_presult { - public: +class Cassandra_system_add_column_family_args +{ +public: + Cassandra_system_add_column_family_args() + { + } - virtual ~Cassandra_remove_counter_presult() throw() {} + virtual ~Cassandra_system_add_column_family_args() throw() + { + } - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; + CfDef cf_def; - _Cassandra_remove_counter_presult__isset __isset; + bool operator==(const Cassandra_system_add_column_family_args &rhs) const + { + if(!(cf_def == rhs.cf_def)) + return false; + return true; + } + bool operator!=(const Cassandra_system_add_column_family_args &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + bool operator<(const Cassandra_system_add_column_family_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -class Cassandra_batch_mutate_args { - public: +class Cassandra_system_add_column_family_pargs +{ +public: + virtual ~Cassandra_system_add_column_family_pargs() throw() + { + } - Cassandra_batch_mutate_args() { - consistency_level = (ConsistencyLevel::type)1; + const CfDef *cf_def; - } + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; - virtual ~Cassandra_batch_mutate_args() throw() {} +typedef struct _Cassandra_system_add_column_family_result__isset +{ + _Cassandra_system_add_column_family_result__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_add_column_family_result__isset; - std::map > > mutation_map; - ConsistencyLevel::type consistency_level; +class Cassandra_system_add_column_family_result +{ +public: + Cassandra_system_add_column_family_result() : success("") + { + } + + virtual ~Cassandra_system_add_column_family_result() throw() + { + } + + std::string success; + InvalidRequestException ire; + SchemaDisagreementException sde; + + _Cassandra_system_add_column_family_result__isset __isset; + + bool operator==(const Cassandra_system_add_column_family_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(sde == rhs.sde)) + return false; + return true; + } + bool operator!=(const Cassandra_system_add_column_family_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_system_add_column_family_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_system_add_column_family_presult__isset +{ + _Cassandra_system_add_column_family_presult__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_add_column_family_presult__isset; - bool operator == (const Cassandra_batch_mutate_args & rhs) const - { - if (!(mutation_map == rhs.mutation_map)) - return false; - if (!(consistency_level == rhs.consistency_level)) - return false; - return true; - } - bool operator != (const Cassandra_batch_mutate_args &rhs) const { - return !(*this == rhs); - } +class Cassandra_system_add_column_family_presult +{ +public: + virtual ~Cassandra_system_add_column_family_presult() throw() + { + } - bool operator < (const Cassandra_batch_mutate_args & ) const; + std::string *success; + InvalidRequestException ire; + SchemaDisagreementException sde; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_system_add_column_family_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -class Cassandra_batch_mutate_pargs { - public: +class Cassandra_system_drop_column_family_args +{ +public: + Cassandra_system_drop_column_family_args() : column_family("") + { + } + virtual ~Cassandra_system_drop_column_family_args() throw() + { + } - virtual ~Cassandra_batch_mutate_pargs() throw() {} + std::string column_family; - const std::map > > * mutation_map; - const ConsistencyLevel::type* consistency_level; + bool operator==(const Cassandra_system_drop_column_family_args &rhs) const + { + if(!(column_family == rhs.column_family)) + return false; + return true; + } + bool operator!=(const Cassandra_system_drop_column_family_args &rhs) const + { + return !(*this == rhs); + } - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_system_drop_column_family_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_batch_mutate_result__isset { - _Cassandra_batch_mutate_result__isset() : ire(false), ue(false), te(false) {} - bool ire; - bool ue; - bool te; -} _Cassandra_batch_mutate_result__isset; -class Cassandra_batch_mutate_result { - public: +class Cassandra_system_drop_column_family_pargs +{ +public: + virtual ~Cassandra_system_drop_column_family_pargs() throw() + { + } - Cassandra_batch_mutate_result() { - } + const std::string *column_family; - virtual ~Cassandra_batch_mutate_result() throw() {} + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; +typedef struct _Cassandra_system_drop_column_family_result__isset +{ + _Cassandra_system_drop_column_family_result__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_drop_column_family_result__isset; - _Cassandra_batch_mutate_result__isset __isset; +class Cassandra_system_drop_column_family_result +{ +public: + Cassandra_system_drop_column_family_result() : success("") + { + } + + virtual ~Cassandra_system_drop_column_family_result() throw() + { + } + + std::string success; + InvalidRequestException ire; + SchemaDisagreementException sde; + + _Cassandra_system_drop_column_family_result__isset __isset; + + bool operator==(const Cassandra_system_drop_column_family_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(sde == rhs.sde)) + return false; + return true; + } + bool operator!=(const Cassandra_system_drop_column_family_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_system_drop_column_family_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_system_drop_column_family_presult__isset +{ + _Cassandra_system_drop_column_family_presult__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_drop_column_family_presult__isset; - bool operator == (const Cassandra_batch_mutate_result & rhs) const - { - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - return true; - } - bool operator != (const Cassandra_batch_mutate_result &rhs) const { - return !(*this == rhs); - } +class Cassandra_system_drop_column_family_presult +{ +public: + virtual ~Cassandra_system_drop_column_family_presult() throw() + { + } - bool operator < (const Cassandra_batch_mutate_result & ) const; + std::string *success; + InvalidRequestException ire; + SchemaDisagreementException sde; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_system_drop_column_family_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -typedef struct _Cassandra_batch_mutate_presult__isset { - _Cassandra_batch_mutate_presult__isset() : ire(false), ue(false), te(false) {} - bool ire; - bool ue; - bool te; -} _Cassandra_batch_mutate_presult__isset; - -class Cassandra_batch_mutate_presult { - public: +class Cassandra_system_add_keyspace_args +{ +public: + Cassandra_system_add_keyspace_args() + { + } - virtual ~Cassandra_batch_mutate_presult() throw() {} + virtual ~Cassandra_system_add_keyspace_args() throw() + { + } - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; + KsDef ks_def; - _Cassandra_batch_mutate_presult__isset __isset; + bool operator==(const Cassandra_system_add_keyspace_args &rhs) const + { + if(!(ks_def == rhs.ks_def)) + return false; + return true; + } + bool operator!=(const Cassandra_system_add_keyspace_args &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + bool operator<(const Cassandra_system_add_keyspace_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -class Cassandra_truncate_args { - public: - - Cassandra_truncate_args() : cfname("") { - } - - virtual ~Cassandra_truncate_args() throw() {} - - std::string cfname; - - bool operator == (const Cassandra_truncate_args & rhs) const - { - if (!(cfname == rhs.cfname)) - return false; - return true; - } - bool operator != (const Cassandra_truncate_args &rhs) const { - return !(*this == rhs); - } +class Cassandra_system_add_keyspace_pargs +{ +public: + virtual ~Cassandra_system_add_keyspace_pargs() throw() + { + } - bool operator < (const Cassandra_truncate_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + const KsDef *ks_def; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; +typedef struct _Cassandra_system_add_keyspace_result__isset +{ + _Cassandra_system_add_keyspace_result__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_add_keyspace_result__isset; -class Cassandra_truncate_pargs { - public: - +class Cassandra_system_add_keyspace_result +{ +public: + Cassandra_system_add_keyspace_result() : success("") + { + } + + virtual ~Cassandra_system_add_keyspace_result() throw() + { + } + + std::string success; + InvalidRequestException ire; + SchemaDisagreementException sde; + + _Cassandra_system_add_keyspace_result__isset __isset; + + bool operator==(const Cassandra_system_add_keyspace_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(sde == rhs.sde)) + return false; + return true; + } + bool operator!=(const Cassandra_system_add_keyspace_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_system_add_keyspace_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_system_add_keyspace_presult__isset +{ + _Cassandra_system_add_keyspace_presult__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_add_keyspace_presult__isset; - virtual ~Cassandra_truncate_pargs() throw() {} +class Cassandra_system_add_keyspace_presult +{ +public: + virtual ~Cassandra_system_add_keyspace_presult() throw() + { + } - const std::string* cfname; + std::string *success; + InvalidRequestException ire; + SchemaDisagreementException sde; - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_system_add_keyspace_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -typedef struct _Cassandra_truncate_result__isset { - _Cassandra_truncate_result__isset() : ire(false), ue(false) {} - bool ire; - bool ue; -} _Cassandra_truncate_result__isset; - -class Cassandra_truncate_result { - public: - - Cassandra_truncate_result() { - } - - virtual ~Cassandra_truncate_result() throw() {} - InvalidRequestException ire; - UnavailableException ue; +class Cassandra_system_drop_keyspace_args +{ +public: + Cassandra_system_drop_keyspace_args() : keyspace("") + { + } - _Cassandra_truncate_result__isset __isset; + virtual ~Cassandra_system_drop_keyspace_args() throw() + { + } - bool operator == (const Cassandra_truncate_result & rhs) const - { - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - return true; - } - bool operator != (const Cassandra_truncate_result &rhs) const { - return !(*this == rhs); - } + std::string keyspace; - bool operator < (const Cassandra_truncate_result & ) const; + bool operator==(const Cassandra_system_drop_keyspace_args &rhs) const + { + if(!(keyspace == rhs.keyspace)) + return false; + return true; + } + bool operator!=(const Cassandra_system_drop_keyspace_args &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_system_drop_keyspace_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_truncate_presult__isset { - _Cassandra_truncate_presult__isset() : ire(false), ue(false) {} - bool ire; - bool ue; -} _Cassandra_truncate_presult__isset; - -class Cassandra_truncate_presult { - public: - - - virtual ~Cassandra_truncate_presult() throw() {} - InvalidRequestException ire; - UnavailableException ue; +class Cassandra_system_drop_keyspace_pargs +{ +public: + virtual ~Cassandra_system_drop_keyspace_pargs() throw() + { + } - _Cassandra_truncate_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + const std::string *keyspace; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; +typedef struct _Cassandra_system_drop_keyspace_result__isset +{ + _Cassandra_system_drop_keyspace_result__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_drop_keyspace_result__isset; -class Cassandra_describe_schema_versions_args { - public: - - Cassandra_describe_schema_versions_args() { - } - - virtual ~Cassandra_describe_schema_versions_args() throw() {} - +class Cassandra_system_drop_keyspace_result +{ +public: + Cassandra_system_drop_keyspace_result() : success("") + { + } + + virtual ~Cassandra_system_drop_keyspace_result() throw() + { + } + + std::string success; + InvalidRequestException ire; + SchemaDisagreementException sde; + + _Cassandra_system_drop_keyspace_result__isset __isset; + + bool operator==(const Cassandra_system_drop_keyspace_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(sde == rhs.sde)) + return false; + return true; + } + bool operator!=(const Cassandra_system_drop_keyspace_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_system_drop_keyspace_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_system_drop_keyspace_presult__isset +{ + _Cassandra_system_drop_keyspace_presult__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_drop_keyspace_presult__isset; - bool operator == (const Cassandra_describe_schema_versions_args & /* rhs */) const - { - return true; - } - bool operator != (const Cassandra_describe_schema_versions_args &rhs) const { - return !(*this == rhs); - } +class Cassandra_system_drop_keyspace_presult +{ +public: + virtual ~Cassandra_system_drop_keyspace_presult() throw() + { + } - bool operator < (const Cassandra_describe_schema_versions_args & ) const; + std::string *success; + InvalidRequestException ire; + SchemaDisagreementException sde; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_system_drop_keyspace_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -class Cassandra_describe_schema_versions_pargs { - public: +class Cassandra_system_update_keyspace_args +{ +public: + Cassandra_system_update_keyspace_args() + { + } + virtual ~Cassandra_system_update_keyspace_args() throw() + { + } - virtual ~Cassandra_describe_schema_versions_pargs() throw() {} + KsDef ks_def; + bool operator==(const Cassandra_system_update_keyspace_args &rhs) const + { + if(!(ks_def == rhs.ks_def)) + return false; + return true; + } + bool operator!=(const Cassandra_system_update_keyspace_args &rhs) const + { + return !(*this == rhs); + } - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_system_update_keyspace_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_describe_schema_versions_result__isset { - _Cassandra_describe_schema_versions_result__isset() : success(false), ire(false) {} - bool success; - bool ire; -} _Cassandra_describe_schema_versions_result__isset; -class Cassandra_describe_schema_versions_result { - public: +class Cassandra_system_update_keyspace_pargs +{ +public: + virtual ~Cassandra_system_update_keyspace_pargs() throw() + { + } - Cassandra_describe_schema_versions_result() { - } + const KsDef *ks_def; - virtual ~Cassandra_describe_schema_versions_result() throw() {} + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; - std::map > success; - InvalidRequestException ire; +typedef struct _Cassandra_system_update_keyspace_result__isset +{ + _Cassandra_system_update_keyspace_result__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_update_keyspace_result__isset; - _Cassandra_describe_schema_versions_result__isset __isset; +class Cassandra_system_update_keyspace_result +{ +public: + Cassandra_system_update_keyspace_result() : success("") + { + } + + virtual ~Cassandra_system_update_keyspace_result() throw() + { + } + + std::string success; + InvalidRequestException ire; + SchemaDisagreementException sde; + + _Cassandra_system_update_keyspace_result__isset __isset; + + bool operator==(const Cassandra_system_update_keyspace_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(sde == rhs.sde)) + return false; + return true; + } + bool operator!=(const Cassandra_system_update_keyspace_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_system_update_keyspace_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_system_update_keyspace_presult__isset +{ + _Cassandra_system_update_keyspace_presult__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_update_keyspace_presult__isset; - bool operator == (const Cassandra_describe_schema_versions_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - return true; - } - bool operator != (const Cassandra_describe_schema_versions_result &rhs) const { - return !(*this == rhs); - } +class Cassandra_system_update_keyspace_presult +{ +public: + virtual ~Cassandra_system_update_keyspace_presult() throw() + { + } - bool operator < (const Cassandra_describe_schema_versions_result & ) const; + std::string *success; + InvalidRequestException ire; + SchemaDisagreementException sde; - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_system_update_keyspace_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -typedef struct _Cassandra_describe_schema_versions_presult__isset { - _Cassandra_describe_schema_versions_presult__isset() : success(false), ire(false) {} - bool success; - bool ire; -} _Cassandra_describe_schema_versions_presult__isset; - -class Cassandra_describe_schema_versions_presult { - public: +class Cassandra_system_update_column_family_args +{ +public: + Cassandra_system_update_column_family_args() + { + } - virtual ~Cassandra_describe_schema_versions_presult() throw() {} + virtual ~Cassandra_system_update_column_family_args() throw() + { + } - std::map > * success; - InvalidRequestException ire; + CfDef cf_def; - _Cassandra_describe_schema_versions_presult__isset __isset; + bool operator==(const Cassandra_system_update_column_family_args &rhs) const + { + if(!(cf_def == rhs.cf_def)) + return false; + return true; + } + bool operator!=(const Cassandra_system_update_column_family_args &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + bool operator<(const Cassandra_system_update_column_family_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -class Cassandra_describe_keyspaces_args { - public: +class Cassandra_system_update_column_family_pargs +{ +public: + virtual ~Cassandra_system_update_column_family_pargs() throw() + { + } - Cassandra_describe_keyspaces_args() { - } - - virtual ~Cassandra_describe_keyspaces_args() throw() {} - - - bool operator == (const Cassandra_describe_keyspaces_args & /* rhs */) const - { - return true; - } - bool operator != (const Cassandra_describe_keyspaces_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_keyspaces_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + const CfDef *cf_def; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; +typedef struct _Cassandra_system_update_column_family_result__isset +{ + _Cassandra_system_update_column_family_result__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_update_column_family_result__isset; -class Cassandra_describe_keyspaces_pargs { - public: - +class Cassandra_system_update_column_family_result +{ +public: + Cassandra_system_update_column_family_result() : success("") + { + } + + virtual ~Cassandra_system_update_column_family_result() throw() + { + } + + std::string success; + InvalidRequestException ire; + SchemaDisagreementException sde; + + _Cassandra_system_update_column_family_result__isset __isset; + + bool operator==( + const Cassandra_system_update_column_family_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(sde == rhs.sde)) + return false; + return true; + } + bool operator!=( + const Cassandra_system_update_column_family_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_system_update_column_family_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_system_update_column_family_presult__isset +{ + _Cassandra_system_update_column_family_presult__isset() + : success(false), ire(false), sde(false) + { + } + bool success; + bool ire; + bool sde; +} _Cassandra_system_update_column_family_presult__isset; - virtual ~Cassandra_describe_keyspaces_pargs() throw() {} +class Cassandra_system_update_column_family_presult +{ +public: + virtual ~Cassandra_system_update_column_family_presult() throw() + { + } + std::string *success; + InvalidRequestException ire; + SchemaDisagreementException sde; - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + _Cassandra_system_update_column_family_presult__isset __isset; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); }; -typedef struct _Cassandra_describe_keyspaces_result__isset { - _Cassandra_describe_keyspaces_result__isset() : success(false), ire(false) {} - bool success; - bool ire; -} _Cassandra_describe_keyspaces_result__isset; - -class Cassandra_describe_keyspaces_result { - public: - - Cassandra_describe_keyspaces_result() { - } - - virtual ~Cassandra_describe_keyspaces_result() throw() {} - std::vector success; - InvalidRequestException ire; +class Cassandra_execute_cql_query_args +{ +public: + Cassandra_execute_cql_query_args() : query("") + { + } - _Cassandra_describe_keyspaces_result__isset __isset; + virtual ~Cassandra_execute_cql_query_args() throw() + { + } - bool operator == (const Cassandra_describe_keyspaces_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - return true; - } - bool operator != (const Cassandra_describe_keyspaces_result &rhs) const { - return !(*this == rhs); - } + std::string query; + Compression::type compression; - bool operator < (const Cassandra_describe_keyspaces_result & ) const; + bool operator==(const Cassandra_execute_cql_query_args &rhs) const + { + if(!(query == rhs.query)) + return false; + if(!(compression == rhs.compression)) + return false; + return true; + } + bool operator!=(const Cassandra_execute_cql_query_args &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + bool operator<(const Cassandra_execute_cql_query_args &) const; + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_describe_keyspaces_presult__isset { - _Cassandra_describe_keyspaces_presult__isset() : success(false), ire(false) {} - bool success; - bool ire; -} _Cassandra_describe_keyspaces_presult__isset; - -class Cassandra_describe_keyspaces_presult { - public: - - - virtual ~Cassandra_describe_keyspaces_presult() throw() {} - - std::vector * success; - InvalidRequestException ire; - - _Cassandra_describe_keyspaces_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_describe_cluster_name_args { - public: - - Cassandra_describe_cluster_name_args() { - } - - virtual ~Cassandra_describe_cluster_name_args() throw() {} - - - bool operator == (const Cassandra_describe_cluster_name_args & /* rhs */) const - { - return true; - } - bool operator != (const Cassandra_describe_cluster_name_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_cluster_name_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_describe_cluster_name_pargs { - public: - - - virtual ~Cassandra_describe_cluster_name_pargs() throw() {} - - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_cluster_name_result__isset { - _Cassandra_describe_cluster_name_result__isset() : success(false) {} - bool success; -} _Cassandra_describe_cluster_name_result__isset; - -class Cassandra_describe_cluster_name_result { - public: - - Cassandra_describe_cluster_name_result() : success("") { - } - - virtual ~Cassandra_describe_cluster_name_result() throw() {} - - std::string success; - - _Cassandra_describe_cluster_name_result__isset __isset; - - bool operator == (const Cassandra_describe_cluster_name_result & rhs) const - { - if (!(success == rhs.success)) - return false; - return true; - } - bool operator != (const Cassandra_describe_cluster_name_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_cluster_name_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_cluster_name_presult__isset { - _Cassandra_describe_cluster_name_presult__isset() : success(false) {} - bool success; -} _Cassandra_describe_cluster_name_presult__isset; - -class Cassandra_describe_cluster_name_presult { - public: - - - virtual ~Cassandra_describe_cluster_name_presult() throw() {} - - std::string* success; - - _Cassandra_describe_cluster_name_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_describe_version_args { - public: - - Cassandra_describe_version_args() { - } - - virtual ~Cassandra_describe_version_args() throw() {} - - - bool operator == (const Cassandra_describe_version_args & /* rhs */) const - { - return true; - } - bool operator != (const Cassandra_describe_version_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_version_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_describe_version_pargs { - public: - - - virtual ~Cassandra_describe_version_pargs() throw() {} - - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_version_result__isset { - _Cassandra_describe_version_result__isset() : success(false) {} - bool success; -} _Cassandra_describe_version_result__isset; - -class Cassandra_describe_version_result { - public: - - Cassandra_describe_version_result() : success("") { - } - - virtual ~Cassandra_describe_version_result() throw() {} - - std::string success; - - _Cassandra_describe_version_result__isset __isset; - - bool operator == (const Cassandra_describe_version_result & rhs) const - { - if (!(success == rhs.success)) - return false; - return true; - } - bool operator != (const Cassandra_describe_version_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_version_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_version_presult__isset { - _Cassandra_describe_version_presult__isset() : success(false) {} - bool success; -} _Cassandra_describe_version_presult__isset; - -class Cassandra_describe_version_presult { - public: - - - virtual ~Cassandra_describe_version_presult() throw() {} - - std::string* success; - - _Cassandra_describe_version_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_describe_ring_args { - public: - - Cassandra_describe_ring_args() : keyspace("") { - } - - virtual ~Cassandra_describe_ring_args() throw() {} - - std::string keyspace; - - bool operator == (const Cassandra_describe_ring_args & rhs) const - { - if (!(keyspace == rhs.keyspace)) - return false; - return true; - } - bool operator != (const Cassandra_describe_ring_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_ring_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_describe_ring_pargs { - public: - - - virtual ~Cassandra_describe_ring_pargs() throw() {} - - const std::string* keyspace; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_ring_result__isset { - _Cassandra_describe_ring_result__isset() : success(false), ire(false) {} - bool success; - bool ire; -} _Cassandra_describe_ring_result__isset; - -class Cassandra_describe_ring_result { - public: - - Cassandra_describe_ring_result() { - } - - virtual ~Cassandra_describe_ring_result() throw() {} - - std::vector success; - InvalidRequestException ire; - - _Cassandra_describe_ring_result__isset __isset; - - bool operator == (const Cassandra_describe_ring_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - return true; - } - bool operator != (const Cassandra_describe_ring_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_ring_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_ring_presult__isset { - _Cassandra_describe_ring_presult__isset() : success(false), ire(false) {} - bool success; - bool ire; -} _Cassandra_describe_ring_presult__isset; - -class Cassandra_describe_ring_presult { - public: - - - virtual ~Cassandra_describe_ring_presult() throw() {} - - std::vector * success; - InvalidRequestException ire; - - _Cassandra_describe_ring_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_describe_partitioner_args { - public: - - Cassandra_describe_partitioner_args() { - } - - virtual ~Cassandra_describe_partitioner_args() throw() {} - - - bool operator == (const Cassandra_describe_partitioner_args & /* rhs */) const - { - return true; - } - bool operator != (const Cassandra_describe_partitioner_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_partitioner_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_describe_partitioner_pargs { - public: - - - virtual ~Cassandra_describe_partitioner_pargs() throw() {} - - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_partitioner_result__isset { - _Cassandra_describe_partitioner_result__isset() : success(false) {} - bool success; -} _Cassandra_describe_partitioner_result__isset; - -class Cassandra_describe_partitioner_result { - public: - - Cassandra_describe_partitioner_result() : success("") { - } - - virtual ~Cassandra_describe_partitioner_result() throw() {} - - std::string success; - - _Cassandra_describe_partitioner_result__isset __isset; - - bool operator == (const Cassandra_describe_partitioner_result & rhs) const - { - if (!(success == rhs.success)) - return false; - return true; - } - bool operator != (const Cassandra_describe_partitioner_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_partitioner_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_partitioner_presult__isset { - _Cassandra_describe_partitioner_presult__isset() : success(false) {} - bool success; -} _Cassandra_describe_partitioner_presult__isset; - -class Cassandra_describe_partitioner_presult { - public: - - - virtual ~Cassandra_describe_partitioner_presult() throw() {} - - std::string* success; - - _Cassandra_describe_partitioner_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_describe_snitch_args { - public: - - Cassandra_describe_snitch_args() { - } - - virtual ~Cassandra_describe_snitch_args() throw() {} - - - bool operator == (const Cassandra_describe_snitch_args & /* rhs */) const - { - return true; - } - bool operator != (const Cassandra_describe_snitch_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_snitch_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_describe_snitch_pargs { - public: - - - virtual ~Cassandra_describe_snitch_pargs() throw() {} - - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_snitch_result__isset { - _Cassandra_describe_snitch_result__isset() : success(false) {} - bool success; -} _Cassandra_describe_snitch_result__isset; - -class Cassandra_describe_snitch_result { - public: - - Cassandra_describe_snitch_result() : success("") { - } - - virtual ~Cassandra_describe_snitch_result() throw() {} - - std::string success; - - _Cassandra_describe_snitch_result__isset __isset; - - bool operator == (const Cassandra_describe_snitch_result & rhs) const - { - if (!(success == rhs.success)) - return false; - return true; - } - bool operator != (const Cassandra_describe_snitch_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_snitch_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_snitch_presult__isset { - _Cassandra_describe_snitch_presult__isset() : success(false) {} - bool success; -} _Cassandra_describe_snitch_presult__isset; - -class Cassandra_describe_snitch_presult { - public: - - - virtual ~Cassandra_describe_snitch_presult() throw() {} - - std::string* success; - - _Cassandra_describe_snitch_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_describe_keyspace_args { - public: - - Cassandra_describe_keyspace_args() : keyspace("") { - } - - virtual ~Cassandra_describe_keyspace_args() throw() {} - - std::string keyspace; - - bool operator == (const Cassandra_describe_keyspace_args & rhs) const - { - if (!(keyspace == rhs.keyspace)) - return false; - return true; - } - bool operator != (const Cassandra_describe_keyspace_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_keyspace_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_describe_keyspace_pargs { - public: - - - virtual ~Cassandra_describe_keyspace_pargs() throw() {} - - const std::string* keyspace; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_keyspace_result__isset { - _Cassandra_describe_keyspace_result__isset() : success(false), nfe(false), ire(false) {} - bool success; - bool nfe; - bool ire; -} _Cassandra_describe_keyspace_result__isset; - -class Cassandra_describe_keyspace_result { - public: - - Cassandra_describe_keyspace_result() { - } - - virtual ~Cassandra_describe_keyspace_result() throw() {} - - KsDef success; - NotFoundException nfe; - InvalidRequestException ire; - - _Cassandra_describe_keyspace_result__isset __isset; - - bool operator == (const Cassandra_describe_keyspace_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(nfe == rhs.nfe)) - return false; - if (!(ire == rhs.ire)) - return false; - return true; - } - bool operator != (const Cassandra_describe_keyspace_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_keyspace_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_keyspace_presult__isset { - _Cassandra_describe_keyspace_presult__isset() : success(false), nfe(false), ire(false) {} - bool success; - bool nfe; - bool ire; -} _Cassandra_describe_keyspace_presult__isset; - -class Cassandra_describe_keyspace_presult { - public: - - - virtual ~Cassandra_describe_keyspace_presult() throw() {} - - KsDef* success; - NotFoundException nfe; - InvalidRequestException ire; - - _Cassandra_describe_keyspace_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_describe_splits_args { - public: - - Cassandra_describe_splits_args() : cfName(""), start_token(""), end_token(""), keys_per_split(0) { - } - - virtual ~Cassandra_describe_splits_args() throw() {} - - std::string cfName; - std::string start_token; - std::string end_token; - int32_t keys_per_split; - - bool operator == (const Cassandra_describe_splits_args & rhs) const - { - if (!(cfName == rhs.cfName)) - return false; - if (!(start_token == rhs.start_token)) - return false; - if (!(end_token == rhs.end_token)) - return false; - if (!(keys_per_split == rhs.keys_per_split)) - return false; - return true; - } - bool operator != (const Cassandra_describe_splits_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_splits_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_describe_splits_pargs { - public: - - - virtual ~Cassandra_describe_splits_pargs() throw() {} - - const std::string* cfName; - const std::string* start_token; - const std::string* end_token; - const int32_t* keys_per_split; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_splits_result__isset { - _Cassandra_describe_splits_result__isset() : success(false), ire(false) {} - bool success; - bool ire; -} _Cassandra_describe_splits_result__isset; - -class Cassandra_describe_splits_result { - public: - - Cassandra_describe_splits_result() { - } - - virtual ~Cassandra_describe_splits_result() throw() {} - - std::vector success; - InvalidRequestException ire; - - _Cassandra_describe_splits_result__isset __isset; - - bool operator == (const Cassandra_describe_splits_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - return true; - } - bool operator != (const Cassandra_describe_splits_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_describe_splits_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_describe_splits_presult__isset { - _Cassandra_describe_splits_presult__isset() : success(false), ire(false) {} - bool success; - bool ire; -} _Cassandra_describe_splits_presult__isset; - -class Cassandra_describe_splits_presult { - public: - - - virtual ~Cassandra_describe_splits_presult() throw() {} - - std::vector * success; - InvalidRequestException ire; - - _Cassandra_describe_splits_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_system_add_column_family_args { - public: - - Cassandra_system_add_column_family_args() { - } - - virtual ~Cassandra_system_add_column_family_args() throw() {} - - CfDef cf_def; - - bool operator == (const Cassandra_system_add_column_family_args & rhs) const - { - if (!(cf_def == rhs.cf_def)) - return false; - return true; - } - bool operator != (const Cassandra_system_add_column_family_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_add_column_family_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_system_add_column_family_pargs { - public: - - - virtual ~Cassandra_system_add_column_family_pargs() throw() {} - - const CfDef* cf_def; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_add_column_family_result__isset { - _Cassandra_system_add_column_family_result__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_add_column_family_result__isset; - -class Cassandra_system_add_column_family_result { - public: - - Cassandra_system_add_column_family_result() : success("") { - } - - virtual ~Cassandra_system_add_column_family_result() throw() {} - - std::string success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_add_column_family_result__isset __isset; - - bool operator == (const Cassandra_system_add_column_family_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(sde == rhs.sde)) - return false; - return true; - } - bool operator != (const Cassandra_system_add_column_family_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_add_column_family_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_add_column_family_presult__isset { - _Cassandra_system_add_column_family_presult__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_add_column_family_presult__isset; - -class Cassandra_system_add_column_family_presult { - public: - - - virtual ~Cassandra_system_add_column_family_presult() throw() {} - - std::string* success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_add_column_family_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_system_drop_column_family_args { - public: - - Cassandra_system_drop_column_family_args() : column_family("") { - } - - virtual ~Cassandra_system_drop_column_family_args() throw() {} - - std::string column_family; - - bool operator == (const Cassandra_system_drop_column_family_args & rhs) const - { - if (!(column_family == rhs.column_family)) - return false; - return true; - } - bool operator != (const Cassandra_system_drop_column_family_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_drop_column_family_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_system_drop_column_family_pargs { - public: - - - virtual ~Cassandra_system_drop_column_family_pargs() throw() {} - - const std::string* column_family; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_drop_column_family_result__isset { - _Cassandra_system_drop_column_family_result__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_drop_column_family_result__isset; - -class Cassandra_system_drop_column_family_result { - public: - - Cassandra_system_drop_column_family_result() : success("") { - } - - virtual ~Cassandra_system_drop_column_family_result() throw() {} - - std::string success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_drop_column_family_result__isset __isset; - - bool operator == (const Cassandra_system_drop_column_family_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(sde == rhs.sde)) - return false; - return true; - } - bool operator != (const Cassandra_system_drop_column_family_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_drop_column_family_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_drop_column_family_presult__isset { - _Cassandra_system_drop_column_family_presult__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_drop_column_family_presult__isset; - -class Cassandra_system_drop_column_family_presult { - public: - - - virtual ~Cassandra_system_drop_column_family_presult() throw() {} - - std::string* success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_drop_column_family_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_system_add_keyspace_args { - public: - - Cassandra_system_add_keyspace_args() { - } - - virtual ~Cassandra_system_add_keyspace_args() throw() {} - - KsDef ks_def; - - bool operator == (const Cassandra_system_add_keyspace_args & rhs) const - { - if (!(ks_def == rhs.ks_def)) - return false; - return true; - } - bool operator != (const Cassandra_system_add_keyspace_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_add_keyspace_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_system_add_keyspace_pargs { - public: - - - virtual ~Cassandra_system_add_keyspace_pargs() throw() {} - - const KsDef* ks_def; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_add_keyspace_result__isset { - _Cassandra_system_add_keyspace_result__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_add_keyspace_result__isset; - -class Cassandra_system_add_keyspace_result { - public: - - Cassandra_system_add_keyspace_result() : success("") { - } - - virtual ~Cassandra_system_add_keyspace_result() throw() {} - - std::string success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_add_keyspace_result__isset __isset; - - bool operator == (const Cassandra_system_add_keyspace_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(sde == rhs.sde)) - return false; - return true; - } - bool operator != (const Cassandra_system_add_keyspace_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_add_keyspace_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_add_keyspace_presult__isset { - _Cassandra_system_add_keyspace_presult__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_add_keyspace_presult__isset; - -class Cassandra_system_add_keyspace_presult { - public: - - - virtual ~Cassandra_system_add_keyspace_presult() throw() {} - - std::string* success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_add_keyspace_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_system_drop_keyspace_args { - public: - - Cassandra_system_drop_keyspace_args() : keyspace("") { - } - - virtual ~Cassandra_system_drop_keyspace_args() throw() {} - - std::string keyspace; - - bool operator == (const Cassandra_system_drop_keyspace_args & rhs) const - { - if (!(keyspace == rhs.keyspace)) - return false; - return true; - } - bool operator != (const Cassandra_system_drop_keyspace_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_drop_keyspace_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_system_drop_keyspace_pargs { - public: - - - virtual ~Cassandra_system_drop_keyspace_pargs() throw() {} - - const std::string* keyspace; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_drop_keyspace_result__isset { - _Cassandra_system_drop_keyspace_result__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_drop_keyspace_result__isset; - -class Cassandra_system_drop_keyspace_result { - public: - - Cassandra_system_drop_keyspace_result() : success("") { - } - - virtual ~Cassandra_system_drop_keyspace_result() throw() {} - - std::string success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_drop_keyspace_result__isset __isset; - - bool operator == (const Cassandra_system_drop_keyspace_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(sde == rhs.sde)) - return false; - return true; - } - bool operator != (const Cassandra_system_drop_keyspace_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_drop_keyspace_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_drop_keyspace_presult__isset { - _Cassandra_system_drop_keyspace_presult__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_drop_keyspace_presult__isset; - -class Cassandra_system_drop_keyspace_presult { - public: - - - virtual ~Cassandra_system_drop_keyspace_presult() throw() {} - - std::string* success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_drop_keyspace_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_system_update_keyspace_args { - public: - - Cassandra_system_update_keyspace_args() { - } - - virtual ~Cassandra_system_update_keyspace_args() throw() {} - - KsDef ks_def; - - bool operator == (const Cassandra_system_update_keyspace_args & rhs) const - { - if (!(ks_def == rhs.ks_def)) - return false; - return true; - } - bool operator != (const Cassandra_system_update_keyspace_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_update_keyspace_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_system_update_keyspace_pargs { - public: - - - virtual ~Cassandra_system_update_keyspace_pargs() throw() {} - - const KsDef* ks_def; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_update_keyspace_result__isset { - _Cassandra_system_update_keyspace_result__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_update_keyspace_result__isset; - -class Cassandra_system_update_keyspace_result { - public: - - Cassandra_system_update_keyspace_result() : success("") { - } - - virtual ~Cassandra_system_update_keyspace_result() throw() {} - - std::string success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_update_keyspace_result__isset __isset; - - bool operator == (const Cassandra_system_update_keyspace_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(sde == rhs.sde)) - return false; - return true; - } - bool operator != (const Cassandra_system_update_keyspace_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_update_keyspace_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_update_keyspace_presult__isset { - _Cassandra_system_update_keyspace_presult__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_update_keyspace_presult__isset; - -class Cassandra_system_update_keyspace_presult { - public: - - - virtual ~Cassandra_system_update_keyspace_presult() throw() {} - - std::string* success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_update_keyspace_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_system_update_column_family_args { - public: - - Cassandra_system_update_column_family_args() { - } - - virtual ~Cassandra_system_update_column_family_args() throw() {} - - CfDef cf_def; - - bool operator == (const Cassandra_system_update_column_family_args & rhs) const - { - if (!(cf_def == rhs.cf_def)) - return false; - return true; - } - bool operator != (const Cassandra_system_update_column_family_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_update_column_family_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_system_update_column_family_pargs { - public: - - - virtual ~Cassandra_system_update_column_family_pargs() throw() {} - - const CfDef* cf_def; - - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_update_column_family_result__isset { - _Cassandra_system_update_column_family_result__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_update_column_family_result__isset; - -class Cassandra_system_update_column_family_result { - public: - - Cassandra_system_update_column_family_result() : success("") { - } - - virtual ~Cassandra_system_update_column_family_result() throw() {} - - std::string success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_update_column_family_result__isset __isset; - - bool operator == (const Cassandra_system_update_column_family_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(sde == rhs.sde)) - return false; - return true; - } - bool operator != (const Cassandra_system_update_column_family_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_system_update_column_family_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_system_update_column_family_presult__isset { - _Cassandra_system_update_column_family_presult__isset() : success(false), ire(false), sde(false) {} - bool success; - bool ire; - bool sde; -} _Cassandra_system_update_column_family_presult__isset; - -class Cassandra_system_update_column_family_presult { - public: - - - virtual ~Cassandra_system_update_column_family_presult() throw() {} - - std::string* success; - InvalidRequestException ire; - SchemaDisagreementException sde; - - _Cassandra_system_update_column_family_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - - -class Cassandra_execute_cql_query_args { - public: - - Cassandra_execute_cql_query_args() : query("") { - } - - virtual ~Cassandra_execute_cql_query_args() throw() {} - - std::string query; - Compression::type compression; - - bool operator == (const Cassandra_execute_cql_query_args & rhs) const - { - if (!(query == rhs.query)) - return false; - if (!(compression == rhs.compression)) - return false; - return true; - } - bool operator != (const Cassandra_execute_cql_query_args &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_execute_cql_query_args & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - - -class Cassandra_execute_cql_query_pargs { - public: - - - virtual ~Cassandra_execute_cql_query_pargs() throw() {} - const std::string* query; - const Compression::type* compression; +class Cassandra_execute_cql_query_pargs +{ +public: + virtual ~Cassandra_execute_cql_query_pargs() throw() + { + } - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + const std::string *query; + const Compression::type *compression; + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; }; -typedef struct _Cassandra_execute_cql_query_result__isset { - _Cassandra_execute_cql_query_result__isset() : success(false), ire(false), ue(false), te(false), sde(false) {} - bool success; - bool ire; - bool ue; - bool te; - bool sde; +typedef struct _Cassandra_execute_cql_query_result__isset +{ + _Cassandra_execute_cql_query_result__isset() + : success(false), ire(false), ue(false), te(false), sde(false) + { + } + bool success; + bool ire; + bool ue; + bool te; + bool sde; } _Cassandra_execute_cql_query_result__isset; -class Cassandra_execute_cql_query_result { - public: - - Cassandra_execute_cql_query_result() { - } - - virtual ~Cassandra_execute_cql_query_result() throw() {} - - CqlResult success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; - SchemaDisagreementException sde; - - _Cassandra_execute_cql_query_result__isset __isset; - - bool operator == (const Cassandra_execute_cql_query_result & rhs) const - { - if (!(success == rhs.success)) - return false; - if (!(ire == rhs.ire)) - return false; - if (!(ue == rhs.ue)) - return false; - if (!(te == rhs.te)) - return false; - if (!(sde == rhs.sde)) - return false; - return true; - } - bool operator != (const Cassandra_execute_cql_query_result &rhs) const { - return !(*this == rhs); - } - - bool operator < (const Cassandra_execute_cql_query_result & ) const; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - -}; - -typedef struct _Cassandra_execute_cql_query_presult__isset { - _Cassandra_execute_cql_query_presult__isset() : success(false), ire(false), ue(false), te(false), sde(false) {} - bool success; - bool ire; - bool ue; - bool te; - bool sde; +class Cassandra_execute_cql_query_result +{ +public: + Cassandra_execute_cql_query_result() + { + } + + virtual ~Cassandra_execute_cql_query_result() throw() + { + } + + CqlResult success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + SchemaDisagreementException sde; + + _Cassandra_execute_cql_query_result__isset __isset; + + bool operator==(const Cassandra_execute_cql_query_result &rhs) const + { + if(!(success == rhs.success)) + return false; + if(!(ire == rhs.ire)) + return false; + if(!(ue == rhs.ue)) + return false; + if(!(te == rhs.te)) + return false; + if(!(sde == rhs.sde)) + return false; + return true; + } + bool operator!=(const Cassandra_execute_cql_query_result &rhs) const + { + return !(*this == rhs); + } + + bool operator<(const Cassandra_execute_cql_query_result &) const; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); + uint32_t write(::apache::thrift::protocol::TProtocol *oprot) const; +}; + +typedef struct _Cassandra_execute_cql_query_presult__isset +{ + _Cassandra_execute_cql_query_presult__isset() + : success(false), ire(false), ue(false), te(false), sde(false) + { + } + bool success; + bool ire; + bool ue; + bool te; + bool sde; } _Cassandra_execute_cql_query_presult__isset; -class Cassandra_execute_cql_query_presult { - public: - - - virtual ~Cassandra_execute_cql_query_presult() throw() {} - - CqlResult* success; - InvalidRequestException ire; - UnavailableException ue; - TimedOutException te; - SchemaDisagreementException sde; - - _Cassandra_execute_cql_query_presult__isset __isset; - - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - -}; - -class CassandraClient : virtual public CassandraIf { - public: - CassandraClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) : - piprot_(prot), - poprot_(prot) { - iprot_ = prot.get(); - oprot_ = prot.get(); - } - CassandraClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) : - piprot_(iprot), - poprot_(oprot) { - iprot_ = iprot.get(); - oprot_ = oprot.get(); - } - boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { - return piprot_; - } - boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { - return poprot_; - } - void login(const AuthenticationRequest& auth_request); - void send_login(const AuthenticationRequest& auth_request); - void recv_login(); - void set_keyspace(const std::string& keyspace); - void send_set_keyspace(const std::string& keyspace); - void recv_set_keyspace(); - void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level); - void send_get(const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level); - void recv_get(ColumnOrSuperColumn& _return); - void get_slice(std::vector & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); - void send_get_slice(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); - void recv_get_slice(std::vector & _return); - int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); - void send_get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); - int32_t recv_get_count(); - void multiget_slice(std::map > & _return, const std::vector & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); - void send_multiget_slice(const std::vector & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); - void recv_multiget_slice(std::map > & _return); - void multiget_count(std::map & _return, const std::vector & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); - void send_multiget_count(const std::vector & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); - void recv_multiget_count(std::map & _return); - void get_range_slices(std::vector & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level); - void send_get_range_slices(const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level); - void recv_get_range_slices(std::vector & _return); - void get_indexed_slices(std::vector & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level); - void send_get_indexed_slices(const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level); - void recv_get_indexed_slices(std::vector & _return); - void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level); - void send_insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level); - void recv_insert(); - void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level); - void send_add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level); - void recv_add(); - void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level); - void send_remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level); - void recv_remove(); - void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level); - void send_remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level); - void recv_remove_counter(); - void batch_mutate(const std::map > > & mutation_map, const ConsistencyLevel::type consistency_level); - void send_batch_mutate(const std::map > > & mutation_map, const ConsistencyLevel::type consistency_level); - void recv_batch_mutate(); - void truncate(const std::string& cfname); - void send_truncate(const std::string& cfname); - void recv_truncate(); - void describe_schema_versions(std::map > & _return); - void send_describe_schema_versions(); - void recv_describe_schema_versions(std::map > & _return); - void describe_keyspaces(std::vector & _return); - void send_describe_keyspaces(); - void recv_describe_keyspaces(std::vector & _return); - void describe_cluster_name(std::string& _return); - void send_describe_cluster_name(); - void recv_describe_cluster_name(std::string& _return); - void describe_version(std::string& _return); - void send_describe_version(); - void recv_describe_version(std::string& _return); - void describe_ring(std::vector & _return, const std::string& keyspace); - void send_describe_ring(const std::string& keyspace); - void recv_describe_ring(std::vector & _return); - void describe_partitioner(std::string& _return); - void send_describe_partitioner(); - void recv_describe_partitioner(std::string& _return); - void describe_snitch(std::string& _return); - void send_describe_snitch(); - void recv_describe_snitch(std::string& _return); - void describe_keyspace(KsDef& _return, const std::string& keyspace); - void send_describe_keyspace(const std::string& keyspace); - void recv_describe_keyspace(KsDef& _return); - void describe_splits(std::vector & _return, const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split); - void send_describe_splits(const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split); - void recv_describe_splits(std::vector & _return); - void system_add_column_family(std::string& _return, const CfDef& cf_def); - void send_system_add_column_family(const CfDef& cf_def); - void recv_system_add_column_family(std::string& _return); - void system_drop_column_family(std::string& _return, const std::string& column_family); - void send_system_drop_column_family(const std::string& column_family); - void recv_system_drop_column_family(std::string& _return); - void system_add_keyspace(std::string& _return, const KsDef& ks_def); - void send_system_add_keyspace(const KsDef& ks_def); - void recv_system_add_keyspace(std::string& _return); - void system_drop_keyspace(std::string& _return, const std::string& keyspace); - void send_system_drop_keyspace(const std::string& keyspace); - void recv_system_drop_keyspace(std::string& _return); - void system_update_keyspace(std::string& _return, const KsDef& ks_def); - void send_system_update_keyspace(const KsDef& ks_def); - void recv_system_update_keyspace(std::string& _return); - void system_update_column_family(std::string& _return, const CfDef& cf_def); - void send_system_update_column_family(const CfDef& cf_def); - void recv_system_update_column_family(std::string& _return); - void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression); - void send_execute_cql_query(const std::string& query, const Compression::type compression); - void recv_execute_cql_query(CqlResult& _return); - protected: - boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; - boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; - ::apache::thrift::protocol::TProtocol* iprot_; - ::apache::thrift::protocol::TProtocol* oprot_; -}; - -class CassandraProcessor : virtual public ::apache::thrift::TProcessor { - protected: - boost::shared_ptr iface_; - virtual bool process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid, void* callContext); - private: - std::map processMap_; - void process_login(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_set_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_get_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_get_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_multiget_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_multiget_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_get_range_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_get_indexed_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_insert(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_add(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_remove(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_remove_counter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_batch_mutate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_truncate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_describe_schema_versions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_describe_keyspaces(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_describe_cluster_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_describe_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_describe_ring(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_describe_partitioner(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_describe_snitch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_describe_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_describe_splits(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_system_add_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_system_drop_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_system_add_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_system_drop_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_system_update_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_system_update_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - void process_execute_cql_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); - public: - CassandraProcessor(boost::shared_ptr iface) : - iface_(iface) { - processMap_["login"] = &CassandraProcessor::process_login; - processMap_["set_keyspace"] = &CassandraProcessor::process_set_keyspace; - processMap_["get"] = &CassandraProcessor::process_get; - processMap_["get_slice"] = &CassandraProcessor::process_get_slice; - processMap_["get_count"] = &CassandraProcessor::process_get_count; - processMap_["multiget_slice"] = &CassandraProcessor::process_multiget_slice; - processMap_["multiget_count"] = &CassandraProcessor::process_multiget_count; - processMap_["get_range_slices"] = &CassandraProcessor::process_get_range_slices; - processMap_["get_indexed_slices"] = &CassandraProcessor::process_get_indexed_slices; - processMap_["insert"] = &CassandraProcessor::process_insert; - processMap_["add"] = &CassandraProcessor::process_add; - processMap_["remove"] = &CassandraProcessor::process_remove; - processMap_["remove_counter"] = &CassandraProcessor::process_remove_counter; - processMap_["batch_mutate"] = &CassandraProcessor::process_batch_mutate; - processMap_["truncate"] = &CassandraProcessor::process_truncate; - processMap_["describe_schema_versions"] = &CassandraProcessor::process_describe_schema_versions; - processMap_["describe_keyspaces"] = &CassandraProcessor::process_describe_keyspaces; - processMap_["describe_cluster_name"] = &CassandraProcessor::process_describe_cluster_name; - processMap_["describe_version"] = &CassandraProcessor::process_describe_version; - processMap_["describe_ring"] = &CassandraProcessor::process_describe_ring; - processMap_["describe_partitioner"] = &CassandraProcessor::process_describe_partitioner; - processMap_["describe_snitch"] = &CassandraProcessor::process_describe_snitch; - processMap_["describe_keyspace"] = &CassandraProcessor::process_describe_keyspace; - processMap_["describe_splits"] = &CassandraProcessor::process_describe_splits; - processMap_["system_add_column_family"] = &CassandraProcessor::process_system_add_column_family; - processMap_["system_drop_column_family"] = &CassandraProcessor::process_system_drop_column_family; - processMap_["system_add_keyspace"] = &CassandraProcessor::process_system_add_keyspace; - processMap_["system_drop_keyspace"] = &CassandraProcessor::process_system_drop_keyspace; - processMap_["system_update_keyspace"] = &CassandraProcessor::process_system_update_keyspace; - processMap_["system_update_column_family"] = &CassandraProcessor::process_system_update_column_family; - processMap_["execute_cql_query"] = &CassandraProcessor::process_execute_cql_query; - } - - virtual bool process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot, void* callContext); - virtual ~CassandraProcessor() {} -}; - -class CassandraMultiface : virtual public CassandraIf { - public: - CassandraMultiface(std::vector >& ifaces) : ifaces_(ifaces) { - } - virtual ~CassandraMultiface() {} - protected: - std::vector > ifaces_; - CassandraMultiface() {} - void add(boost::shared_ptr iface) { - ifaces_.push_back(iface); - } - public: - void login(const AuthenticationRequest& auth_request) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - ifaces_[i]->login(auth_request); - } - } - - void set_keyspace(const std::string& keyspace) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - ifaces_[i]->set_keyspace(keyspace); - } - } - - void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->get(_return, key, column_path, consistency_level); - return; - } else { - ifaces_[i]->get(_return, key, column_path, consistency_level); - } - } - } - - void get_slice(std::vector & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->get_slice(_return, key, column_parent, predicate, consistency_level); - return; - } else { - ifaces_[i]->get_slice(_return, key, column_parent, predicate, consistency_level); - } - } - } - - int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - return ifaces_[i]->get_count(key, column_parent, predicate, consistency_level); - } else { - ifaces_[i]->get_count(key, column_parent, predicate, consistency_level); - } - } - } - - void multiget_slice(std::map > & _return, const std::vector & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->multiget_slice(_return, keys, column_parent, predicate, consistency_level); - return; - } else { - ifaces_[i]->multiget_slice(_return, keys, column_parent, predicate, consistency_level); - } - } - } - - void multiget_count(std::map & _return, const std::vector & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->multiget_count(_return, keys, column_parent, predicate, consistency_level); - return; - } else { - ifaces_[i]->multiget_count(_return, keys, column_parent, predicate, consistency_level); - } - } - } - - void get_range_slices(std::vector & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->get_range_slices(_return, column_parent, predicate, range, consistency_level); - return; - } else { - ifaces_[i]->get_range_slices(_return, column_parent, predicate, range, consistency_level); - } - } - } - - void get_indexed_slices(std::vector & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->get_indexed_slices(_return, column_parent, index_clause, column_predicate, consistency_level); - return; - } else { - ifaces_[i]->get_indexed_slices(_return, column_parent, index_clause, column_predicate, consistency_level); - } - } - } - - void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - ifaces_[i]->insert(key, column_parent, column, consistency_level); - } - } - - void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - ifaces_[i]->add(key, column_parent, column, consistency_level); - } - } - - void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - ifaces_[i]->remove(key, column_path, timestamp, consistency_level); - } - } - - void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - ifaces_[i]->remove_counter(key, path, consistency_level); - } - } - - void batch_mutate(const std::map > > & mutation_map, const ConsistencyLevel::type consistency_level) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - ifaces_[i]->batch_mutate(mutation_map, consistency_level); - } - } - - void truncate(const std::string& cfname) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - ifaces_[i]->truncate(cfname); - } - } - - void describe_schema_versions(std::map > & _return) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->describe_schema_versions(_return); - return; - } else { - ifaces_[i]->describe_schema_versions(_return); - } - } - } - - void describe_keyspaces(std::vector & _return) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->describe_keyspaces(_return); - return; - } else { - ifaces_[i]->describe_keyspaces(_return); - } - } - } - - void describe_cluster_name(std::string& _return) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->describe_cluster_name(_return); - return; - } else { - ifaces_[i]->describe_cluster_name(_return); - } - } - } - - void describe_version(std::string& _return) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->describe_version(_return); - return; - } else { - ifaces_[i]->describe_version(_return); - } - } - } - - void describe_ring(std::vector & _return, const std::string& keyspace) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->describe_ring(_return, keyspace); - return; - } else { - ifaces_[i]->describe_ring(_return, keyspace); - } - } - } - - void describe_partitioner(std::string& _return) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->describe_partitioner(_return); - return; - } else { - ifaces_[i]->describe_partitioner(_return); - } - } - } - - void describe_snitch(std::string& _return) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->describe_snitch(_return); - return; - } else { - ifaces_[i]->describe_snitch(_return); - } - } - } - - void describe_keyspace(KsDef& _return, const std::string& keyspace) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->describe_keyspace(_return, keyspace); - return; - } else { - ifaces_[i]->describe_keyspace(_return, keyspace); - } - } - } - - void describe_splits(std::vector & _return, const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->describe_splits(_return, cfName, start_token, end_token, keys_per_split); - return; - } else { - ifaces_[i]->describe_splits(_return, cfName, start_token, end_token, keys_per_split); - } - } - } - - void system_add_column_family(std::string& _return, const CfDef& cf_def) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->system_add_column_family(_return, cf_def); - return; - } else { - ifaces_[i]->system_add_column_family(_return, cf_def); - } - } - } - - void system_drop_column_family(std::string& _return, const std::string& column_family) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->system_drop_column_family(_return, column_family); - return; - } else { - ifaces_[i]->system_drop_column_family(_return, column_family); - } - } - } - - void system_add_keyspace(std::string& _return, const KsDef& ks_def) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->system_add_keyspace(_return, ks_def); - return; - } else { - ifaces_[i]->system_add_keyspace(_return, ks_def); - } - } - } - - void system_drop_keyspace(std::string& _return, const std::string& keyspace) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->system_drop_keyspace(_return, keyspace); - return; - } else { - ifaces_[i]->system_drop_keyspace(_return, keyspace); - } - } - } - - void system_update_keyspace(std::string& _return, const KsDef& ks_def) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->system_update_keyspace(_return, ks_def); - return; - } else { - ifaces_[i]->system_update_keyspace(_return, ks_def); - } - } - } - - void system_update_column_family(std::string& _return, const CfDef& cf_def) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->system_update_column_family(_return, cf_def); - return; - } else { - ifaces_[i]->system_update_column_family(_return, cf_def); - } - } - } - - void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression) { - uint32_t sz = ifaces_.size(); - for (uint32_t i = 0; i < sz; ++i) { - if (i == sz - 1) { - ifaces_[i]->execute_cql_query(_return, query, compression); - return; - } else { - ifaces_[i]->execute_cql_query(_return, query, compression); - } - } - } - -}; - -}}} // namespace +class Cassandra_execute_cql_query_presult +{ +public: + virtual ~Cassandra_execute_cql_query_presult() throw() + { + } + + CqlResult *success; + InvalidRequestException ire; + UnavailableException ue; + TimedOutException te; + SchemaDisagreementException sde; + + _Cassandra_execute_cql_query_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol *iprot); +}; + +class CassandraClient : virtual public CassandraIf +{ +public: + CassandraClient( + boost::shared_ptr<::apache::thrift::protocol::TProtocol> prot) + : piprot_(prot), poprot_(prot) + { + iprot_ = prot.get(); + oprot_ = prot.get(); + } + CassandraClient( + boost::shared_ptr<::apache::thrift::protocol::TProtocol> iprot, + boost::shared_ptr<::apache::thrift::protocol::TProtocol> oprot) + : piprot_(iprot), poprot_(oprot) + { + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + boost::shared_ptr<::apache::thrift::protocol::TProtocol> getInputProtocol() + { + return piprot_; + } + boost::shared_ptr<::apache::thrift::protocol::TProtocol> getOutputProtocol() + { + return poprot_; + } + void login(const AuthenticationRequest &auth_request); + void send_login(const AuthenticationRequest &auth_request); + void recv_login(); + void set_keyspace(const std::string &keyspace); + void send_set_keyspace(const std::string &keyspace); + void recv_set_keyspace(); + void get(ColumnOrSuperColumn &_return, const std::string &key, + const ColumnPath &column_path, + const ConsistencyLevel::type consistency_level); + void send_get(const std::string &key, const ColumnPath &column_path, + const ConsistencyLevel::type consistency_level); + void recv_get(ColumnOrSuperColumn &_return); + void get_slice(std::vector &_return, + const std::string &key, const ColumnParent &column_parent, + const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level); + void send_get_slice(const std::string &key, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level); + void recv_get_slice(std::vector &_return); + int32_t get_count(const std::string &key, const ColumnParent &column_parent, + const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level); + void send_get_count(const std::string &key, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level); + int32_t recv_get_count(); + void multiget_slice( + std::map> &_return, + const std::vector &keys, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level); + void send_multiget_slice(const std::vector &keys, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level); + void recv_multiget_slice( + std::map> &_return); + void multiget_count(std::map &_return, + const std::vector &keys, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level); + void send_multiget_count(const std::vector &keys, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level); + void recv_multiget_count(std::map &_return); + void get_range_slices(std::vector &_return, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const KeyRange &range, + const ConsistencyLevel::type consistency_level); + void send_get_range_slices(const ColumnParent &column_parent, + const SlicePredicate &predicate, const KeyRange &range, + const ConsistencyLevel::type consistency_level); + void recv_get_range_slices(std::vector &_return); + void get_indexed_slices(std::vector &_return, + const ColumnParent &column_parent, const IndexClause &index_clause, + const SlicePredicate &column_predicate, + const ConsistencyLevel::type consistency_level); + void send_get_indexed_slices(const ColumnParent &column_parent, + const IndexClause &index_clause, + const SlicePredicate &column_predicate, + const ConsistencyLevel::type consistency_level); + void recv_get_indexed_slices(std::vector &_return); + void insert(const std::string &key, const ColumnParent &column_parent, + const Column &column, + const ConsistencyLevel::type consistency_level); + void send_insert(const std::string &key, const ColumnParent &column_parent, + const Column &column, + const ConsistencyLevel::type consistency_level); + void recv_insert(); + void add(const std::string &key, const ColumnParent &column_parent, + const CounterColumn &column, + const ConsistencyLevel::type consistency_level); + void send_add(const std::string &key, const ColumnParent &column_parent, + const CounterColumn &column, + const ConsistencyLevel::type consistency_level); + void recv_add(); + void remove(const std::string &key, const ColumnPath &column_path, + const int64_t timestamp, + const ConsistencyLevel::type consistency_level); + void send_remove(const std::string &key, const ColumnPath &column_path, + const int64_t timestamp, + const ConsistencyLevel::type consistency_level); + void recv_remove(); + void remove_counter(const std::string &key, const ColumnPath &path, + const ConsistencyLevel::type consistency_level); + void send_remove_counter(const std::string &key, const ColumnPath &path, + const ConsistencyLevel::type consistency_level); + void recv_remove_counter(); + void batch_mutate( + const std::map>> &mutation_map, + const ConsistencyLevel::type consistency_level); + void send_batch_mutate( + const std::map>> &mutation_map, + const ConsistencyLevel::type consistency_level); + void recv_batch_mutate(); + void truncate(const std::string &cfname); + void send_truncate(const std::string &cfname); + void recv_truncate(); + void describe_schema_versions( + std::map> &_return); + void send_describe_schema_versions(); + void recv_describe_schema_versions( + std::map> &_return); + void describe_keyspaces(std::vector &_return); + void send_describe_keyspaces(); + void recv_describe_keyspaces(std::vector &_return); + void describe_cluster_name(std::string &_return); + void send_describe_cluster_name(); + void recv_describe_cluster_name(std::string &_return); + void describe_version(std::string &_return); + void send_describe_version(); + void recv_describe_version(std::string &_return); + void describe_ring( + std::vector &_return, const std::string &keyspace); + void send_describe_ring(const std::string &keyspace); + void recv_describe_ring(std::vector &_return); + void describe_partitioner(std::string &_return); + void send_describe_partitioner(); + void recv_describe_partitioner(std::string &_return); + void describe_snitch(std::string &_return); + void send_describe_snitch(); + void recv_describe_snitch(std::string &_return); + void describe_keyspace(KsDef &_return, const std::string &keyspace); + void send_describe_keyspace(const std::string &keyspace); + void recv_describe_keyspace(KsDef &_return); + void describe_splits(std::vector &_return, + const std::string &cfName, const std::string &start_token, + const std::string &end_token, const int32_t keys_per_split); + void send_describe_splits(const std::string &cfName, + const std::string &start_token, const std::string &end_token, + const int32_t keys_per_split); + void recv_describe_splits(std::vector &_return); + void system_add_column_family(std::string &_return, const CfDef &cf_def); + void send_system_add_column_family(const CfDef &cf_def); + void recv_system_add_column_family(std::string &_return); + void system_drop_column_family( + std::string &_return, const std::string &column_family); + void send_system_drop_column_family(const std::string &column_family); + void recv_system_drop_column_family(std::string &_return); + void system_add_keyspace(std::string &_return, const KsDef &ks_def); + void send_system_add_keyspace(const KsDef &ks_def); + void recv_system_add_keyspace(std::string &_return); + void system_drop_keyspace( + std::string &_return, const std::string &keyspace); + void send_system_drop_keyspace(const std::string &keyspace); + void recv_system_drop_keyspace(std::string &_return); + void system_update_keyspace(std::string &_return, const KsDef &ks_def); + void send_system_update_keyspace(const KsDef &ks_def); + void recv_system_update_keyspace(std::string &_return); + void system_update_column_family(std::string &_return, const CfDef &cf_def); + void send_system_update_column_family(const CfDef &cf_def); + void recv_system_update_column_family(std::string &_return); + void execute_cql_query(CqlResult &_return, const std::string &query, + const Compression::type compression); + void send_execute_cql_query( + const std::string &query, const Compression::type compression); + void recv_execute_cql_query(CqlResult &_return); + +protected: + boost::shared_ptr<::apache::thrift::protocol::TProtocol> piprot_; + boost::shared_ptr<::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol *iprot_; + ::apache::thrift::protocol::TProtocol *oprot_; +}; + +class CassandraProcessor : virtual public ::apache::thrift::TProcessor +{ +protected: + boost::shared_ptr iface_; + virtual bool process_fn(::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, std::string &fname, + int32_t seqid, void *callContext); + +private: + std::map + processMap_; + void process_login(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_set_keyspace(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_get(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_get_slice(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_get_count(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_multiget_slice(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_multiget_count(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_get_range_slices(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_get_indexed_slices(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_insert(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_add(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_remove(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_remove_counter(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_batch_mutate(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_truncate(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_describe_schema_versions(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_describe_keyspaces(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_describe_cluster_name(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_describe_version(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_describe_ring(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_describe_partitioner(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_describe_snitch(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_describe_keyspace(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_describe_splits(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_system_add_column_family(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_system_drop_column_family(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_system_add_keyspace(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_system_drop_keyspace(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_system_update_keyspace(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_system_update_column_family(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + void process_execute_cql_query(int32_t seqid, + ::apache::thrift::protocol::TProtocol *iprot, + ::apache::thrift::protocol::TProtocol *oprot, void *callContext); + +public: + CassandraProcessor(boost::shared_ptr iface) : iface_(iface) + { + processMap_["login"] = &CassandraProcessor::process_login; + processMap_["set_keyspace"] = &CassandraProcessor::process_set_keyspace; + processMap_["get"] = &CassandraProcessor::process_get; + processMap_["get_slice"] = &CassandraProcessor::process_get_slice; + processMap_["get_count"] = &CassandraProcessor::process_get_count; + processMap_["multiget_slice"] = + &CassandraProcessor::process_multiget_slice; + processMap_["multiget_count"] = + &CassandraProcessor::process_multiget_count; + processMap_["get_range_slices"] = + &CassandraProcessor::process_get_range_slices; + processMap_["get_indexed_slices"] = + &CassandraProcessor::process_get_indexed_slices; + processMap_["insert"] = &CassandraProcessor::process_insert; + processMap_["add"] = &CassandraProcessor::process_add; + processMap_["remove"] = &CassandraProcessor::process_remove; + processMap_["remove_counter"] = + &CassandraProcessor::process_remove_counter; + processMap_["batch_mutate"] = &CassandraProcessor::process_batch_mutate; + processMap_["truncate"] = &CassandraProcessor::process_truncate; + processMap_["describe_schema_versions"] = + &CassandraProcessor::process_describe_schema_versions; + processMap_["describe_keyspaces"] = + &CassandraProcessor::process_describe_keyspaces; + processMap_["describe_cluster_name"] = + &CassandraProcessor::process_describe_cluster_name; + processMap_["describe_version"] = + &CassandraProcessor::process_describe_version; + processMap_["describe_ring"] = + &CassandraProcessor::process_describe_ring; + processMap_["describe_partitioner"] = + &CassandraProcessor::process_describe_partitioner; + processMap_["describe_snitch"] = + &CassandraProcessor::process_describe_snitch; + processMap_["describe_keyspace"] = + &CassandraProcessor::process_describe_keyspace; + processMap_["describe_splits"] = + &CassandraProcessor::process_describe_splits; + processMap_["system_add_column_family"] = + &CassandraProcessor::process_system_add_column_family; + processMap_["system_drop_column_family"] = + &CassandraProcessor::process_system_drop_column_family; + processMap_["system_add_keyspace"] = + &CassandraProcessor::process_system_add_keyspace; + processMap_["system_drop_keyspace"] = + &CassandraProcessor::process_system_drop_keyspace; + processMap_["system_update_keyspace"] = + &CassandraProcessor::process_system_update_keyspace; + processMap_["system_update_column_family"] = + &CassandraProcessor::process_system_update_column_family; + processMap_["execute_cql_query"] = + &CassandraProcessor::process_execute_cql_query; + } + + virtual bool process( + boost::shared_ptr<::apache::thrift::protocol::TProtocol> piprot, + boost::shared_ptr<::apache::thrift::protocol::TProtocol> poprot, + void *callContext); + virtual ~CassandraProcessor() + { + } +}; + +class CassandraMultiface : virtual public CassandraIf +{ +public: + CassandraMultiface(std::vector> &ifaces) + : ifaces_(ifaces) + { + } + virtual ~CassandraMultiface() + { + } + +protected: + std::vector> ifaces_; + CassandraMultiface() + { + } + void add(boost::shared_ptr iface) + { + ifaces_.push_back(iface); + } + +public: + void login(const AuthenticationRequest &auth_request) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + ifaces_[i]->login(auth_request); + } + } + + void set_keyspace(const std::string &keyspace) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + ifaces_[i]->set_keyspace(keyspace); + } + } + + void get(ColumnOrSuperColumn &_return, const std::string &key, + const ColumnPath &column_path, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->get(_return, key, column_path, consistency_level); + return; + } else { + ifaces_[i]->get(_return, key, column_path, consistency_level); + } + } + } + + void get_slice(std::vector &_return, + const std::string &key, const ColumnParent &column_parent, + const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->get_slice(_return, key, column_parent, predicate, + consistency_level); + return; + } else { + ifaces_[i]->get_slice(_return, key, column_parent, predicate, + consistency_level); + } + } + } + + int32_t get_count(const std::string &key, const ColumnParent &column_parent, + const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + return ifaces_[i]->get_count( + key, column_parent, predicate, consistency_level); + } else { + ifaces_[i]->get_count( + key, column_parent, predicate, consistency_level); + } + } + } + + void multiget_slice( + std::map> &_return, + const std::vector &keys, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->multiget_slice(_return, keys, column_parent, + predicate, consistency_level); + return; + } else { + ifaces_[i]->multiget_slice(_return, keys, column_parent, + predicate, consistency_level); + } + } + } + + void multiget_count(std::map &_return, + const std::vector &keys, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->multiget_count(_return, keys, column_parent, + predicate, consistency_level); + return; + } else { + ifaces_[i]->multiget_count(_return, keys, column_parent, + predicate, consistency_level); + } + } + } + + void get_range_slices(std::vector &_return, + const ColumnParent &column_parent, const SlicePredicate &predicate, + const KeyRange &range, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->get_range_slices(_return, column_parent, predicate, + range, consistency_level); + return; + } else { + ifaces_[i]->get_range_slices(_return, column_parent, predicate, + range, consistency_level); + } + } + } + + void get_indexed_slices(std::vector &_return, + const ColumnParent &column_parent, const IndexClause &index_clause, + const SlicePredicate &column_predicate, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->get_indexed_slices(_return, column_parent, + index_clause, column_predicate, consistency_level); + return; + } else { + ifaces_[i]->get_indexed_slices(_return, column_parent, + index_clause, column_predicate, consistency_level); + } + } + } + + void insert(const std::string &key, const ColumnParent &column_parent, + const Column &column, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + ifaces_[i]->insert(key, column_parent, column, consistency_level); + } + } + + void add(const std::string &key, const ColumnParent &column_parent, + const CounterColumn &column, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + ifaces_[i]->add(key, column_parent, column, consistency_level); + } + } + + void remove(const std::string &key, const ColumnPath &column_path, + const int64_t timestamp, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + ifaces_[i]->remove(key, column_path, timestamp, consistency_level); + } + } + + void remove_counter(const std::string &key, const ColumnPath &path, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + ifaces_[i]->remove_counter(key, path, consistency_level); + } + } + + void batch_mutate( + const std::map>> &mutation_map, + const ConsistencyLevel::type consistency_level) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + ifaces_[i]->batch_mutate(mutation_map, consistency_level); + } + } + + void truncate(const std::string &cfname) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + ifaces_[i]->truncate(cfname); + } + } + + void describe_schema_versions( + std::map> &_return) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->describe_schema_versions(_return); + return; + } else { + ifaces_[i]->describe_schema_versions(_return); + } + } + } + + void describe_keyspaces(std::vector &_return) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->describe_keyspaces(_return); + return; + } else { + ifaces_[i]->describe_keyspaces(_return); + } + } + } + + void describe_cluster_name(std::string &_return) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->describe_cluster_name(_return); + return; + } else { + ifaces_[i]->describe_cluster_name(_return); + } + } + } + + void describe_version(std::string &_return) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->describe_version(_return); + return; + } else { + ifaces_[i]->describe_version(_return); + } + } + } + + void describe_ring( + std::vector &_return, const std::string &keyspace) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->describe_ring(_return, keyspace); + return; + } else { + ifaces_[i]->describe_ring(_return, keyspace); + } + } + } + + void describe_partitioner(std::string &_return) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->describe_partitioner(_return); + return; + } else { + ifaces_[i]->describe_partitioner(_return); + } + } + } + + void describe_snitch(std::string &_return) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->describe_snitch(_return); + return; + } else { + ifaces_[i]->describe_snitch(_return); + } + } + } + + void describe_keyspace(KsDef &_return, const std::string &keyspace) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->describe_keyspace(_return, keyspace); + return; + } else { + ifaces_[i]->describe_keyspace(_return, keyspace); + } + } + } + + void describe_splits(std::vector &_return, + const std::string &cfName, const std::string &start_token, + const std::string &end_token, const int32_t keys_per_split) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->describe_splits(_return, cfName, start_token, + end_token, keys_per_split); + return; + } else { + ifaces_[i]->describe_splits(_return, cfName, start_token, + end_token, keys_per_split); + } + } + } + + void system_add_column_family(std::string &_return, const CfDef &cf_def) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->system_add_column_family(_return, cf_def); + return; + } else { + ifaces_[i]->system_add_column_family(_return, cf_def); + } + } + } + + void system_drop_column_family( + std::string &_return, const std::string &column_family) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->system_drop_column_family(_return, column_family); + return; + } else { + ifaces_[i]->system_drop_column_family(_return, column_family); + } + } + } + + void system_add_keyspace(std::string &_return, const KsDef &ks_def) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->system_add_keyspace(_return, ks_def); + return; + } else { + ifaces_[i]->system_add_keyspace(_return, ks_def); + } + } + } + + void system_drop_keyspace(std::string &_return, const std::string &keyspace) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->system_drop_keyspace(_return, keyspace); + return; + } else { + ifaces_[i]->system_drop_keyspace(_return, keyspace); + } + } + } + + void system_update_keyspace(std::string &_return, const KsDef &ks_def) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->system_update_keyspace(_return, ks_def); + return; + } else { + ifaces_[i]->system_update_keyspace(_return, ks_def); + } + } + } + + void system_update_column_family(std::string &_return, const CfDef &cf_def) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->system_update_column_family(_return, cf_def); + return; + } else { + ifaces_[i]->system_update_column_family(_return, cf_def); + } + } + } + + void execute_cql_query(CqlResult &_return, const std::string &query, + const Compression::type compression) + { + uint32_t sz = ifaces_.size(); + for(uint32_t i = 0; i < sz; ++i) { + if(i == sz - 1) { + ifaces_[i]->execute_cql_query(_return, query, compression); + return; + } else { + ifaces_[i]->execute_cql_query(_return, query, compression); + } + } + } +}; + +} // namespace cassandra +} // namespace apache +} // namespace org #endif diff --git a/src/modules/db_cassandra/cassandra_constants.h b/src/modules/db_cassandra/cassandra_constants.h index 97c762245e6..febdb048afd 100644 --- a/src/modules/db_cassandra/cassandra_constants.h +++ b/src/modules/db_cassandra/cassandra_constants.h @@ -8,17 +8,22 @@ #include "cassandra_types.h" -namespace org { namespace apache { namespace cassandra { +namespace org { +namespace apache { +namespace cassandra { -class cassandraConstants { - public: - cassandraConstants(); +class cassandraConstants +{ +public: + cassandraConstants(); - std::string CASS_VERSION; + std::string CASS_VERSION; }; extern const cassandraConstants g_cassandra_constants; -}}} // namespace +} // namespace cassandra +} // namespace apache +} // namespace org #endif diff --git a/src/modules/db_cassandra/cassandra_types.h b/src/modules/db_cassandra/cassandra_types.h index 1f56ae3e4c8..94d6ed714de 100644 --- a/src/modules/db_cassandra/cassandra_types.h +++ b/src/modules/db_cassandra/cassandra_types.h @@ -12,1509 +12,1790 @@ #include - -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 - }; +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 _ConsistencyLevel_VALUES_TO_NAMES; - -struct IndexOperator { - enum type { - EQ = 0, - GTE = 1, - GT = 2, - LTE = 3, - LT = 4 - }; +extern const std::map _ConsistencyLevel_VALUES_TO_NAMES; + +struct IndexOperator +{ + enum type + { + EQ = 0, + GTE = 1, + GT = 2, + LTE = 3, + LT = 4 + }; }; -extern const std::map _IndexOperator_VALUES_TO_NAMES; +extern const std::map _IndexOperator_VALUES_TO_NAMES; -struct IndexType { - enum type { - KEYS = 0, - CUSTOM = 1 - }; +struct IndexType +{ + enum type + { + KEYS = 0, + CUSTOM = 1 + }; }; -extern const std::map _IndexType_VALUES_TO_NAMES; +extern const std::map _IndexType_VALUES_TO_NAMES; -struct Compression { - enum type { - GZIP = 1, - NONE = 2 - }; +struct Compression +{ + enum type + { + GZIP = 1, + NONE = 2 + }; }; -extern const std::map _Compression_VALUES_TO_NAMES; +extern const std::map _Compression_VALUES_TO_NAMES; -struct CqlResultType { - enum type { - ROWS = 1, - VOID = 2, - INT = 3 - }; +struct CqlResultType +{ + enum type + { + ROWS = 1, + VOID = 2, + INT = 3 + }; }; -extern const std::map _CqlResultType_VALUES_TO_NAMES; +extern const std::map _CqlResultType_VALUES_TO_NAMES; -typedef struct _Column__isset { - _Column__isset() : value(false), timestamp(false), ttl(false) {} - bool value; - bool timestamp; - bool ttl; +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 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 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 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 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 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 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; - +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 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; +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 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() { - } +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}; - virtual ~NotFoundException() throw() {} + 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; + bool operator==(const NotFoundException & /* rhs */) const + { + return true; + } + bool operator!=(const NotFoundException &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + 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: +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}; - 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("") + { + } - InvalidRequestException() : why("") { - } + virtual ~InvalidRequestException() throw() + { + } - virtual ~InvalidRequestException() throw() {} + std::string why; - 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 & 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; + 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}; +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() { - } + UnavailableException() + { + } - virtual ~UnavailableException() throw() {} + virtual ~UnavailableException() throw() + { + } - bool operator == (const UnavailableException & /* rhs */) const - { - return true; - } - bool operator != (const UnavailableException &rhs) const { - return !(*this == rhs); - } + 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; + 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}; +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() { - } + TimedOutException() + { + } - virtual ~TimedOutException() throw() {} + virtual ~TimedOutException() throw() + { + } - bool operator == (const TimedOutException & /* rhs */) const - { - return true; - } - bool operator != (const TimedOutException &rhs) const { - return !(*this == rhs); - } + 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; + 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("") { - } +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}; - virtual ~AuthenticationException() throw() {} + AuthenticationException() : why("") + { + } - std::string why; + virtual ~AuthenticationException() throw() + { + } - bool operator == (const AuthenticationException & rhs) const - { - if (!(why == rhs.why)) - return false; - return true; - } - bool operator != (const AuthenticationException &rhs) const { - return !(*this == rhs); - } + std::string why; - bool operator < (const AuthenticationException & ) const; + bool operator==(const AuthenticationException &rhs) const + { + if(!(why == rhs.why)) + return false; + return true; + } + bool operator!=(const AuthenticationException &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + 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("") { - } +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}; - virtual ~AuthorizationException() throw() {} + AuthorizationException() : why("") + { + } - std::string why; + virtual ~AuthorizationException() throw() + { + } - bool operator == (const AuthorizationException & rhs) const - { - if (!(why == rhs.why)) - return false; - return true; - } - bool operator != (const AuthorizationException &rhs) const { - return !(*this == rhs); - } + std::string why; - bool operator < (const AuthorizationException & ) const; + bool operator==(const AuthorizationException &rhs) const + { + if(!(why == rhs.why)) + return false; + return true; + } + bool operator!=(const AuthorizationException &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + 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: +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}; - 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() + { + } - SchemaDisagreementException() { - } + virtual ~SchemaDisagreementException() throw() + { + } - virtual ~SchemaDisagreementException() throw() {} + bool operator==(const SchemaDisagreementException & /* rhs */) const + { + return true; + } + bool operator!=(const SchemaDisagreementException &rhs) const + { + return !(*this == rhs); + } - 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; + 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; +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; - +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; +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 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; - +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; +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 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 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 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 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 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; - +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 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; +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 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 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 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 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; - +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; +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; - +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; +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; - +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; +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; - +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; +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 endpoints; - std::vector rpc_endpoints; - std::vector 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 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 endpoints; + std::vector rpc_endpoints; + std::vector 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() { - } +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}; - virtual ~AuthenticationRequest() throw() {} + AuthenticationRequest() + { + } - std::map credentials; + virtual ~AuthenticationRequest() throw() + { + } - bool operator == (const AuthenticationRequest & rhs) const - { - if (!(credentials == rhs.credentials)) - return false; - return true; - } - bool operator != (const AuthenticationRequest &rhs) const { - return !(*this == rhs); - } + std::map credentials; - bool operator < (const AuthenticationRequest & ) const; + bool operator==(const AuthenticationRequest &rhs) const + { + if(!(credentials == rhs.credentials)) + return false; + return true; + } + bool operator!=(const AuthenticationRequest &rhs) const + { + return !(*this == rhs); + } - uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + 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; +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 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; - +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 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; +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 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 compaction_strategy_options; - int32_t row_cache_keys_to_save; - std::map 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; - +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 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 compaction_strategy_options; + int32_t row_cache_keys_to_save; + std::map 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; +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 strategy_options; - int32_t replication_factor; - std::vector 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 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 strategy_options; + int32_t replication_factor; + std::vector 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 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 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 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 name_types; - std::map 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; - +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 name_types; + std::map 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; +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 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; - +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 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 +} // namespace cassandra +} // namespace apache +} // namespace org #endif diff --git a/src/modules/db_cassandra/db_cassandra.c b/src/modules/db_cassandra/db_cassandra.c index 0e557e96620..b1cf65f5068 100644 --- a/src/modules/db_cassandra/db_cassandra.c +++ b/src/modules/db_cassandra/db_cassandra.c @@ -36,16 +36,16 @@ #include "dbcassa_base.h" #include "dbcassa_table.h" -unsigned int cassa_conn_timeout= 1000; -unsigned int cassa_send_timeout= 2000; -unsigned int cassa_recv_timeout= 4000; -unsigned int cassa_retries= 1; +unsigned int cassa_conn_timeout = 1000; +unsigned int cassa_send_timeout = 2000; +unsigned int cassa_recv_timeout = 4000; +unsigned int cassa_retries = 1; unsigned int cassa_auto_reconnect = 1; static int cassa_mod_init(void); static void mod_destroy(void); int db_cassa_bind_api(db_func_t *dbb); -str dbcassa_schema_path={0, 0}; +str dbcassa_schema_path = {0, 0}; MODULE_VERSION @@ -53,40 +53,38 @@ MODULE_VERSION * database module interface */ static cmd_export_t cmds[] = { - {"db_bind_api", (cmd_function)db_cassa_bind_api, 0, 0, 0, 0}, - {0, 0, 0, 0, 0, 0} -}; + {"db_bind_api", (cmd_function)db_cassa_bind_api, 0, 0, 0, 0}, + {0, 0, 0, 0, 0, 0}}; static param_export_t params[] = { - {"schema_path", PARAM_STR, &dbcassa_schema_path.s}, - {"connect_timeout", PARAM_INT, &cassa_conn_timeout}, - {"send_timeout", PARAM_INT, &cassa_send_timeout}, - {"receive_timeout", PARAM_INT, &cassa_recv_timeout}, - {"retries", PARAM_INT, &cassa_retries}, - {"auto_reconnect", INT_PARAM, &cassa_auto_reconnect}, - {0, 0, 0} -}; + {"schema_path", PARAM_STR, &dbcassa_schema_path.s}, + {"connect_timeout", PARAM_INT, &cassa_conn_timeout}, + {"send_timeout", PARAM_INT, &cassa_send_timeout}, + {"receive_timeout", PARAM_INT, &cassa_recv_timeout}, + {"retries", PARAM_INT, &cassa_retries}, + {"auto_reconnect", INT_PARAM, &cassa_auto_reconnect}, {0, 0, 0}}; struct module_exports exports = { - "db_cassandra", /* module name */ - DEFAULT_DLFLAGS, /* dlopen flags */ - cmds, /* exported functions */ - params, /* exported parameters */ - 0, /* RPC method exports */ - 0, /* exported pseudo-variables */ - 0, /* response handling function */ - cassa_mod_init, /* module initialization function */ - 0, /* per-child init function */ - mod_destroy /* module destroy function */ + "db_cassandra", /* module name */ + DEFAULT_DLFLAGS, /* dlopen flags */ + cmds, /* exported functions */ + params, /* exported parameters */ + 0, /* RPC method exports */ + 0, /* exported pseudo-variables */ + 0, /* response handling function */ + cassa_mod_init, /* module initialization function */ + 0, /* per-child init function */ + mod_destroy /* module destroy function */ }; static int cassa_mod_init(void) { if(!dbcassa_schema_path.s) { LM_ERR("Set the schema_path parameter to the path of the directory" - " where the table schemas are found (they must be described in cassa special format)\n"); + " where the table schemas are found (they must be described in " + "cassa special format)\n"); return -1; } dbcassa_schema_path.len = strlen(dbcassa_schema_path.s); @@ -94,9 +92,9 @@ static int cassa_mod_init(void) return dbcassa_read_table_schemas(); } -db1_con_t *db_cassa_init(const str* _url) +db1_con_t *db_cassa_init(const str *_url) { - return db_do_init(_url, (void* (*)()) db_cassa_new_connection); + return db_do_init(_url, (void *(*)())db_cassa_new_connection); } @@ -105,40 +103,39 @@ db1_con_t *db_cassa_init(const str* _url) * \param _h closed connection, as returned from db_cassa_init * \note free all memory and resources */ -void db_cassa_close(db1_con_t* _h) +void db_cassa_close(db1_con_t *_h) { - db_do_close(_h, (void (*)()) db_cassa_free_connection); + db_do_close(_h, (void (*)())db_cassa_free_connection); } /* * Store name of table that will be used by * subsequent database functions */ -int db_cassa_use_table(db1_con_t* _h, const str* _t) +int db_cassa_use_table(db1_con_t *_h, const str *_t) { return db_use_table(_h, _t); } - int db_cassa_bind_api(db_func_t *dbb) { - if(dbb==NULL) + if(dbb == NULL) return -1; memset(dbb, 0, sizeof(db_func_t)); - dbb->use_table = db_cassa_use_table; - dbb->init = db_cassa_init; - dbb->close = db_cassa_close; - dbb->query = db_cassa_query; - dbb->free_result = db_cassa_free_result; - dbb->insert = db_cassa_insert; - dbb->replace = db_cassa_replace; - dbb->insert_update = db_cassa_insert; - dbb->delete = db_cassa_delete; - dbb->update = db_cassa_update; - dbb->raw_query = db_cassa_raw_query; + dbb->use_table = db_cassa_use_table; + dbb->init = db_cassa_init; + dbb->close = db_cassa_close; + dbb->query = db_cassa_query; + dbb->free_result = db_cassa_free_result; + dbb->insert = db_cassa_insert; + dbb->replace = db_cassa_replace; + dbb->insert_update = db_cassa_insert; + dbb->delete = db_cassa_delete; + dbb->update = db_cassa_update; + dbb->raw_query = db_cassa_raw_query; return 0; } diff --git a/src/modules/db_cassandra/dbcassa_base.h b/src/modules/db_cassandra/dbcassa_base.h index 48077ee81ed..9b95095daa2 100644 --- a/src/modules/db_cassandra/dbcassa_base.h +++ b/src/modules/db_cassandra/dbcassa_base.h @@ -31,7 +31,8 @@ #ifdef __cplusplus -extern "C" { +extern "C" +{ #endif @@ -40,60 +41,60 @@ extern "C" { #include "../../lib/srdb1/db_res.h" #include "../../lib/srdb1/db_op.h" -extern unsigned int cassa_auto_reconnect; -extern unsigned int cassa_retries; -extern unsigned int cassa_conn_timeout; -extern unsigned int cassa_send_timeout; -extern unsigned int cassa_recv_timeout; + extern unsigned int cassa_auto_reconnect; + extern unsigned int cassa_retries; + extern unsigned int cassa_conn_timeout; + extern unsigned int cassa_send_timeout; + extern unsigned int cassa_recv_timeout; -/* + /* * Open connection */ -void* db_cassa_new_connection(struct db_id* id); + void *db_cassa_new_connection(struct db_id *id); -/* + /* * Free connection */ -void db_cassa_free_connection(struct pool_con* con); + void db_cassa_free_connection(struct pool_con *con); -/* + /* * Do a query */ -int db_cassa_query(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _op, - const db_val_t* _v, const db_key_t* _c, int _n, int _nc, - const db_key_t _o, db1_res_t** _r); + int db_cassa_query(const db1_con_t *_h, const db_key_t *_k, + const db_op_t *_op, const db_val_t *_v, const db_key_t *_c, int _n, + int _nc, const db_key_t _o, db1_res_t **_r); -/* + /* * Insert a row into table */ -int db_cassa_insert(const db1_con_t* _h, const db_key_t* _k, const db_val_t* _v, - int _n); + int db_cassa_insert(const db1_con_t *_h, const db_key_t *_k, + const db_val_t *_v, int _n); -/* + /* * Replace a row into table - same as insert for cassandra */ -int db_cassa_replace(const db1_con_t* _h, const db_key_t* _k, const db_val_t* _v, - int _n, const int _un, const int _m); + int db_cassa_replace(const db1_con_t *_h, const db_key_t *_k, + const db_val_t *_v, int _n, const int _un, const int _m); -/* + /* * Delete a row from table */ -int db_cassa_delete(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _o, - const db_val_t* _v, int _n); + int db_cassa_delete(const db1_con_t *_h, const db_key_t *_k, + const db_op_t *_o, const db_val_t *_v, int _n); -/* + /* * Update a row in table */ -int db_cassa_update(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _o, - const db_val_t* _v, const db_key_t* _uk, const db_val_t* _uv, - int _n, int _un); + int db_cassa_update(const db1_con_t *_h, const db_key_t *_k, + const db_op_t *_o, const db_val_t *_v, const db_key_t *_uk, + const db_val_t *_uv, int _n, int _un); -int db_cassa_free_result(db1_con_t* _h, db1_res_t* _r); + int db_cassa_free_result(db1_con_t *_h, db1_res_t *_r); -int db_cassa_raw_query(const db1_con_t* _h, const str* _s, db1_res_t** _r); + int db_cassa_raw_query(const db1_con_t *_h, const str *_s, db1_res_t **_r); #ifdef __cplusplus } diff --git a/src/modules/db_cassandra/dbcassa_table.c b/src/modules/db_cassandra/dbcassa_table.c index 0585414ec1f..2574db278b5 100644 --- a/src/modules/db_cassandra/dbcassa_table.c +++ b/src/modules/db_cassandra/dbcassa_table.c @@ -42,7 +42,8 @@ #define DBCASSA_TABLE_SIZE 16 -typedef struct rw_lock { +typedef struct rw_lock +{ gen_lock_t lock; int reload_flag; int data_refcnt; @@ -68,10 +69,8 @@ int dbcassa_check_mtime(time_t *mt) { struct stat s; - if(stat(full_path_buf, &s) == 0) - { - if((int)s.st_mtime > (int)*mt) - { + if(stat(full_path_buf, &s) == 0) { + if((int)s.st_mtime > (int)*mt) { *mt = s.st_mtime; LM_DBG("[%s] was updated\n", full_path_buf); return 1; @@ -99,7 +98,7 @@ dbcassa_table_p dbcassa_table_new(const str *_tbname, const str *_dbname) return 0; } - size = sizeof(dbcassa_table_t)+_tbname->len+_dbname->len; + size = sizeof(dbcassa_table_t) + _tbname->len + _dbname->len; dtp = (dbcassa_table_p)shm_malloc(size); if(!dtp) { LM_ERR("No more shared memory\n"); @@ -108,12 +107,12 @@ dbcassa_table_p dbcassa_table_new(const str *_tbname, const str *_dbname) memset(dtp, 0, size); size = sizeof(dbcassa_table_t); - dtp->name.s = (char*)dtp + size; + dtp->name.s = (char *)dtp + size; memcpy(dtp->name.s, _tbname->s, _tbname->len); dtp->name.len = _tbname->len; - size+= _tbname->len; + size += _tbname->len; - dtp->dbname.s = (char*)dtp + size; + dtp->dbname.s = (char *)dtp + size; memcpy(dtp->dbname.s, _dbname->s, _dbname->len); dtp->dbname.len = _dbname->len; @@ -130,14 +129,14 @@ dbcassa_column_p dbcassa_column_new(char *_s, int _l) dbcassa_column_p dcp; int size; - size = sizeof(dbcassa_column_t) + _l+ 1; + size = sizeof(dbcassa_column_t) + _l + 1; dcp = (dbcassa_column_p)shm_malloc(size); if(!dcp) { LM_ERR("No more shared memory\n"); return 0; } memset(dcp, 0, size); - dcp->name.s = (char*)dcp + sizeof(dbcassa_column_t); + dcp->name.s = (char *)dcp + sizeof(dbcassa_column_t); memcpy(dcp->name.s, _s, _l); dcp->name.len = _l; dcp->name.s[_l] = '\0'; @@ -156,15 +155,15 @@ int dbcassa_column_free(dbcassa_column_p dcp) int dbcassa_table_free(dbcassa_table_p _dtp) { dbcassa_column_p _cp, _cp0; - + if(!_dtp) return -1; /* cols*/ _cp = _dtp->cols; while(_cp) { - _cp0=_cp; - _cp=_cp->next; + _cp0 = _cp; + _cp = _cp->next; dbcassa_column_free(_cp0); } /* key */ @@ -181,21 +180,26 @@ int dbcassa_table_free(dbcassa_table_p _dtp) /** * Load the table schema from file */ -dbcassa_table_p dbcassa_load_file(str* dbn, str* tbn) +dbcassa_table_p dbcassa_load_file(str *dbn, str *tbn) { #define KEY_MAX_LEN 10 - FILE *fin=NULL; + FILE *fin = NULL; char buf[4096]; int c, ccol, bp; dbcassa_table_p dtp = 0; - dbcassa_column_p colp= 0; + dbcassa_column_p colp = 0; dbcassa_column_p key[KEY_MAX_LEN]; dbcassa_column_p sec_key[KEY_MAX_LEN]; - enum {DBCASSA_FLINE_ST, DBCASSA_NLINE_ST, DBCASSA_NLINE2_ST} state; + enum + { + DBCASSA_FLINE_ST, + DBCASSA_NLINE_ST, + DBCASSA_NLINE2_ST + } state; - memset(key, 0, KEY_MAX_LEN*sizeof(dbcassa_column_p)); - memset(sec_key, 0, KEY_MAX_LEN*sizeof(dbcassa_column_p)); + memset(key, 0, KEY_MAX_LEN * sizeof(dbcassa_column_p)); + memset(sec_key, 0, KEY_MAX_LEN * sizeof(dbcassa_column_p)); LM_DBG("loading file [%s]\n", full_path_buf); fin = fopen(full_path_buf, "rt"); @@ -210,24 +214,25 @@ dbcassa_table_p dbcassa_load_file(str* dbn, str* tbn) state = DBCASSA_FLINE_ST; c = fgetc(fin); - while(c!=EOF) { + while(c != EOF) { switch(state) { case DBCASSA_FLINE_ST: bp = 0; - while(c==DBCASSA_DELIM_C) + while(c == DBCASSA_DELIM_C) c = fgetc(fin); - if(c==DBCASSA_DELIM_R && !dtp->cols) + if(c == DBCASSA_DELIM_R && !dtp->cols) goto clean; - if(c==DBCASSA_DELIM_R) { + if(c == DBCASSA_DELIM_R) { if(dtp->nrcols <= 0) goto clean; - + state = DBCASSA_NLINE_ST; c = fgetc(fin); break; } - while(c!=DBCASSA_DELIM_C && c!='(' && c!=DBCASSA_DELIM_R) { - if(c==EOF) + while(c != DBCASSA_DELIM_C && c != '(' + && c != DBCASSA_DELIM_R) { + if(c == EOF) goto clean; buf[bp++] = c; c = fgetc(fin); @@ -236,49 +241,52 @@ dbcassa_table_p dbcassa_load_file(str* dbn, str* tbn) if(!colp) goto clean; LM_DBG("new col [%.*s]\n", bp, buf); - while(c==DBCASSA_DELIM_C) + while(c == DBCASSA_DELIM_C) c = fgetc(fin); - if(c!='(') + if(c != '(') goto clean; c = fgetc(fin); - while(c==DBCASSA_DELIM_C) + while(c == DBCASSA_DELIM_C) c = fgetc(fin); switch(c) { case 's': case 'S': colp->type = DB1_STR; - LM_DBG("column[%d] is STR!\n", ccol+1); - break; + LM_DBG("column[%d] is STR!\n", ccol + 1); + break; case 'i': case 'I': colp->type = DB1_INT; - LM_DBG("column[%d] is INT!\n", ccol+1); - break; + LM_DBG("column[%d] is INT!\n", ccol + 1); + break; case 'd': case 'D': colp->type = DB1_DOUBLE; - LM_DBG("column[%d] is DOUBLE!\n", ccol+1); - break; + LM_DBG("column[%d] is DOUBLE!\n", ccol + 1); + break; case 't': case 'T': colp->type = DB1_DATETIME; - LM_DBG("column[%d] is TIME! Timestamp col has name [%s]\n", ccol+1, colp->name.s); + LM_DBG("column[%d] is TIME! Timestamp col has name " + "[%s]\n", + ccol + 1, colp->name.s); if(dtp->ts_col) { - LM_ERR("You can have only one column with type timestamp\n"); + LM_ERR("You can have only one column with type " + "timestamp\n"); goto clean; } dtp->ts_col = colp; - break; + break; default: LM_DBG("wrong column type!\n"); goto clean; } - while(c!='\n' && c!=EOF && c!=')' && c!= ',') { - if(colp->type == DB1_STR && (c=='i'|| c=='I')) { + while(c != '\n' && c != EOF && c != ')' && c != ',') { + if(colp->type == DB1_STR && (c == 'i' || c == 'I')) { colp->type = DB1_STRING; - LM_DBG("column[%d] is actually STRING!\n", ccol+1); + LM_DBG("column[%d] is actually STRING!\n", ccol + 1); } c = fgetc(fin); } @@ -289,16 +297,15 @@ dbcassa_table_p dbcassa_load_file(str* dbn, str* tbn) dtp->cols = colp; dtp->nrcols++; c = fgetc(fin); - } - else + } else goto clean; ccol++; - break; + break; case DBCASSA_NLINE_ST: case DBCASSA_NLINE2_ST: // unique key - while(c==DBCASSA_DELIM_C) + while(c == DBCASSA_DELIM_C) c = fgetc(fin); if(c == DBCASSA_DELIM_R) { state = DBCASSA_NLINE2_ST; @@ -308,17 +315,17 @@ dbcassa_table_p dbcassa_load_file(str* dbn, str* tbn) if(c == EOF) break; - bp= 0; - while(c!=DBCASSA_DELIM_C && c!=DBCASSA_DELIM_R) - { - if(c==EOF) + bp = 0; + while(c != DBCASSA_DELIM_C && c != DBCASSA_DELIM_R) { + if(c == EOF) break; buf[bp++] = c; c = fgetc(fin); } colp = dtp->cols; while(colp) { - if(bp==colp->name.len && strncmp(colp->name.s, buf, bp)==0) { + if(bp == colp->name.len + && strncmp(colp->name.s, buf, bp) == 0) { if(state == DBCASSA_NLINE_ST) key[dtp->key_len++] = colp; else @@ -337,27 +344,29 @@ dbcassa_table_p dbcassa_load_file(str* dbn, str* tbn) /* copy the keys into the table */ if(dtp->key_len) { - dtp->key = (dbcassa_column_p*) - shm_malloc(dtp->key_len*sizeof(dbcassa_column_p)); + dtp->key = (dbcassa_column_p *)shm_malloc( + dtp->key_len * sizeof(dbcassa_column_p)); if(!dtp->key) { LM_ERR("No more share memory\n"); goto clean; } - for(ccol = 0; ccol< dtp->key_len; ccol++) { + for(ccol = 0; ccol < dtp->key_len; ccol++) { dtp->key[ccol] = key[ccol]; - LM_DBG("col [%.*s] in primary key\n", key[ccol]->name.len, key[ccol]->name.s); + LM_DBG("col [%.*s] in primary key\n", key[ccol]->name.len, + key[ccol]->name.s); } } if(dtp->seckey_len) { - dtp->sec_key = (dbcassa_column_p*) - shm_malloc(dtp->seckey_len*sizeof(dbcassa_column_p)); + dtp->sec_key = (dbcassa_column_p *)shm_malloc( + dtp->seckey_len * sizeof(dbcassa_column_p)); if(!dtp->sec_key) { LM_ERR("No more share memory\n"); goto clean; } - for(ccol = 0; ccol< dtp->seckey_len; ccol++) { + for(ccol = 0; ccol < dtp->seckey_len; ccol++) { dtp->sec_key[ccol] = sec_key[ccol]; - LM_DBG("col [%.*s] in secondary key\n", sec_key[ccol]->name.len, sec_key[ccol]->name.s); + LM_DBG("col [%.*s] in secondary key\n", sec_key[ccol]->name.len, + sec_key[ccol]->name.s); } } @@ -374,57 +383,57 @@ dbcassa_table_p dbcassa_load_file(str* dbn, str* tbn) } -#define ref_read_data(rw_lock) \ -do {\ - again:\ - lock_get( &rw_lock.lock ); \ - if (rw_lock.reload_flag) { \ - lock_release( &rw_lock.lock ); \ - usleep(5); \ - goto again; \ - } \ - rw_lock.data_refcnt++; \ - lock_release( &rw_lock.lock ); \ -} while(0) +#define ref_read_data(rw_lock) \ + do { \ + again: \ + lock_get(&rw_lock.lock); \ + if(rw_lock.reload_flag) { \ + lock_release(&rw_lock.lock); \ + usleep(5); \ + goto again; \ + } \ + rw_lock.data_refcnt++; \ + lock_release(&rw_lock.lock); \ + } while(0) -#define unref_read_data(rw_lock) \ -do {\ - lock_get( &rw_lock.lock ); \ - rw_lock.data_refcnt--; \ - lock_release( &rw_lock.lock ); \ -} while(0) +#define unref_read_data(rw_lock) \ + do { \ + lock_get(&rw_lock.lock); \ + rw_lock.data_refcnt--; \ + lock_release(&rw_lock.lock); \ + } while(0) -#define ref_write_data(rw_lock)\ -do {\ - lock_get( &rw_lock.lock ); \ - rw_lock.reload_flag = 1; \ - lock_release( &rw_lock.lock ); \ - while (rw_lock.data_refcnt) \ - usleep(10); \ -} while(0) +#define ref_write_data(rw_lock) \ + do { \ + lock_get(&rw_lock.lock); \ + rw_lock.reload_flag = 1; \ + lock_release(&rw_lock.lock); \ + while(rw_lock.data_refcnt) \ + usleep(10); \ + } while(0) -#define unref_write_data(rw_lock)\ - rw_lock.reload_flag = 0; +#define unref_write_data(rw_lock) rw_lock.reload_flag = 0; /* * Search the table schema * */ -dbcassa_table_p dbcassa_db_search_table(int hashidx, int hash, - const str* dbn, const str *tbn) +dbcassa_table_p dbcassa_db_search_table( + int hashidx, int hash, const str *dbn, const str *tbn) { dbcassa_table_p tbc = NULL; ref_read_data(dbcassa_tbl_htable[hashidx].lock); tbc = dbcassa_tbl_htable[hashidx].dtp; while(tbc) { - LM_DBG("found dbname=%.*s, table=%.*s\n", tbc->dbname.len, tbc->dbname.s, tbc->name.len, tbc->name.s); - if(tbc->hash==hash && tbc->dbname.len == dbn->len - && tbc->name.len == tbn->len - && !strncasecmp(tbc->dbname.s, dbn->s, dbn->len) - && !strncasecmp(tbc->name.s, tbn->s, tbn->len)) + LM_DBG("found dbname=%.*s, table=%.*s\n", tbc->dbname.len, + tbc->dbname.s, tbc->name.len, tbc->name.s); + if(tbc->hash == hash && tbc->dbname.len == dbn->len + && tbc->name.len == tbn->len + && !strncasecmp(tbc->dbname.s, dbn->s, dbn->len) + && !strncasecmp(tbc->name.s, tbn->s, tbn->len)) return tbc; tbc = tbc->next; } @@ -436,14 +445,14 @@ dbcassa_table_p dbcassa_db_search_table(int hashidx, int hash, /** * Get the table schema. If the file was updated, update the table schema. */ -dbcassa_table_p dbcassa_db_get_table(const str* dbn, const str *tbn) +dbcassa_table_p dbcassa_db_get_table(const str *dbn, const str *tbn) { - dbcassa_table_p tbc = NULL, old_tbc= NULL, new_tbc= NULL, prev_tbc= NULL; + dbcassa_table_p tbc = NULL, old_tbc = NULL, new_tbc = NULL, prev_tbc = NULL; int hash; int hashidx; int len; - if(!dbn || !tbn ) { + if(!dbn || !tbn) { LM_ERR("invalid parameter"); return NULL; } @@ -456,8 +465,9 @@ dbcassa_table_p dbcassa_db_get_table(const str* dbn, const str *tbn) tbc = dbcassa_tbl_htable[hashidx].dtp; while(tbc) { - LM_DBG("found dbname=%.*s, table=%.*s\n", tbc->dbname.len, tbc->dbname.s, tbc->name.len, tbc->name.s); - if(tbc->hash==hash && tbc->dbname.len == dbn->len + LM_DBG("found dbname=%.*s, table=%.*s\n", tbc->dbname.len, + tbc->dbname.s, tbc->name.len, tbc->name.s); + if(tbc->hash == hash && tbc->dbname.len == dbn->len && tbc->name.len == tbn->len && !strncasecmp(tbc->dbname.s, dbn->s, dbn->len) && !strncasecmp(tbc->name.s, tbn->s, tbn->len)) { @@ -480,9 +490,8 @@ dbcassa_table_p dbcassa_db_get_table(const str* dbn, const str *tbn) return NULL; /* the file has changed - load again the schema */ - new_tbc = dbcassa_load_file((str*)dbn, (str*)tbn); - if(!new_tbc) - { + new_tbc = dbcassa_load_file((str *)dbn, (str *)tbn); + if(!new_tbc) { LM_ERR("could not load database from file [%.*s]\n", tbn->len, tbn->s); return NULL; } @@ -525,9 +534,9 @@ int dbcassa_read_table_schemas(void) { int i, j; str db_name, tb_name; - DIR* srcdir = opendir(dbcassa_schema_path.s); - DIR* db_dir; - struct dirent* dent; + DIR *srcdir = opendir(dbcassa_schema_path.s); + DIR *db_dir; + struct dirent *dent; int fn_len = dbcassa_schema_path.len; struct stat fstat; int dir_len; @@ -535,21 +544,19 @@ int dbcassa_read_table_schemas(void) unsigned int hashidx; /* init tables' hash table */ - if (!dbcassa_tbl_htable) { - dbcassa_tbl_htable = (dbcassa_tbl_htable_p)shm_malloc(DBCASSA_TABLE_SIZE* - sizeof(dbcassa_tbl_htable_t)); - if(dbcassa_tbl_htable==NULL) - { + if(!dbcassa_tbl_htable) { + dbcassa_tbl_htable = (dbcassa_tbl_htable_p)shm_malloc( + DBCASSA_TABLE_SIZE * sizeof(dbcassa_tbl_htable_t)); + if(dbcassa_tbl_htable == NULL) { LM_CRIT("no enough shm mem\n"); return -1; } - memset(dbcassa_tbl_htable, 0, DBCASSA_TABLE_SIZE*sizeof(dbcassa_tbl_htable_t)); - for(i=0; i=0; j--) + for(j = i - 1; j >= 0; j--) lock_destroy(&dbcassa_tbl_htable[j].rw_lock.lock); return -1; } @@ -558,40 +565,39 @@ int dbcassa_read_table_schemas(void) memset(full_path_buf, 0, _POSIX_PATH_MAX); strcpy(full_path_buf, dbcassa_schema_path.s); - if (full_path_buf[dbcassa_schema_path.len - 1] != '/') { - full_path_buf[fn_len++]= '/'; + if(full_path_buf[dbcassa_schema_path.len - 1] != '/') { + full_path_buf[fn_len++] = '/'; dbcassa_schema_path.len++; } - if (srcdir == NULL) { + if(srcdir == NULL) { perror("opendir"); return -1; } LM_DBG("Full name= %.*s\n", fn_len, full_path_buf); - while((dent = readdir(srcdir)) != NULL) - { + while((dent = readdir(srcdir)) != NULL) { if(strcmp(dent->d_name, ".") == 0 || strcmp(dent->d_name, "..") == 0) continue; /* Calculate full name, check we are in file length limits */ - if ((fn_len + strlen(dent->d_name) + 1) > _POSIX_PATH_MAX) + if((fn_len + strlen(dent->d_name) + 1) > _POSIX_PATH_MAX) continue; db_name.s = dent->d_name; db_name.len = strlen(dent->d_name); - - strcpy(full_path_buf+fn_len, dent->d_name); + + strcpy(full_path_buf + fn_len, dent->d_name); dir_len = fn_len + db_name.len; LM_DBG("Full dir name= %.*s\n", dir_len, full_path_buf); - if (stat(full_path_buf, &fstat) < 0) { + if(stat(full_path_buf, &fstat) < 0) { LM_ERR("stat failed %s\n", strerror(errno)); continue; } - if (!S_ISDIR(fstat.st_mode)) { + if(!S_ISDIR(fstat.st_mode)) { LM_ERR("not a directory\n"); continue; } @@ -610,25 +616,24 @@ int dbcassa_read_table_schemas(void) LM_ERR("Failed to open dictory %s\n", full_path_buf); continue; } - full_path_buf[dir_len++]= '/'; - while((dent = readdir(db_dir)) != NULL) - { - if(strcmp(dent->d_name, ".") == 0 || strcmp(dent->d_name, "..") == 0) + full_path_buf[dir_len++] = '/'; + while((dent = readdir(db_dir)) != NULL) { + if(strcmp(dent->d_name, ".") == 0 + || strcmp(dent->d_name, "..") == 0) continue; LM_DBG("database table %s\n", dent->d_name); - if(dir_len + strlen(dent->d_name)+1 > _POSIX_PATH_MAX) { + if(dir_len + strlen(dent->d_name) + 1 > _POSIX_PATH_MAX) { LM_ERR("File len too large\n"); continue; } - strcpy(full_path_buf+dir_len, dent->d_name); + strcpy(full_path_buf + dir_len, dent->d_name); tb_name.s = dent->d_name; tb_name.len = strlen(dent->d_name); LM_DBG("File path= %s\n", full_path_buf); tbc = dbcassa_load_file(&db_name, &tb_name); - if(!tbc) - { + if(!tbc) { LM_ERR("could not load database from file [%s]\n", tb_name.s); return -1; } @@ -654,10 +659,10 @@ void dbcassa_destroy_htable(void) dbcassa_table_p tbc, tbc0; /* destroy tables' hash table*/ - if(dbcassa_tbl_htable==0) + if(dbcassa_tbl_htable == 0) return; - for(i=0; i