Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

3641 lines (2639 sloc) 106.177 kb
/**
* Autogenerated by Thrift
*
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
*/
#ifndef Cassandra_H
#define Cassandra_H
#include <TProcessor.h>
#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<ColumnOrSuperColumn> & _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<std::string, std::vector<ColumnOrSuperColumn> > & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
virtual void multiget_count(std::map<std::string, int32_t> & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
virtual void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) = 0;
virtual void get_indexed_slices(std::vector<KeySlice> & _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 remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) = 0;
virtual void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level) = 0;
virtual void truncate(const std::string& cfname) = 0;
virtual void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return) = 0;
virtual void describe_keyspaces(std::vector<KsDef> & _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<TokenRange> & _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<std::string> & _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;
};
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<ColumnOrSuperColumn> & /* _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<std::string, std::vector<ColumnOrSuperColumn> > & /* _return */, const std::vector<std::string> & /* keys */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) {
return;
}
void multiget_count(std::map<std::string, int32_t> & /* _return */, const std::vector<std::string> & /* keys */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) {
return;
}
void get_range_slices(std::vector<KeySlice> & /* _return */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const KeyRange& /* range */, const ConsistencyLevel::type /* consistency_level */) {
return;
}
void get_indexed_slices(std::vector<KeySlice> & /* _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 remove(const std::string& /* key */, const ColumnPath& /* column_path */, const int64_t /* timestamp */, const ConsistencyLevel::type /* consistency_level */) {
return;
}
void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & /* mutation_map */, const ConsistencyLevel::type /* consistency_level */) {
return;
}
void truncate(const std::string& /* cfname */) {
return;
}
void describe_schema_versions(std::map<std::string, std::vector<std::string> > & /* _return */) {
return;
}
void describe_keyspaces(std::vector<KsDef> & /* _return */) {
return;
}
void describe_cluster_name(std::string& /* _return */) {
return;
}
void describe_version(std::string& /* _return */) {
return;
}
void describe_ring(std::vector<TokenRange> & /* _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<std::string> & /* _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;
}
};
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;
} _Cassandra_login_presult__isset;
class Cassandra_login_presult {
public:
virtual ~Cassandra_login_presult() throw() {}
AuthenticationException authnx;
AuthorizationException authzx;
_Cassandra_login_presult__isset __isset;
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
};
class Cassandra_set_keyspace_args {
public:
Cassandra_set_keyspace_args() : keyspace("") {
}
virtual ~Cassandra_set_keyspace_args() throw() {}
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 & ) const;
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
};
class Cassandra_set_keyspace_pargs {
public:
virtual ~Cassandra_set_keyspace_pargs() throw() {}
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;
} _Cassandra_set_keyspace_result__isset;
class Cassandra_set_keyspace_result {
public:
Cassandra_set_keyspace_result() {
}
virtual ~Cassandra_set_keyspace_result() throw() {}
InvalidRequestException ire;
_Cassandra_set_keyspace_result__isset __isset;
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);
}
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;
} _Cassandra_set_keyspace_presult__isset;
class Cassandra_set_keyspace_presult {
public:
virtual ~Cassandra_set_keyspace_presult() throw() {}
InvalidRequestException ire;
_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;
}
virtual ~Cassandra_get_args() throw() {}
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 & ) 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() {}
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;
} _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;
} _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;
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;
class Cassandra_get_slice_result {
public:
Cassandra_get_slice_result() {
}
virtual ~Cassandra_get_slice_result() throw() {}
std::vector<ColumnOrSuperColumn> 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<ColumnOrSuperColumn> * 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_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<std::string> 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<std::string> * 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;
class Cassandra_multiget_slice_result {
public:
Cassandra_multiget_slice_result() {
}
virtual ~Cassandra_multiget_slice_result() throw() {}
std::map<std::string, std::vector<ColumnOrSuperColumn> > 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<std::string, std::vector<ColumnOrSuperColumn> > * 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<std::string> 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<std::string> * 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;
class Cassandra_multiget_count_result {
public:
Cassandra_multiget_count_result() {
}
virtual ~Cassandra_multiget_count_result() throw() {}
std::map<std::string, int32_t> 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;
class Cassandra_multiget_count_presult {
public:
virtual ~Cassandra_multiget_count_presult() throw() {}
std::map<std::string, int32_t> * 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;
class Cassandra_get_range_slices_result {
public:
Cassandra_get_range_slices_result() {
}
virtual ~Cassandra_get_range_slices_result() throw() {}
std::vector<KeySlice> 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;
class Cassandra_get_range_slices_presult {
public:
virtual ~Cassandra_get_range_slices_presult() throw() {}
std::vector<KeySlice> * 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;
class Cassandra_get_indexed_slices_result {
public:
Cassandra_get_indexed_slices_result() {
}
virtual ~Cassandra_get_indexed_slices_result() throw() {}
std::vector<KeySlice> 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<KeySlice> * 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_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);
};
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;
_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;
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;
class Cassandra_remove_presult {
public:
virtual ~Cassandra_remove_presult() throw() {}
InvalidRequestException ire;
UnavailableException ue;
TimedOutException te;
_Cassandra_remove_presult__isset __isset;
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
};
class Cassandra_batch_mutate_args {
public:
Cassandra_batch_mutate_args() {
consistency_level = (ConsistencyLevel::type)1;
}
virtual ~Cassandra_batch_mutate_args() throw() {}
std::map<std::string, std::map<std::string, std::vector<Mutation> > > mutation_map;
ConsistencyLevel::type consistency_level;
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_batch_mutate_args & ) const;
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
};
class Cassandra_batch_mutate_pargs {
public:
virtual ~Cassandra_batch_mutate_pargs() throw() {}
const std::map<std::string, std::map<std::string, std::vector<Mutation> > > * 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_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;
class Cassandra_batch_mutate_presult {
public:
virtual ~Cassandra_batch_mutate_presult() throw() {}
InvalidRequestException ire;
UnavailableException ue;
TimedOutException te;
_Cassandra_batch_mutate_presult__isset __isset;
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
};
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);
}
bool operator < (const Cassandra_truncate_args & ) const;
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
};
class Cassandra_truncate_pargs {
public:
virtual ~Cassandra_truncate_pargs() throw() {}
const std::string* cfname;
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
};
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;
_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;
class Cassandra_truncate_presult {
public:
virtual ~Cassandra_truncate_presult() throw() {}
InvalidRequestException ire;
UnavailableException ue;
_Cassandra_truncate_presult__isset __isset;
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
};
class Cassandra_describe_schema_versions_args {
public:
Cassandra_describe_schema_versions_args() {
}
virtual ~Cassandra_describe_schema_versions_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);
}
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_describe_schema_versions_pargs {
public:
virtual ~Cassandra_describe_schema_versions_pargs() throw() {}
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:
Cassandra_describe_schema_versions_result() {
}
virtual ~Cassandra_describe_schema_versions_result() throw() {}
std::map<std::string, std::vector<std::string> > 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;
class Cassandra_describe_schema_versions_presult {
public:
virtual ~Cassandra_describe_schema_versions_presult() throw() {}
std::map<std::string, std::vector<std::string> > * success;
InvalidRequestException ire;
_Cassandra_describe_schema_versions_presult__isset __isset;
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
};
class Cassandra_describe_keyspaces_args {
public:
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;
};
class Cassandra_describe_keyspaces_pargs {
public:
virtual ~Cassandra_describe_keyspaces_pargs() throw() {}
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
};
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<KsDef> 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;
class Cassandra_describe_keyspaces_presult {
public:
virtual ~Cassandra_describe_keyspaces_presult() throw() {}
std::vector<KsDef> * 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<TokenRange> 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<TokenRange> * 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) {}
bool success;
} _Cassandra_describe_splits_result__isset;
class Cassandra_describe_splits_result {
public:
Cassandra_describe_splits_result() {
}
virtual ~Cassandra_describe_splits_result() throw() {}
std::vector<std::string> success;
_Cassandra_describe_splits_result__isset __isset;
bool operator == (const Cassandra_describe_splits_result & rhs) const
{
if (!(success == rhs.success))
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) {}
bool success;
} _Cassandra_describe_splits_presult__isset;
class Cassandra_describe_splits_presult {
public:
virtual ~Cassandra_describe_splits_presult() throw() {}
std::vector<std::string> * success;
_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) {}
bool success;
bool ire;
} _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;
_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;
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) {}
bool success;
bool ire;
} _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;
_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) {}
bool success;
bool ire;
} _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;
_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;
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) {}
bool success;
bool ire;
} _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;
_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) {}
bool success;
bool ire;
} _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;
_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;
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) {}
bool success;
bool ire;
} _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;
_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) {}
bool success;
bool ire;
} _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;
_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;
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) {}
bool success;
bool ire;
} _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;
_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) {}
bool success;
bool ire;
} _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;
_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;
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) {}
bool success;
bool ire;
} _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;
_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) {}
bool success;
bool ire;
} _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;
_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;
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) {}
bool success;
bool ire;
} _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;
_Cassandra_system_update_column_family_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<ColumnOrSuperColumn> & _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<ColumnOrSuperColumn> & _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<std::string, std::vector<ColumnOrSuperColumn> > & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
void send_multiget_slice(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
void recv_multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return);
void multiget_count(std::map<std::string, int32_t> & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
void send_multiget_count(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
void recv_multiget_count(std::map<std::string, int32_t> & _return);
void get_range_slices(std::vector<KeySlice> & _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<KeySlice> & _return);
void get_indexed_slices(std::vector<KeySlice> & _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<KeySlice> & _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 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 batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level);
void send_batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & 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<std::string, std::vector<std::string> > & _return);
void send_describe_schema_versions();
void recv_describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return);
void describe_keyspaces(std::vector<KsDef> & _return);
void send_describe_keyspaces();
void recv_describe_keyspaces(std::vector<KsDef> & _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<TokenRange> & _return, const std::string& keyspace);
void send_describe_ring(const std::string& keyspace);
void recv_describe_ring(std::vector<TokenRange> & _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<std::string> & _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<std::string> & _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);
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<CassandraIf> iface_;
virtual bool process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid);
private:
std::map<std::string, void (CassandraProcessor::*)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*)> processMap_;
void process_login(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_set_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_get_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_get_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_multiget_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_multiget_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_get_range_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_get_indexed_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_insert(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_remove(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_batch_mutate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_truncate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_describe_schema_versions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_describe_keyspaces(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_describe_cluster_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_describe_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_describe_ring(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_describe_partitioner(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_describe_snitch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_describe_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_describe_splits(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_system_add_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_system_drop_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_system_add_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_system_drop_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_system_update_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
void process_system_update_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
public:
CassandraProcessor(boost::shared_ptr<CassandraIf> 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_["remove"] = &CassandraProcessor::process_remove;
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;
}
virtual bool process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot);
virtual ~CassandraProcessor() {}
};
class CassandraMultiface : virtual public CassandraIf {
public:
CassandraMultiface(std::vector<boost::shared_ptr<CassandraIf> >& ifaces) : ifaces_(ifaces) {
}
virtual ~CassandraMultiface() {}
protected:
std::vector<boost::shared_ptr<CassandraIf> > ifaces_;
CassandraMultiface() {}
void add(boost::shared_ptr<CassandraIf> 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<ColumnOrSuperColumn> & _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<std::string, std::vector<ColumnOrSuperColumn> > & _return, const std::vector<std::string> & 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<std::string, int32_t> & _return, const std::vector<std::string> & 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<KeySlice> & _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<KeySlice> & _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 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 batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & 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<std::string, std::vector<std::string> > & _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<KsDef> & _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<TokenRange> & _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<std::string> & _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);
}
}
}
};
}}} // namespace
#endif
Jump to Line
Something went wrong with that request. Please try again.