/**
 * Autogenerated by Thrift Compiler (0.7.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 */
#ifndef Cassandra_H
#define Cassandra_H

#include <thrift/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 add(const std::string &key, const ColumnParent &column_parent,
			const CounterColumn &column,
			const ConsistencyLevel::type consistency_level) = 0;
	virtual void remove(const std::string &key, const ColumnPath &column_path,
			const int64_t timestamp,
			const ConsistencyLevel::type consistency_level) = 0;
	virtual void remove_counter(const std::string &key, const ColumnPath &path,
			const ConsistencyLevel::type consistency_level) = 0;
	virtual void batch_mutate(
			const std::map<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;
	virtual void execute_cql_query(CqlResult &_return, const std::string &query,
			const Compression::type compression) = 0;
};

class CassandraNull : virtual public CassandraIf
{
public:
	virtual ~CassandraNull()
	{
	}
	void login(const AuthenticationRequest & /* auth_request */)
	{
		return;
	}
	void set_keyspace(const std::string & /* keyspace */)
	{
		return;
	}
	void get(ColumnOrSuperColumn & /* _return */, const std::string & /* key */,
			const ColumnPath & /* column_path */,
			const ConsistencyLevel::type /* consistency_level */)
	{
		return;
	}
	void get_slice(std::vector<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 add(const std::string & /* key */,
			const ColumnParent & /* column_parent */,
			const CounterColumn & /* column */,
			const ConsistencyLevel::type /* consistency_level */)
	{
		return;
	}
	void remove(const std::string & /* key */,
			const ColumnPath & /* column_path */, const int64_t /* timestamp */,
			const ConsistencyLevel::type /* consistency_level */)
	{
		return;
	}
	void remove_counter(const std::string & /* key */,
			const ColumnPath & /* path */,
			const ConsistencyLevel::type /* consistency_level */)
	{
		return;
	}
	void batch_mutate(const std::map<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;
	}
	void execute_cql_query(CqlResult & /* _return */,
			const std::string & /* query */,
			const Compression::type /* compression */)
	{
		return;
	}
};


class Cassandra_login_args
{
public:
	Cassandra_login_args()
	{
	}

	virtual ~Cassandra_login_args() throw()
	{
	}

	AuthenticationRequest auth_request;

	void __set_auth_request(const AuthenticationRequest &val)
	{
		auth_request = val;
	}

	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;

	void __set_authnx(const AuthenticationException &val)
	{
		authnx = val;
	}

	void __set_authzx(const AuthorizationException &val)
	{
		authzx = val;
	}

	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;

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

	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;

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	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;

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

	void __set_column_path(const ColumnPath &val)
	{
		column_path = val;
	}

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	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;

	void __set_success(const ColumnOrSuperColumn &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_nfe(const NotFoundException &val)
	{
		nfe = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	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;

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

	void __set_column_parent(const ColumnParent &val)
	{
		column_parent = val;
	}

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

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	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;

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

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	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;

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

	void __set_column_parent(const ColumnParent &val)
	{
		column_parent = val;
	}

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

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	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;

	void __set_success(const int32_t val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	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;

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

	void __set_column_parent(const ColumnParent &val)
	{
		column_parent = val;
	}

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

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	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;

	void __set_success(
			const std::map<std::string, std::vector<ColumnOrSuperColumn>> &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	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;

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

	void __set_column_parent(const ColumnParent &val)
	{
		column_parent = val;
	}

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

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	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;

	void __set_success(const std::map<std::string, int32_t> &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	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;

	void __set_column_parent(const ColumnParent &val)
	{
		column_parent = val;
	}

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

	void __set_range(const KeyRange &val)
	{
		range = val;
	}

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	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;

	void __set_success(const std::vector<KeySlice> &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	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;

	void __set_column_parent(const ColumnParent &val)
	{
		column_parent = val;
	}

	void __set_index_clause(const IndexClause &val)
	{
		index_clause = val;
	}

	void __set_column_predicate(const SlicePredicate &val)
	{
		column_predicate = val;
	}

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	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;

	void __set_success(const std::vector<KeySlice> &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	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;

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

	void __set_column_parent(const ColumnParent &val)
	{
		column_parent = val;
	}

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

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	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;

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	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);
};


class Cassandra_add_args
{
public:
	Cassandra_add_args() : key("")
	{
		consistency_level = (ConsistencyLevel::type)1;
	}

	virtual ~Cassandra_add_args() throw()
	{
	}

	std::string key;
	ColumnParent column_parent;
	CounterColumn column;
	ConsistencyLevel::type consistency_level;

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

	void __set_column_parent(const ColumnParent &val)
	{
		column_parent = val;
	}

	void __set_column(const CounterColumn &val)
	{
		column = val;
	}

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	bool operator==(const Cassandra_add_args &rhs) const
	{
		if(!(key == rhs.key))
			return false;
		if(!(column_parent == rhs.column_parent))
			return false;
		if(!(column == rhs.column))
			return false;
		if(!(consistency_level == rhs.consistency_level))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_add_args &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_add_args &) const;

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


class Cassandra_add_pargs
{
public:
	virtual ~Cassandra_add_pargs() throw()
	{
	}

	const std::string *key;
	const ColumnParent *column_parent;
	const CounterColumn *column;
	const ConsistencyLevel::type *consistency_level;

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

typedef struct _Cassandra_add_result__isset
{
	_Cassandra_add_result__isset() : ire(false), ue(false), te(false)
	{
	}
	bool ire;
	bool ue;
	bool te;
} _Cassandra_add_result__isset;

class Cassandra_add_result
{
public:
	Cassandra_add_result()
	{
	}

	virtual ~Cassandra_add_result() throw()
	{
	}

	InvalidRequestException ire;
	UnavailableException ue;
	TimedOutException te;

	_Cassandra_add_result__isset __isset;

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	bool operator==(const Cassandra_add_result &rhs) const
	{
		if(!(ire == rhs.ire))
			return false;
		if(!(ue == rhs.ue))
			return false;
		if(!(te == rhs.te))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_add_result &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_add_result &) const;

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

typedef struct _Cassandra_add_presult__isset
{
	_Cassandra_add_presult__isset() : ire(false), ue(false), te(false)
	{
	}
	bool ire;
	bool ue;
	bool te;
} _Cassandra_add_presult__isset;

class Cassandra_add_presult
{
public:
	virtual ~Cassandra_add_presult() throw()
	{
	}

	InvalidRequestException ire;
	UnavailableException ue;
	TimedOutException te;

	_Cassandra_add_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;

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

	void __set_column_path(const ColumnPath &val)
	{
		column_path = val;
	}

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

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	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;

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	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_remove_counter_args
{
public:
	Cassandra_remove_counter_args() : key("")
	{
		consistency_level = (ConsistencyLevel::type)1;
	}

	virtual ~Cassandra_remove_counter_args() throw()
	{
	}

	std::string key;
	ColumnPath path;
	ConsistencyLevel::type consistency_level;

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

	void __set_path(const ColumnPath &val)
	{
		path = val;
	}

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	bool operator==(const Cassandra_remove_counter_args &rhs) const
	{
		if(!(key == rhs.key))
			return false;
		if(!(path == rhs.path))
			return false;
		if(!(consistency_level == rhs.consistency_level))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_remove_counter_args &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_remove_counter_args &) const;

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


class Cassandra_remove_counter_pargs
{
public:
	virtual ~Cassandra_remove_counter_pargs() throw()
	{
	}

	const std::string *key;
	const ColumnPath *path;
	const ConsistencyLevel::type *consistency_level;

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

typedef struct _Cassandra_remove_counter_result__isset
{
	_Cassandra_remove_counter_result__isset() : ire(false), ue(false), te(false)
	{
	}
	bool ire;
	bool ue;
	bool te;
} _Cassandra_remove_counter_result__isset;

class Cassandra_remove_counter_result
{
public:
	Cassandra_remove_counter_result()
	{
	}

	virtual ~Cassandra_remove_counter_result() throw()
	{
	}

	InvalidRequestException ire;
	UnavailableException ue;
	TimedOutException te;

	_Cassandra_remove_counter_result__isset __isset;

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	bool operator==(const Cassandra_remove_counter_result &rhs) const
	{
		if(!(ire == rhs.ire))
			return false;
		if(!(ue == rhs.ue))
			return false;
		if(!(te == rhs.te))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_remove_counter_result &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_remove_counter_result &) const;

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

typedef struct _Cassandra_remove_counter_presult__isset
{
	_Cassandra_remove_counter_presult__isset()
		: ire(false), ue(false), te(false)
	{
	}
	bool ire;
	bool ue;
	bool te;
} _Cassandra_remove_counter_presult__isset;

class Cassandra_remove_counter_presult
{
public:
	virtual ~Cassandra_remove_counter_presult() throw()
	{
	}

	InvalidRequestException ire;
	UnavailableException ue;
	TimedOutException te;

	_Cassandra_remove_counter_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;

	void __set_mutation_map(const std::map<std::string,
			std::map<std::string, std::vector<Mutation>>> &val)
	{
		mutation_map = val;
	}

	void __set_consistency_level(const ConsistencyLevel::type val)
	{
		consistency_level = val;
	}

	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;

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	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;

	void __set_cfname(const std::string &val)
	{
		cfname = val;
	}

	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;

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	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;

	void __set_success(
			const std::map<std::string, std::vector<std::string>> &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	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;

	void __set_success(const std::vector<KsDef> &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	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;

	void __set_success(const std::string &val)
	{
		success = val;
	}

	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;

	void __set_success(const std::string &val)
	{
		success = val;
	}

	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;

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

	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;

	void __set_success(const std::vector<TokenRange> &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	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;

	void __set_success(const std::string &val)
	{
		success = val;
	}

	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;

	void __set_success(const std::string &val)
	{
		success = val;
	}

	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;

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

	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;

	void __set_success(const KsDef &val)
	{
		success = val;
	}

	void __set_nfe(const NotFoundException &val)
	{
		nfe = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	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;

	void __set_cfName(const std::string &val)
	{
		cfName = val;
	}

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

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

	void __set_keys_per_split(const int32_t val)
	{
		keys_per_split = val;
	}

	bool operator==(const Cassandra_describe_splits_args &rhs) const
	{
		if(!(cfName == rhs.cfName))
			return false;
		if(!(start_token == rhs.start_token))
			return false;
		if(!(end_token == rhs.end_token))
			return false;
		if(!(keys_per_split == rhs.keys_per_split))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_describe_splits_args &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_describe_splits_args &) const;

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


class Cassandra_describe_splits_pargs
{
public:
	virtual ~Cassandra_describe_splits_pargs() throw()
	{
	}

	const std::string *cfName;
	const std::string *start_token;
	const std::string *end_token;
	const int32_t *keys_per_split;

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

typedef struct _Cassandra_describe_splits_result__isset
{
	_Cassandra_describe_splits_result__isset() : success(false), ire(false)
	{
	}
	bool success;
	bool ire;
} _Cassandra_describe_splits_result__isset;

class Cassandra_describe_splits_result
{
public:
	Cassandra_describe_splits_result()
	{
	}

	virtual ~Cassandra_describe_splits_result() throw()
	{
	}

	std::vector<std::string> success;
	InvalidRequestException ire;

	_Cassandra_describe_splits_result__isset __isset;

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

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	bool operator==(const Cassandra_describe_splits_result &rhs) const
	{
		if(!(success == rhs.success))
			return false;
		if(!(ire == rhs.ire))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_describe_splits_result &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_describe_splits_result &) const;

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

typedef struct _Cassandra_describe_splits_presult__isset
{
	_Cassandra_describe_splits_presult__isset() : success(false), ire(false)
	{
	}
	bool success;
	bool ire;
} _Cassandra_describe_splits_presult__isset;

class Cassandra_describe_splits_presult
{
public:
	virtual ~Cassandra_describe_splits_presult() throw()
	{
	}

	std::vector<std::string> *success;
	InvalidRequestException ire;

	_Cassandra_describe_splits_presult__isset __isset;

	uint32_t read(::apache::thrift::protocol::TProtocol *iprot);
};


class Cassandra_system_add_column_family_args
{
public:
	Cassandra_system_add_column_family_args()
	{
	}

	virtual ~Cassandra_system_add_column_family_args() throw()
	{
	}

	CfDef cf_def;

	void __set_cf_def(const CfDef &val)
	{
		cf_def = val;
	}

	bool operator==(const Cassandra_system_add_column_family_args &rhs) const
	{
		if(!(cf_def == rhs.cf_def))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_system_add_column_family_args &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_add_column_family_args &) const;

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


class Cassandra_system_add_column_family_pargs
{
public:
	virtual ~Cassandra_system_add_column_family_pargs() throw()
	{
	}

	const CfDef *cf_def;

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

typedef struct _Cassandra_system_add_column_family_result__isset
{
	_Cassandra_system_add_column_family_result__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_add_column_family_result__isset;

class Cassandra_system_add_column_family_result
{
public:
	Cassandra_system_add_column_family_result() : success("")
	{
	}

	virtual ~Cassandra_system_add_column_family_result() throw()
	{
	}

	std::string success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_add_column_family_result__isset __isset;

	void __set_success(const std::string &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_sde(const SchemaDisagreementException &val)
	{
		sde = val;
	}

	bool operator==(const Cassandra_system_add_column_family_result &rhs) const
	{
		if(!(success == rhs.success))
			return false;
		if(!(ire == rhs.ire))
			return false;
		if(!(sde == rhs.sde))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_system_add_column_family_result &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_add_column_family_result &) const;

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

typedef struct _Cassandra_system_add_column_family_presult__isset
{
	_Cassandra_system_add_column_family_presult__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_add_column_family_presult__isset;

class Cassandra_system_add_column_family_presult
{
public:
	virtual ~Cassandra_system_add_column_family_presult() throw()
	{
	}

	std::string *success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_add_column_family_presult__isset __isset;

	uint32_t read(::apache::thrift::protocol::TProtocol *iprot);
};


class Cassandra_system_drop_column_family_args
{
public:
	Cassandra_system_drop_column_family_args() : column_family("")
	{
	}

	virtual ~Cassandra_system_drop_column_family_args() throw()
	{
	}

	std::string column_family;

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

	bool operator==(const Cassandra_system_drop_column_family_args &rhs) const
	{
		if(!(column_family == rhs.column_family))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_system_drop_column_family_args &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_drop_column_family_args &) const;

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


class Cassandra_system_drop_column_family_pargs
{
public:
	virtual ~Cassandra_system_drop_column_family_pargs() throw()
	{
	}

	const std::string *column_family;

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

typedef struct _Cassandra_system_drop_column_family_result__isset
{
	_Cassandra_system_drop_column_family_result__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_drop_column_family_result__isset;

class Cassandra_system_drop_column_family_result
{
public:
	Cassandra_system_drop_column_family_result() : success("")
	{
	}

	virtual ~Cassandra_system_drop_column_family_result() throw()
	{
	}

	std::string success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_drop_column_family_result__isset __isset;

	void __set_success(const std::string &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_sde(const SchemaDisagreementException &val)
	{
		sde = val;
	}

	bool operator==(const Cassandra_system_drop_column_family_result &rhs) const
	{
		if(!(success == rhs.success))
			return false;
		if(!(ire == rhs.ire))
			return false;
		if(!(sde == rhs.sde))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_system_drop_column_family_result &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_drop_column_family_result &) const;

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

typedef struct _Cassandra_system_drop_column_family_presult__isset
{
	_Cassandra_system_drop_column_family_presult__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_drop_column_family_presult__isset;

class Cassandra_system_drop_column_family_presult
{
public:
	virtual ~Cassandra_system_drop_column_family_presult() throw()
	{
	}

	std::string *success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_drop_column_family_presult__isset __isset;

	uint32_t read(::apache::thrift::protocol::TProtocol *iprot);
};


class Cassandra_system_add_keyspace_args
{
public:
	Cassandra_system_add_keyspace_args()
	{
	}

	virtual ~Cassandra_system_add_keyspace_args() throw()
	{
	}

	KsDef ks_def;

	void __set_ks_def(const KsDef &val)
	{
		ks_def = val;
	}

	bool operator==(const Cassandra_system_add_keyspace_args &rhs) const
	{
		if(!(ks_def == rhs.ks_def))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_system_add_keyspace_args &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_add_keyspace_args &) const;

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


class Cassandra_system_add_keyspace_pargs
{
public:
	virtual ~Cassandra_system_add_keyspace_pargs() throw()
	{
	}

	const KsDef *ks_def;

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

typedef struct _Cassandra_system_add_keyspace_result__isset
{
	_Cassandra_system_add_keyspace_result__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_add_keyspace_result__isset;

class Cassandra_system_add_keyspace_result
{
public:
	Cassandra_system_add_keyspace_result() : success("")
	{
	}

	virtual ~Cassandra_system_add_keyspace_result() throw()
	{
	}

	std::string success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_add_keyspace_result__isset __isset;

	void __set_success(const std::string &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_sde(const SchemaDisagreementException &val)
	{
		sde = val;
	}

	bool operator==(const Cassandra_system_add_keyspace_result &rhs) const
	{
		if(!(success == rhs.success))
			return false;
		if(!(ire == rhs.ire))
			return false;
		if(!(sde == rhs.sde))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_system_add_keyspace_result &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_add_keyspace_result &) const;

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

typedef struct _Cassandra_system_add_keyspace_presult__isset
{
	_Cassandra_system_add_keyspace_presult__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_add_keyspace_presult__isset;

class Cassandra_system_add_keyspace_presult
{
public:
	virtual ~Cassandra_system_add_keyspace_presult() throw()
	{
	}

	std::string *success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_add_keyspace_presult__isset __isset;

	uint32_t read(::apache::thrift::protocol::TProtocol *iprot);
};


class Cassandra_system_drop_keyspace_args
{
public:
	Cassandra_system_drop_keyspace_args() : keyspace("")
	{
	}

	virtual ~Cassandra_system_drop_keyspace_args() throw()
	{
	}

	std::string keyspace;

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

	bool operator==(const Cassandra_system_drop_keyspace_args &rhs) const
	{
		if(!(keyspace == rhs.keyspace))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_system_drop_keyspace_args &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_drop_keyspace_args &) const;

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


class Cassandra_system_drop_keyspace_pargs
{
public:
	virtual ~Cassandra_system_drop_keyspace_pargs() throw()
	{
	}

	const std::string *keyspace;

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

typedef struct _Cassandra_system_drop_keyspace_result__isset
{
	_Cassandra_system_drop_keyspace_result__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_drop_keyspace_result__isset;

class Cassandra_system_drop_keyspace_result
{
public:
	Cassandra_system_drop_keyspace_result() : success("")
	{
	}

	virtual ~Cassandra_system_drop_keyspace_result() throw()
	{
	}

	std::string success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_drop_keyspace_result__isset __isset;

	void __set_success(const std::string &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_sde(const SchemaDisagreementException &val)
	{
		sde = val;
	}

	bool operator==(const Cassandra_system_drop_keyspace_result &rhs) const
	{
		if(!(success == rhs.success))
			return false;
		if(!(ire == rhs.ire))
			return false;
		if(!(sde == rhs.sde))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_system_drop_keyspace_result &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_drop_keyspace_result &) const;

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

typedef struct _Cassandra_system_drop_keyspace_presult__isset
{
	_Cassandra_system_drop_keyspace_presult__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_drop_keyspace_presult__isset;

class Cassandra_system_drop_keyspace_presult
{
public:
	virtual ~Cassandra_system_drop_keyspace_presult() throw()
	{
	}

	std::string *success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_drop_keyspace_presult__isset __isset;

	uint32_t read(::apache::thrift::protocol::TProtocol *iprot);
};


class Cassandra_system_update_keyspace_args
{
public:
	Cassandra_system_update_keyspace_args()
	{
	}

	virtual ~Cassandra_system_update_keyspace_args() throw()
	{
	}

	KsDef ks_def;

	void __set_ks_def(const KsDef &val)
	{
		ks_def = val;
	}

	bool operator==(const Cassandra_system_update_keyspace_args &rhs) const
	{
		if(!(ks_def == rhs.ks_def))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_system_update_keyspace_args &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_update_keyspace_args &) const;

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


class Cassandra_system_update_keyspace_pargs
{
public:
	virtual ~Cassandra_system_update_keyspace_pargs() throw()
	{
	}

	const KsDef *ks_def;

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

typedef struct _Cassandra_system_update_keyspace_result__isset
{
	_Cassandra_system_update_keyspace_result__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_update_keyspace_result__isset;

class Cassandra_system_update_keyspace_result
{
public:
	Cassandra_system_update_keyspace_result() : success("")
	{
	}

	virtual ~Cassandra_system_update_keyspace_result() throw()
	{
	}

	std::string success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_update_keyspace_result__isset __isset;

	void __set_success(const std::string &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_sde(const SchemaDisagreementException &val)
	{
		sde = val;
	}

	bool operator==(const Cassandra_system_update_keyspace_result &rhs) const
	{
		if(!(success == rhs.success))
			return false;
		if(!(ire == rhs.ire))
			return false;
		if(!(sde == rhs.sde))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_system_update_keyspace_result &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_update_keyspace_result &) const;

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

typedef struct _Cassandra_system_update_keyspace_presult__isset
{
	_Cassandra_system_update_keyspace_presult__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_update_keyspace_presult__isset;

class Cassandra_system_update_keyspace_presult
{
public:
	virtual ~Cassandra_system_update_keyspace_presult() throw()
	{
	}

	std::string *success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_update_keyspace_presult__isset __isset;

	uint32_t read(::apache::thrift::protocol::TProtocol *iprot);
};


class Cassandra_system_update_column_family_args
{
public:
	Cassandra_system_update_column_family_args()
	{
	}

	virtual ~Cassandra_system_update_column_family_args() throw()
	{
	}

	CfDef cf_def;

	void __set_cf_def(const CfDef &val)
	{
		cf_def = val;
	}

	bool operator==(const Cassandra_system_update_column_family_args &rhs) const
	{
		if(!(cf_def == rhs.cf_def))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_system_update_column_family_args &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_update_column_family_args &) const;

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


class Cassandra_system_update_column_family_pargs
{
public:
	virtual ~Cassandra_system_update_column_family_pargs() throw()
	{
	}

	const CfDef *cf_def;

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

typedef struct _Cassandra_system_update_column_family_result__isset
{
	_Cassandra_system_update_column_family_result__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_update_column_family_result__isset;

class Cassandra_system_update_column_family_result
{
public:
	Cassandra_system_update_column_family_result() : success("")
	{
	}

	virtual ~Cassandra_system_update_column_family_result() throw()
	{
	}

	std::string success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_update_column_family_result__isset __isset;

	void __set_success(const std::string &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_sde(const SchemaDisagreementException &val)
	{
		sde = val;
	}

	bool operator==(
			const Cassandra_system_update_column_family_result &rhs) const
	{
		if(!(success == rhs.success))
			return false;
		if(!(ire == rhs.ire))
			return false;
		if(!(sde == rhs.sde))
			return false;
		return true;
	}
	bool operator!=(
			const Cassandra_system_update_column_family_result &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_system_update_column_family_result &) const;

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

typedef struct _Cassandra_system_update_column_family_presult__isset
{
	_Cassandra_system_update_column_family_presult__isset()
		: success(false), ire(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool sde;
} _Cassandra_system_update_column_family_presult__isset;

class Cassandra_system_update_column_family_presult
{
public:
	virtual ~Cassandra_system_update_column_family_presult() throw()
	{
	}

	std::string *success;
	InvalidRequestException ire;
	SchemaDisagreementException sde;

	_Cassandra_system_update_column_family_presult__isset __isset;

	uint32_t read(::apache::thrift::protocol::TProtocol *iprot);
};


class Cassandra_execute_cql_query_args
{
public:
	Cassandra_execute_cql_query_args() : query("")
	{
	}

	virtual ~Cassandra_execute_cql_query_args() throw()
	{
	}

	std::string query;
	Compression::type compression;

	void __set_query(const std::string &val)
	{
		query = val;
	}

	void __set_compression(const Compression::type val)
	{
		compression = val;
	}

	bool operator==(const Cassandra_execute_cql_query_args &rhs) const
	{
		if(!(query == rhs.query))
			return false;
		if(!(compression == rhs.compression))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_execute_cql_query_args &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_execute_cql_query_args &) const;

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


class Cassandra_execute_cql_query_pargs
{
public:
	virtual ~Cassandra_execute_cql_query_pargs() throw()
	{
	}

	const std::string *query;
	const Compression::type *compression;

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

typedef struct _Cassandra_execute_cql_query_result__isset
{
	_Cassandra_execute_cql_query_result__isset()
		: success(false), ire(false), ue(false), te(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool ue;
	bool te;
	bool sde;
} _Cassandra_execute_cql_query_result__isset;

class Cassandra_execute_cql_query_result
{
public:
	Cassandra_execute_cql_query_result()
	{
	}

	virtual ~Cassandra_execute_cql_query_result() throw()
	{
	}

	CqlResult success;
	InvalidRequestException ire;
	UnavailableException ue;
	TimedOutException te;
	SchemaDisagreementException sde;

	_Cassandra_execute_cql_query_result__isset __isset;

	void __set_success(const CqlResult &val)
	{
		success = val;
	}

	void __set_ire(const InvalidRequestException &val)
	{
		ire = val;
	}

	void __set_ue(const UnavailableException &val)
	{
		ue = val;
	}

	void __set_te(const TimedOutException &val)
	{
		te = val;
	}

	void __set_sde(const SchemaDisagreementException &val)
	{
		sde = val;
	}

	bool operator==(const Cassandra_execute_cql_query_result &rhs) const
	{
		if(!(success == rhs.success))
			return false;
		if(!(ire == rhs.ire))
			return false;
		if(!(ue == rhs.ue))
			return false;
		if(!(te == rhs.te))
			return false;
		if(!(sde == rhs.sde))
			return false;
		return true;
	}
	bool operator!=(const Cassandra_execute_cql_query_result &rhs) const
	{
		return !(*this == rhs);
	}

	bool operator<(const Cassandra_execute_cql_query_result &) const;

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

typedef struct _Cassandra_execute_cql_query_presult__isset
{
	_Cassandra_execute_cql_query_presult__isset()
		: success(false), ire(false), ue(false), te(false), sde(false)
	{
	}
	bool success;
	bool ire;
	bool ue;
	bool te;
	bool sde;
} _Cassandra_execute_cql_query_presult__isset;

class Cassandra_execute_cql_query_presult
{
public:
	virtual ~Cassandra_execute_cql_query_presult() throw()
	{
	}

	CqlResult *success;
	InvalidRequestException ire;
	UnavailableException ue;
	TimedOutException te;
	SchemaDisagreementException sde;

	_Cassandra_execute_cql_query_presult__isset __isset;

	uint32_t read(::apache::thrift::protocol::TProtocol *iprot);
};

class CassandraClient : virtual public CassandraIf
{
public:
	CassandraClient(
			boost::shared_ptr<::apache::thrift::protocol::TProtocol> prot)
		: piprot_(prot), poprot_(prot)
	{
		iprot_ = prot.get();
		oprot_ = prot.get();
	}
	CassandraClient(
			boost::shared_ptr<::apache::thrift::protocol::TProtocol> iprot,
			boost::shared_ptr<::apache::thrift::protocol::TProtocol> oprot)
		: piprot_(iprot), poprot_(oprot)
	{
		iprot_ = iprot.get();
		oprot_ = oprot.get();
	}
	boost::shared_ptr<::apache::thrift::protocol::TProtocol> getInputProtocol()
	{
		return piprot_;
	}
	boost::shared_ptr<::apache::thrift::protocol::TProtocol> getOutputProtocol()
	{
		return poprot_;
	}
	void login(const AuthenticationRequest &auth_request);
	void send_login(const AuthenticationRequest &auth_request);
	void recv_login();
	void set_keyspace(const std::string &keyspace);
	void send_set_keyspace(const std::string &keyspace);
	void recv_set_keyspace();
	void get(ColumnOrSuperColumn &_return, const std::string &key,
			const ColumnPath &column_path,
			const ConsistencyLevel::type consistency_level);
	void send_get(const std::string &key, const ColumnPath &column_path,
			const ConsistencyLevel::type consistency_level);
	void recv_get(ColumnOrSuperColumn &_return);
	void get_slice(std::vector<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 add(const std::string &key, const ColumnParent &column_parent,
			const CounterColumn &column,
			const ConsistencyLevel::type consistency_level);
	void send_add(const std::string &key, const ColumnParent &column_parent,
			const CounterColumn &column,
			const ConsistencyLevel::type consistency_level);
	void recv_add();
	void remove(const std::string &key, const ColumnPath &column_path,
			const int64_t timestamp,
			const ConsistencyLevel::type consistency_level);
	void send_remove(const std::string &key, const ColumnPath &column_path,
			const int64_t timestamp,
			const ConsistencyLevel::type consistency_level);
	void recv_remove();
	void remove_counter(const std::string &key, const ColumnPath &path,
			const ConsistencyLevel::type consistency_level);
	void send_remove_counter(const std::string &key, const ColumnPath &path,
			const ConsistencyLevel::type consistency_level);
	void recv_remove_counter();
	void batch_mutate(
			const std::map<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);
	void execute_cql_query(CqlResult &_return, const std::string &query,
			const Compression::type compression);
	void send_execute_cql_query(
			const std::string &query, const Compression::type compression);
	void recv_execute_cql_query(CqlResult &_return);

protected:
	boost::shared_ptr<::apache::thrift::protocol::TProtocol> piprot_;
	boost::shared_ptr<::apache::thrift::protocol::TProtocol> poprot_;
	::apache::thrift::protocol::TProtocol *iprot_;
	::apache::thrift::protocol::TProtocol *oprot_;
};

class CassandraProcessor : virtual public ::apache::thrift::TProcessor
{
protected:
	boost::shared_ptr<CassandraIf> iface_;
	virtual bool process_fn(::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, std::string &fname,
			int32_t seqid, void *callContext);

private:
	std::map<std::string,
			void (CassandraProcessor::*)(int32_t,
					::apache::thrift::protocol::TProtocol *,
					::apache::thrift::protocol::TProtocol *, void *)>
			processMap_;
	void process_login(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_set_keyspace(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_get(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_get_slice(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_get_count(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_multiget_slice(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_multiget_count(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_get_range_slices(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_get_indexed_slices(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_insert(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_add(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_remove(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_remove_counter(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_batch_mutate(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_truncate(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_describe_schema_versions(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_describe_keyspaces(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_describe_cluster_name(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_describe_version(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_describe_ring(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_describe_partitioner(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_describe_snitch(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_describe_keyspace(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_describe_splits(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_system_add_column_family(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_system_drop_column_family(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_system_add_keyspace(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_system_drop_keyspace(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_system_update_keyspace(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_system_update_column_family(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);
	void process_execute_cql_query(int32_t seqid,
			::apache::thrift::protocol::TProtocol *iprot,
			::apache::thrift::protocol::TProtocol *oprot, void *callContext);

public:
	CassandraProcessor(boost::shared_ptr<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_["add"] = &CassandraProcessor::process_add;
		processMap_["remove"] = &CassandraProcessor::process_remove;
		processMap_["remove_counter"] =
				&CassandraProcessor::process_remove_counter;
		processMap_["batch_mutate"] = &CassandraProcessor::process_batch_mutate;
		processMap_["truncate"] = &CassandraProcessor::process_truncate;
		processMap_["describe_schema_versions"] =
				&CassandraProcessor::process_describe_schema_versions;
		processMap_["describe_keyspaces"] =
				&CassandraProcessor::process_describe_keyspaces;
		processMap_["describe_cluster_name"] =
				&CassandraProcessor::process_describe_cluster_name;
		processMap_["describe_version"] =
				&CassandraProcessor::process_describe_version;
		processMap_["describe_ring"] =
				&CassandraProcessor::process_describe_ring;
		processMap_["describe_partitioner"] =
				&CassandraProcessor::process_describe_partitioner;
		processMap_["describe_snitch"] =
				&CassandraProcessor::process_describe_snitch;
		processMap_["describe_keyspace"] =
				&CassandraProcessor::process_describe_keyspace;
		processMap_["describe_splits"] =
				&CassandraProcessor::process_describe_splits;
		processMap_["system_add_column_family"] =
				&CassandraProcessor::process_system_add_column_family;
		processMap_["system_drop_column_family"] =
				&CassandraProcessor::process_system_drop_column_family;
		processMap_["system_add_keyspace"] =
				&CassandraProcessor::process_system_add_keyspace;
		processMap_["system_drop_keyspace"] =
				&CassandraProcessor::process_system_drop_keyspace;
		processMap_["system_update_keyspace"] =
				&CassandraProcessor::process_system_update_keyspace;
		processMap_["system_update_column_family"] =
				&CassandraProcessor::process_system_update_column_family;
		processMap_["execute_cql_query"] =
				&CassandraProcessor::process_execute_cql_query;
	}

	virtual bool process(
			boost::shared_ptr<::apache::thrift::protocol::TProtocol> piprot,
			boost::shared_ptr<::apache::thrift::protocol::TProtocol> poprot,
			void *callContext);
	virtual ~CassandraProcessor()
	{
	}
};

class CassandraMultiface : virtual public CassandraIf
{
public:
	CassandraMultiface(std::vector<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)
	{
		size_t sz = ifaces_.size();
		for(size_t i = 0; i < sz; ++i) {
			ifaces_[i]->login(auth_request);
		}
	}

	void set_keyspace(const std::string &keyspace)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_t i = 0; i < sz; ++i) {
			ifaces_[i]->insert(key, column_parent, column, consistency_level);
		}
	}

	void add(const std::string &key, const ColumnParent &column_parent,
			const CounterColumn &column,
			const ConsistencyLevel::type consistency_level)
	{
		size_t sz = ifaces_.size();
		for(size_t i = 0; i < sz; ++i) {
			ifaces_[i]->add(key, column_parent, column, consistency_level);
		}
	}

	void remove(const std::string &key, const ColumnPath &column_path,
			const int64_t timestamp,
			const ConsistencyLevel::type consistency_level)
	{
		size_t sz = ifaces_.size();
		for(size_t i = 0; i < sz; ++i) {
			ifaces_[i]->remove(key, column_path, timestamp, consistency_level);
		}
	}

	void remove_counter(const std::string &key, const ColumnPath &path,
			const ConsistencyLevel::type consistency_level)
	{
		size_t sz = ifaces_.size();
		for(size_t i = 0; i < sz; ++i) {
			ifaces_[i]->remove_counter(key, path, consistency_level);
		}
	}

	void batch_mutate(
			const std::map<std::string,
					std::map<std::string, std::vector<Mutation>>> &mutation_map,
			const ConsistencyLevel::type consistency_level)
	{
		size_t sz = ifaces_.size();
		for(size_t i = 0; i < sz; ++i) {
			ifaces_[i]->batch_mutate(mutation_map, consistency_level);
		}
	}

	void truncate(const std::string &cfname)
	{
		size_t sz = ifaces_.size();
		for(size_t i = 0; i < sz; ++i) {
			ifaces_[i]->truncate(cfname);
		}
	}

	void describe_schema_versions(
			std::map<std::string, std::vector<std::string>> &_return)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_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)
	{
		size_t sz = ifaces_.size();
		for(size_t i = 0; i < sz; ++i) {
			if(i == sz - 1) {
				ifaces_[i]->system_update_column_family(_return, cf_def);
				return;
			} else {
				ifaces_[i]->system_update_column_family(_return, cf_def);
			}
		}
	}

	void execute_cql_query(CqlResult &_return, const std::string &query,
			const Compression::type compression)
	{
		size_t sz = ifaces_.size();
		for(size_t i = 0; i < sz; ++i) {
			if(i == sz - 1) {
				ifaces_[i]->execute_cql_query(_return, query, compression);
				return;
			} else {
				ifaces_[i]->execute_cql_query(_return, query, compression);
			}
		}
	}
};

} // namespace cassandra
} // namespace apache
} // namespace org

#endif
