Movatterモバイル変換

#include <client.hpp>

Classes
struct	bitfield_operation

Public Types
enum	client_type {normal,master,pubsub,slave }

enum	connect_state { dropped,start,sleeping,ok, failed,lookup_failed,stopped }

enum	aggregate_method {sum,min,max,server_default }

enum	geo_unit {m,km,ft,mi }

enum	overflow_type {wrap,sat,fail,server_default }

enum	bitfield_operation_type {get,set,incrby }

typedef std::function< void(const std::string &host, std::size_t port,connect_state status)>	connect_callback_t

typedef std::function< void(reply &)>	reply_callback_t

Public Member Functions
	client (void)
	ctor

	client (const std::shared_ptr<network::tcp_client_iface > &tcp_client)

	~client (void)
	dtor

	client (constclient &)=delete
	copy ctor

client &	operator= (constclient &)=delete
	assignment operator

void	connect (const std::string &host="127.0.0.1", std::size_t port=6379, constconnect_callback_t &connect_callback=nullptr, std::uint32_t timeout_msecs=0, std::int32_t max_reconnects=0, std::uint32_t reconnect_interval_msecs=0)

void	connect (const std::string &name, constconnect_callback_t &connect_callback=nullptr, std::uint32_t timeout_msecs=0, std::int32_t max_reconnects=0, std::uint32_t reconnect_interval_msecs=0)

bool	is_connected (void) const

void	disconnect (bool wait_for_removal=false)

bool	is_reconnecting (void) const

void	cancel_reconnect (void)

client &	send (const std::vector< std::string > &redis_cmd, constreply_callback_t &callback)

std::future<reply >	send (const std::vector< std::string > &redis_cmd)

client &	commit (void)

client &	sync_commit (void)

template<class Rep , class Period >
client &	sync_commit (const std::chrono::duration< Rep, Period > &timeout)

void	add_sentinel (const std::string &host, std::size_t port, std::uint32_t timeout_msecs=0)

constsentinel &	get_sentinel (void) const

sentinel &	get_sentinel (void)

void	clear_sentinels (void)

std::string	aggregate_method_to_string (aggregate_method method) const

std::string	geo_unit_to_string (geo_unit unit) const

std::string	overflow_type_to_string (overflow_type type) const

std::string	bitfield_operation_type_to_string (bitfield_operation_type operation) const

client &	append (const std::string &key, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	append (const std::string &key, const std::string &value)

client &	auth (const std::string &password, constreply_callback_t &reply_callback)

std::future<reply >	auth (const std::string &password)

client &	bgrewriteaof (constreply_callback_t &reply_callback)

std::future<reply >	bgrewriteaof ()

client &	bgsave (constreply_callback_t &reply_callback)

std::future<reply >	bgsave ()

client &	bitcount (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	bitcount (const std::string &key)

client &	bitcount (const std::string &key, int start, int end, constreply_callback_t &reply_callback)

std::future<reply >	bitcount (const std::string &key, int start, int end)

client &	bitfield (const std::string &key, const std::vector<bitfield_operation > &operations, constreply_callback_t &reply_callback)

std::future<reply >	bitfield (const std::string &key, const std::vector<bitfield_operation > &operations)

client &	bitop (const std::string &operation, const std::string &destkey, const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	bitop (const std::string &operation, const std::string &destkey, const std::vector< std::string > &keys)

client &	bitpos (const std::string &key, int bit, constreply_callback_t &reply_callback)

std::future<reply >	bitpos (const std::string &key, int bit)

client &	bitpos (const std::string &key, int bit, int start, constreply_callback_t &reply_callback)

std::future<reply >	bitpos (const std::string &key, int bit, int start)

client &	bitpos (const std::string &key, int bit, int start, int end, constreply_callback_t &reply_callback)

std::future<reply >	bitpos (const std::string &key, int bit, int start, int end)

client &	blpop (const std::vector< std::string > &keys, int timeout, constreply_callback_t &reply_callback)

std::future<reply >	blpop (const std::vector< std::string > &keys, int timeout)

client &	brpop (const std::vector< std::string > &keys, int timeout, constreply_callback_t &reply_callback)

std::future<reply >	brpop (const std::vector< std::string > &keys, int timeout)

client &	brpoplpush (const std::string &src, const std::string &dst, int timeout, constreply_callback_t &reply_callback)

std::future<reply >	brpoplpush (const std::string &src, const std::string &dst, int timeout)

template<typename T , typename... Ts>
client &	client_kill (const std::string &host, int port, const T &arg, const Ts &... args)

client &	client_kill (const std::string &host, int port)

template<typename... Ts>
client &	client_kill (const char *host, int port, const Ts &... args)

template<typename T , typename... Ts>
client &	client_kill (const T &, const Ts &...)

template<typename T , typename... Ts>
std::future<reply >	client_kill_future (const T, const Ts...)

client &	client_list (constreply_callback_t &reply_callback)

std::future<reply >	client_list ()

client &	client_getname (constreply_callback_t &reply_callback)

std::future<reply >	client_getname ()

client &	client_pause (int timeout, constreply_callback_t &reply_callback)

std::future<reply >	client_pause (int timeout)

client &	client_reply (const std::string &mode, constreply_callback_t &reply_callback)

std::future<reply >	client_reply (const std::string &mode)

client &	client_setname (const std::string &name, constreply_callback_t &reply_callback)

std::future<reply >	client_setname (const std::string &name)

client &	cluster_addslots (const std::vector< std::string > &p_slots, constreply_callback_t &reply_callback)

std::future<reply >	cluster_addslots (const std::vector< std::string > &p_slots)

client &	cluster_count_failure_reports (const std::string &node_id, constreply_callback_t &reply_callback)

std::future<reply >	cluster_count_failure_reports (const std::string &node_id)

client &	cluster_countkeysinslot (const std::string &slot, constreply_callback_t &reply_callback)

std::future<reply >	cluster_countkeysinslot (const std::string &slot)

client &	cluster_delslots (const std::vector< std::string > &p_slots, constreply_callback_t &reply_callback)

std::future<reply >	cluster_delslots (const std::vector< std::string > &p_slots)

client &	cluster_failover (constreply_callback_t &reply_callback)

std::future<reply >	cluster_failover ()

client &	cluster_failover (const std::string &mode, constreply_callback_t &reply_callback)

std::future<reply >	cluster_failover (const std::string &mode)

client &	cluster_forget (const std::string &node_id, constreply_callback_t &reply_callback)

std::future<reply >	cluster_forget (const std::string &node_id)

client &	cluster_getkeysinslot (const std::string &slot, int count, constreply_callback_t &reply_callback)

std::future<reply >	cluster_getkeysinslot (const std::string &slot, int count)

client &	cluster_info (constreply_callback_t &reply_callback)

std::future<reply >	cluster_info ()

client &	cluster_keyslot (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	cluster_keyslot (const std::string &key)

client &	cluster_meet (const std::string &ip, int port, constreply_callback_t &reply_callback)

std::future<reply >	cluster_meet (const std::string &ip, int port)

client &	cluster_nodes (constreply_callback_t &reply_callback)

std::future<reply >	cluster_nodes ()

client &	cluster_replicate (const std::string &node_id, constreply_callback_t &reply_callback)

std::future<reply >	cluster_replicate (const std::string &node_id)

client &	cluster_reset (constreply_callback_t &reply_callback)

client &	cluster_reset (const std::string &mode, constreply_callback_t &reply_callback)

std::future<reply >	cluster_reset (const std::string &mode="soft")

client &	cluster_saveconfig (constreply_callback_t &reply_callback)

std::future<reply >	cluster_saveconfig ()

client &	cluster_set_config_epoch (const std::string &epoch, constreply_callback_t &reply_callback)

std::future<reply >	cluster_set_config_epoch (const std::string &epoch)

client &	cluster_setslot (const std::string &slot, const std::string &mode, constreply_callback_t &reply_callback)

std::future<reply >	cluster_setslot (const std::string &slot, const std::string &mode)

client &	cluster_setslot (const std::string &slot, const std::string &mode, const std::string &node_id, constreply_callback_t &reply_callback)

std::future<reply >	cluster_setslot (const std::string &slot, const std::string &mode, const std::string &node_id)

client &	cluster_slaves (const std::string &node_id, constreply_callback_t &reply_callback)

std::future<reply >	cluster_slaves (const std::string &node_id)

client &	cluster_slots (constreply_callback_t &reply_callback)

std::future<reply >	cluster_slots ()

client &	command (constreply_callback_t &reply_callback)

std::future<reply >	command ()

client &	command_count (constreply_callback_t &reply_callback)

std::future<reply >	command_count ()

client &	command_getkeys (constreply_callback_t &reply_callback)

std::future<reply >	command_getkeys ()

client &	command_info (const std::vector< std::string > &command_name, constreply_callback_t &reply_callback)

std::future<reply >	command_info (const std::vector< std::string > &command_name)

client &	config_get (const std::string &param, constreply_callback_t &reply_callback)

std::future<reply >	config_get (const std::string &param)

client &	config_rewrite (constreply_callback_t &reply_callback)

std::future<reply >	config_rewrite ()

client &	config_set (const std::string &param, const std::string &val, constreply_callback_t &reply_callback)

std::future<reply >	config_set (const std::string &param, const std::string &val)

client &	config_resetstat (constreply_callback_t &reply_callback)

std::future<reply >	config_resetstat ()

client &	dbsize (constreply_callback_t &reply_callback)

std::future<reply >	dbsize ()

client &	debug_object (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	debug_object (const std::string &key)

client &	debug_segfault (constreply_callback_t &reply_callback)

std::future<reply >	debug_segfault ()

client &	decr (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	decr (const std::string &key)

client &	decrby (const std::string &key, int val, constreply_callback_t &reply_callback)

std::future<reply >	decrby (const std::string &key, int val)

client &	del (const std::vector< std::string > &key, constreply_callback_t &reply_callback)

std::future<reply >	del (const std::vector< std::string > &key)

client &	discard (constreply_callback_t &reply_callback)

std::future<reply >	discard ()

client &	dump (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	dump (const std::string &key)

client &	echo (const std::string &msg, constreply_callback_t &reply_callback)

std::future<reply >	echo (const std::string &msg)

client &	eval (const std::string &script, int numkeys, const std::vector< std::string > &keys, const std::vector< std::string > &args, constreply_callback_t &reply_callback)

std::future<reply >	eval (const std::string &script, int numkeys, const std::vector< std::string > &keys, const std::vector< std::string > &args)

client &	evalsha (const std::string &sha1, int numkeys, const std::vector< std::string > &keys, const std::vector< std::string > &args, constreply_callback_t &reply_callback)

std::future<reply >	evalsha (const std::string &sha1, int numkeys, const std::vector< std::string > &keys, const std::vector< std::string > &args)

client &	exec (constreply_callback_t &reply_callback)

std::future<reply >	exec ()

client &	exists (const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	exists (const std::vector< std::string > &keys)

client &	expire (const std::string &key, int seconds, constreply_callback_t &reply_callback)

std::future<reply >	expire (const std::string &key, int seconds)

client &	expireat (const std::string &key, int timestamp, constreply_callback_t &reply_callback)

std::future<reply >	expireat (const std::string &key, int timestamp)

client &	flushall (constreply_callback_t &reply_callback)

std::future<reply >	flushall ()

client &	flushdb (constreply_callback_t &reply_callback)

std::future<reply >	flushdb ()

client &	geoadd (const std::string &key, const std::vector< std::tuple< std::string, std::string, std::string >> &long_lat_memb, constreply_callback_t &reply_callback)

std::future<reply >	geoadd (const std::string &key, const std::vector< std::tuple< std::string, std::string, std::string >> &long_lat_memb)

client &	geohash (const std::string &key, const std::vector< std::string > &members, constreply_callback_t &reply_callback)

std::future<reply >	geohash (const std::string &key, const std::vector< std::string > &members)

client &	geopos (const std::string &key, const std::vector< std::string > &members, constreply_callback_t &reply_callback)

std::future<reply >	geopos (const std::string &key, const std::vector< std::string > &members)

client &	geodist (const std::string &key, const std::string &member_1, const std::string &member_2, constreply_callback_t &reply_callback)

client &	geodist (const std::string &key, const std::string &member_1, const std::string &member_2, const std::string &unit, constreply_callback_t &reply_callback)

std::future<reply >	geodist (const std::string &key, const std::string &member_1, const std::string &member_2, const std::string &unit="m")

client &	georadius (const std::string &key, double longitude, double latitude, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, constreply_callback_t &reply_callback)

client &	georadius (const std::string &key, double longitude, double latitude, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, std::size_t count, constreply_callback_t &reply_callback)

client &	georadius (const std::string &key, double longitude, double latitude, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, const std::string &store_key, constreply_callback_t &reply_callback)

client &	georadius (const std::string &key, double longitude, double latitude, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, const std::string &store_key, const std::string &storedist_key, constreply_callback_t &reply_callback)

client &	georadius (const std::string &key, double longitude, double latitude, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, std::size_t count, const std::string &store_key, constreply_callback_t &reply_callback)

client &	georadius (const std::string &key, double longitude, double latitude, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, std::size_t count, const std::string &store_key, const std::string &storedist_key, constreply_callback_t &reply_callback)

std::future<reply >	georadius (const std::string &key, double longitude, double latitude, double radius,geo_unit unit, bool with_coord=false, bool with_dist=false, bool with_hash=false, bool asc_order=false, std::size_t count=0, const std::string &store_key="", const std::string &storedist_key="")

client &	georadiusbymember (const std::string &key, const std::string &member, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, constreply_callback_t &reply_callback)

client &	georadiusbymember (const std::string &key, const std::string &member, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, std::size_t count, constreply_callback_t &reply_callback)

client &	georadiusbymember (const std::string &key, const std::string &member, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, const std::string &store_key, constreply_callback_t &reply_callback)

client &	georadiusbymember (const std::string &key, const std::string &member, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, const std::string &store_key, const std::string &storedist_key, constreply_callback_t &reply_callback)

client &	georadiusbymember (const std::string &key, const std::string &member, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, std::size_t count, const std::string &store_key, constreply_callback_t &reply_callback)

client &	georadiusbymember (const std::string &key, const std::string &member, double radius,geo_unit unit, bool with_coord, bool with_dist, bool with_hash, bool asc_order, std::size_t count, const std::string &store_key, const std::string &storedist_key, constreply_callback_t &reply_callback)

std::future<reply >	georadiusbymember (const std::string &key, const std::string &member, double radius,geo_unit unit, bool with_coord=false, bool with_dist=false, bool with_hash=false, bool asc_order=false, std::size_t count=0, const std::string &store_key="", const std::string &storedist_key="")

client &	get (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	get (const std::string &key)

client &	getbit (const std::string &key, int offset, constreply_callback_t &reply_callback)

std::future<reply >	getbit (const std::string &key, int offset)

client &	getrange (const std::string &key, int start, int end, constreply_callback_t &reply_callback)

std::future<reply >	getrange (const std::string &key, int start, int end)

client &	getset (const std::string &key, const std::string &val, constreply_callback_t &reply_callback)

std::future<reply >	getset (const std::string &key, const std::string &val)

client &	hdel (const std::string &key, const std::vector< std::string > &fields, constreply_callback_t &reply_callback)

std::future<reply >	hdel (const std::string &key, const std::vector< std::string > &fields)

client &	hexists (const std::string &key, const std::string &field, constreply_callback_t &reply_callback)

std::future<reply >	hexists (const std::string &key, const std::string &field)

client &	hget (const std::string &key, const std::string &field, constreply_callback_t &reply_callback)

std::future<reply >	hget (const std::string &key, const std::string &field)

client &	hgetall (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	hgetall (const std::string &key)

client &	hincrby (const std::string &key, const std::string &field, int incr, constreply_callback_t &reply_callback)

std::future<reply >	hincrby (const std::string &key, const std::string &field, int incr)

client &	hincrbyfloat (const std::string &key, const std::string &field, float incr, constreply_callback_t &reply_callback)

std::future<reply >	hincrbyfloat (const std::string &key, const std::string &field, float incr)

client &	hkeys (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	hkeys (const std::string &key)

client &	hlen (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	hlen (const std::string &key)

client &	hmget (const std::string &key, const std::vector< std::string > &fields, constreply_callback_t &reply_callback)

std::future<reply >	hmget (const std::string &key, const std::vector< std::string > &fields)

client &	hmset (const std::string &key, const std::vector< std::pair< std::string, std::string >> &field_val, constreply_callback_t &reply_callback)

std::future<reply >	hmset (const std::string &key, const std::vector< std::pair< std::string, std::string >> &field_val)

client &	hscan (const std::string &key, std::size_t cursor, constreply_callback_t &reply_callback)

std::future<reply >	hscan (const std::string &key, std::size_t cursor)

client &	hscan (const std::string &key, std::size_t cursor, const std::string &pattern, constreply_callback_t &reply_callback)

std::future<reply >	hscan (const std::string &key, std::size_t cursor, const std::string &pattern)

client &	hscan (const std::string &key, std::size_t cursor, std::size_t count, constreply_callback_t &reply_callback)

std::future<reply >	hscan (const std::string &key, std::size_t cursor, std::size_t count)

client &	hscan (const std::string &key, std::size_t cursor, const std::string &pattern, std::size_t count, constreply_callback_t &reply_callback)

std::future<reply >	hscan (const std::string &key, std::size_t cursor, const std::string &pattern, std::size_t count)

client &	hset (const std::string &key, const std::string &field, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	hset (const std::string &key, const std::string &field, const std::string &value)

client &	hsetnx (const std::string &key, const std::string &field, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	hsetnx (const std::string &key, const std::string &field, const std::string &value)

client &	hstrlen (const std::string &key, const std::string &field, constreply_callback_t &reply_callback)

std::future<reply >	hstrlen (const std::string &key, const std::string &field)

client &	hvals (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	hvals (const std::string &key)

client &	incr (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	incr (const std::string &key)

client &	incrby (const std::string &key, int incr, constreply_callback_t &reply_callback)

std::future<reply >	incrby (const std::string &key, int incr)

client &	incrbyfloat (const std::string &key, float incr, constreply_callback_t &reply_callback)

std::future<reply >	incrbyfloat (const std::string &key, float incr)

client &	info (constreply_callback_t &reply_callback)

client &	info (const std::string &section, constreply_callback_t &reply_callback)

std::future<reply >	info (const std::string &section="default")

client &	keys (const std::string &pattern, constreply_callback_t &reply_callback)

std::future<reply >	keys (const std::string &pattern)

client &	lastsave (constreply_callback_t &reply_callback)

std::future<reply >	lastsave ()

client &	lindex (const std::string &key, int index, constreply_callback_t &reply_callback)

std::future<reply >	lindex (const std::string &key, int index)

client &	linsert (const std::string &key, const std::string &before_after, const std::string &pivot, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	linsert (const std::string &key, const std::string &before_after, const std::string &pivot, const std::string &value)

client &	llen (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	llen (const std::string &key)

client &	lpop (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	lpop (const std::string &key)

client &	lpush (const std::string &key, const std::vector< std::string > &values, constreply_callback_t &reply_callback)

std::future<reply >	lpush (const std::string &key, const std::vector< std::string > &values)

client &	lpushx (const std::string &key, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	lpushx (const std::string &key, const std::string &value)

client &	lrange (const std::string &key, int start, int stop, constreply_callback_t &reply_callback)

std::future<reply >	lrange (const std::string &key, int start, int stop)

client &	lrem (const std::string &key, int count, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	lrem (const std::string &key, int count, const std::string &value)

client &	lset (const std::string &key, int index, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	lset (const std::string &key, int index, const std::string &value)

client &	ltrim (const std::string &key, int start, int stop, constreply_callback_t &reply_callback)

std::future<reply >	ltrim (const std::string &key, int start, int stop)

client &	mget (const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	mget (const std::vector< std::string > &keys)

client &	migrate (const std::string &host, int port, const std::string &key, const std::string &dest_db, int timeout, constreply_callback_t &reply_callback)

client &	migrate (const std::string &host, int port, const std::string &key, const std::string &dest_db, int timeout, bool copy, bool replace, const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	migrate (const std::string &host, int port, const std::string &key, const std::string &dest_db, int timeout, bool copy=false, bool replace=false, const std::vector< std::string > &keys={})

client &	monitor (constreply_callback_t &reply_callback)

std::future<reply >	monitor ()

client &	move (const std::string &key, const std::string &db, constreply_callback_t &reply_callback)

std::future<reply >	move (const std::string &key, const std::string &db)

client &	mset (const std::vector< std::pair< std::string, std::string >> &key_vals, constreply_callback_t &reply_callback)

std::future<reply >	mset (const std::vector< std::pair< std::string, std::string >> &key_vals)

client &	msetnx (const std::vector< std::pair< std::string, std::string >> &key_vals, constreply_callback_t &reply_callback)

std::future<reply >	msetnx (const std::vector< std::pair< std::string, std::string >> &key_vals)

client &	multi (constreply_callback_t &reply_callback)

std::future<reply >	multi ()

client &	object (const std::string &subcommand, const std::vector< std::string > &args, constreply_callback_t &reply_callback)

std::future<reply >	object (const std::string &subcommand, const std::vector< std::string > &args)

client &	persist (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	persist (const std::string &key)

client &	pexpire (const std::string &key, int milliseconds, constreply_callback_t &reply_callback)

std::future<reply >	pexpire (const std::string &key, int milliseconds)

client &	pexpireat (const std::string &key, int milliseconds_timestamp, constreply_callback_t &reply_callback)

std::future<reply >	pexpireat (const std::string &key, int milliseconds_timestamp)

client &	pfadd (const std::string &key, const std::vector< std::string > &elements, constreply_callback_t &reply_callback)

std::future<reply >	pfadd (const std::string &key, const std::vector< std::string > &elements)

client &	pfcount (const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	pfcount (const std::vector< std::string > &keys)

client &	pfmerge (const std::string &destkey, const std::vector< std::string > &sourcekeys, constreply_callback_t &reply_callback)

std::future<reply >	pfmerge (const std::string &destkey, const std::vector< std::string > &sourcekeys)

client &	ping (constreply_callback_t &reply_callback)

std::future<reply >	ping ()

client &	ping (const std::string &message, constreply_callback_t &reply_callback)

std::future<reply >	ping (const std::string &message)

client &	psetex (const std::string &key, int milliseconds, const std::string &val, constreply_callback_t &reply_callback)

std::future<reply >	psetex (const std::string &key, int milliseconds, const std::string &val)

client &	publish (const std::string &channel, const std::string &message, constreply_callback_t &reply_callback)

std::future<reply >	publish (const std::string &channel, const std::string &message)

client &	pubsub (const std::string &subcommand, const std::vector< std::string > &args, constreply_callback_t &reply_callback)

std::future<reply >	pubsub (const std::string &subcommand, const std::vector< std::string > &args)

client &	pttl (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	pttl (const std::string &key)

client &	quit (constreply_callback_t &reply_callback)

std::future<reply >	quit ()

client &	randomkey (constreply_callback_t &reply_callback)

std::future<reply >	randomkey ()

client &	readonly (constreply_callback_t &reply_callback)

std::future<reply >	readonly ()

client &	readwrite (constreply_callback_t &reply_callback)

std::future<reply >	readwrite ()

client &	rename (const std::string &key, const std::string &newkey, constreply_callback_t &reply_callback)

std::future<reply >	rename (const std::string &key, const std::string &newkey)

client &	renamenx (const std::string &key, const std::string &newkey, constreply_callback_t &reply_callback)

std::future<reply >	renamenx (const std::string &key, const std::string &newkey)

client &	restore (const std::string &key, int ttl, const std::string &serialized_value, constreply_callback_t &reply_callback)

std::future<reply >	restore (const std::string &key, int ttl, const std::string &serialized_value)

client &	restore (const std::string &key, int ttl, const std::string &serialized_value, const std::string &replace, constreply_callback_t &reply_callback)

std::future<reply >	restore (const std::string &key, int ttl, const std::string &serialized_value, const std::string &replace)

client &	role (constreply_callback_t &reply_callback)

std::future<reply >	role ()

client &	rpop (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	rpop (const std::string &key)

client &	rpoplpush (const std::string &source, const std::string &destination, constreply_callback_t &reply_callback)

std::future<reply >	rpoplpush (const std::string &src, const std::string &dst)

client &	rpush (const std::string &key, const std::vector< std::string > &values, constreply_callback_t &reply_callback)

std::future<reply >	rpush (const std::string &key, const std::vector< std::string > &values)

client &	rpushx (const std::string &key, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	rpushx (const std::string &key, const std::string &value)

client &	sadd (const std::string &key, const std::vector< std::string > &members, constreply_callback_t &reply_callback)

std::future<reply >	sadd (const std::string &key, const std::vector< std::string > &members)

client &	save (constreply_callback_t &reply_callback)

std::future<reply >	save ()

client &	scan (std::size_t cursor, constreply_callback_t &reply_callback)

std::future<reply >	scan (std::size_t cursor)

client &	scan (std::size_t cursor, const std::string &pattern, constreply_callback_t &reply_callback)

std::future<reply >	scan (std::size_t cursor, const std::string &pattern)

client &	scan (std::size_t cursor, std::size_t count, constreply_callback_t &reply_callback)

std::future<reply >	scan (std::size_t cursor, std::size_t count)

client &	scan (std::size_t cursor, const std::string &pattern, std::size_t count, constreply_callback_t &reply_callback)

std::future<reply >	scan (std::size_t cursor, const std::string &pattern, std::size_t count)

client &	scard (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	scard (const std::string &key)

client &	script_debug (const std::string &mode, constreply_callback_t &reply_callback)

std::future<reply >	script_debug (const std::string &mode)

client &	script_exists (const std::vector< std::string > &scripts, constreply_callback_t &reply_callback)

std::future<reply >	script_exists (const std::vector< std::string > &scripts)

client &	script_flush (constreply_callback_t &reply_callback)

std::future<reply >	script_flush ()

client &	script_kill (constreply_callback_t &reply_callback)

std::future<reply >	script_kill ()

client &	script_load (const std::string &script, constreply_callback_t &reply_callback)

std::future<reply >	script_load (const std::string &script)

client &	sdiff (const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	sdiff (const std::vector< std::string > &keys)

client &	sdiffstore (const std::string &destination, const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	sdiffstore (const std::string &dst, const std::vector< std::string > &keys)

client &	select (int index, constreply_callback_t &reply_callback)

std::future<reply >	select (int index)

client &	set (const std::string &key, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	set (const std::string &key, const std::string &value)

client &	set_advanced (const std::string &key, const std::string &value, constreply_callback_t &reply_callback)

client &	set_advanced (const std::string &key, const std::string &value, bool ex, int ex_sec, bool px, int px_milli, bool nx, bool xx, constreply_callback_t &reply_callback)

std::future<reply >	set_advanced (const std::string &key, const std::string &value, bool ex=false, int ex_sec=0, bool px=false, int px_milli=0, bool nx=false, bool xx=false)

client &	setbit_ (const std::string &key, int offset, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	setbit_ (const std::string &key, int offset, const std::string &value)

client &	setex (const std::string &key, int seconds, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	setex (const std::string &key, int seconds, const std::string &value)

client &	setnx (const std::string &key, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	setnx (const std::string &key, const std::string &value)

client &	setrange (const std::string &key, int offset, const std::string &value, constreply_callback_t &reply_callback)

std::future<reply >	setrange (const std::string &key, int offset, const std::string &value)

client &	shutdown (constreply_callback_t &reply_callback)

std::future<reply >	shutdown ()

client &	shutdown (const std::string &save, constreply_callback_t &reply_callback)

std::future<reply >	shutdown (const std::string &save)

client &	sinter (const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	sinter (const std::vector< std::string > &keys)

client &	sinterstore (const std::string &destination, const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	sinterstore (const std::string &dst, const std::vector< std::string > &keys)

client &	sismember (const std::string &key, const std::string &member, constreply_callback_t &reply_callback)

std::future<reply >	sismember (const std::string &key, const std::string &member)

client &	slaveof (const std::string &host, int port, constreply_callback_t &reply_callback)

std::future<reply >	slaveof (const std::string &host, int port)

client &	slowlog (const std::string subcommand, constreply_callback_t &reply_callback)

std::future<reply >	slowlog (const std::string &subcommand)

client &	slowlog (const std::string subcommand, const std::string &argument, constreply_callback_t &reply_callback)

std::future<reply >	slowlog (const std::string &subcommand, const std::string &argument)

client &	smembers (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	smembers (const std::string &key)

client &	smove (const std::string &source, const std::string &destination, const std::string &member, constreply_callback_t &reply_callback)

std::future<reply >	smove (const std::string &src, const std::string &dst, const std::string &member)

client &	sort (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	sort (const std::string &key)

client &	sort (const std::string &key, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, constreply_callback_t &reply_callback)

std::future<reply >	sort (const std::string &key, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha)

client &	sort (const std::string &key, std::size_t offset, std::size_t count, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, constreply_callback_t &reply_callback)

std::future<reply >	sort (const std::string &key, std::size_t offset, std::size_t count, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha)

client &	sort (const std::string &key, const std::string &by_pattern, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, constreply_callback_t &reply_callback)

std::future<reply >	sort (const std::string &key, const std::string &by_pattern, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha)

client &	sort (const std::string &key, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, const std::string &store_dest, constreply_callback_t &reply_callback)

std::future<reply >	sort (const std::string &key, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, const std::string &store_dest)

client &	sort (const std::string &key, std::size_t offset, std::size_t count, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, const std::string &store_dest, constreply_callback_t &reply_callback)

std::future<reply >	sort (const std::string &key, std::size_t offset, std::size_t count, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, const std::string &store_dest)

client &	sort (const std::string &key, const std::string &by_pattern, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, const std::string &store_dest, constreply_callback_t &reply_callback)

std::future<reply >	sort (const std::string &key, const std::string &by_pattern, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, const std::string &store_dest)

client &	sort (const std::string &key, const std::string &by_pattern, std::size_t offset, std::size_t count, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, constreply_callback_t &reply_callback)

std::future<reply >	sort (const std::string &key, const std::string &by_pattern, std::size_t offset, std::size_t count, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha)

client &	sort (const std::string &key, const std::string &by_pattern, std::size_t offset, std::size_t count, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, const std::string &store_dest, constreply_callback_t &reply_callback)

std::future<reply >	sort (const std::string &key, const std::string &by_pattern, std::size_t offset, std::size_t count, const std::vector< std::string > &get_patterns, bool asc_order, bool alpha, const std::string &store_dest)

client &	spop (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	spop (const std::string &key)

client &	spop (const std::string &key, int count, constreply_callback_t &reply_callback)

std::future<reply >	spop (const std::string &key, int count)

client &	srandmember (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	srandmember (const std::string &key)

client &	srandmember (const std::string &key, int count, constreply_callback_t &reply_callback)

std::future<reply >	srandmember (const std::string &key, int count)

client &	srem (const std::string &key, const std::vector< std::string > &members, constreply_callback_t &reply_callback)

std::future<reply >	srem (const std::string &key, const std::vector< std::string > &members)

client &	sscan (const std::string &key, std::size_t cursor, constreply_callback_t &reply_callback)

std::future<reply >	sscan (const std::string &key, std::size_t cursor)

client &	sscan (const std::string &key, std::size_t cursor, const std::string &pattern, constreply_callback_t &reply_callback)

std::future<reply >	sscan (const std::string &key, std::size_t cursor, const std::string &pattern)

client &	sscan (const std::string &key, std::size_t cursor, std::size_t count, constreply_callback_t &reply_callback)

std::future<reply >	sscan (const std::string &key, std::size_t cursor, std::size_t count)

client &	sscan (const std::string &key, std::size_t cursor, const std::string &pattern, std::size_t count, constreply_callback_t &reply_callback)

std::future<reply >	sscan (const std::string &key, std::size_t cursor, const std::string &pattern, std::size_t count)

client &	strlen (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	strlen (const std::string &key)

client &	sunion (const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	sunion (const std::vector< std::string > &keys)

client &	sunionstore (const std::string &destination, const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	sunionstore (const std::string &dst, const std::vector< std::string > &keys)

client &	sync (constreply_callback_t &reply_callback)

std::future<reply >	sync ()

client &	time (constreply_callback_t &reply_callback)

std::future<reply >	time ()

client &	ttl (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	ttl (const std::string &key)

client &	type (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	type (const std::string &key)

client &	unwatch (constreply_callback_t &reply_callback)

std::future<reply >	unwatch ()

client &	wait (int numslaves, int timeout, constreply_callback_t &reply_callback)

std::future<reply >	wait (int numslaves, int timeout)

client &	watch (const std::vector< std::string > &keys, constreply_callback_t &reply_callback)

std::future<reply >	watch (const std::vector< std::string > &keys)

client &	zadd (const std::string &key, const std::vector< std::string > &options, const std::multimap< std::string, std::string > &score_members, constreply_callback_t &reply_callback)

std::future<reply >	zadd (const std::string &key, const std::vector< std::string > &options, const std::multimap< std::string, std::string > &score_members)

client &	zcard (const std::string &key, constreply_callback_t &reply_callback)

std::future<reply >	zcard (const std::string &key)

client &	zcount (const std::string &key, int min, int max, constreply_callback_t &reply_callback)

std::future<reply >	zcount (const std::string &key, int min, int max)

client &	zcount (const std::string &key, double min, double max, constreply_callback_t &reply_callback)

std::future<reply >	zcount (const std::string &key, double min, double max)

client &	zcount (const std::string &key, const std::string &min, const std::string &max, constreply_callback_t &reply_callback)

std::future<reply >	zcount (const std::string &key, const std::string &min, const std::string &max)

client &	zincrby (const std::string &key, int incr, const std::string &member, constreply_callback_t &reply_callback)

std::future<reply >	zincrby (const std::string &key, int incr, const std::string &member)

client &	zincrby (const std::string &key, double incr, const std::string &member, constreply_callback_t &reply_callback)

std::future<reply >	zincrby (const std::string &key, double incr, const std::string &member)

client &	zincrby (const std::string &key, const std::string &incr, const std::string &member, constreply_callback_t &reply_callback)

std::future<reply >	zincrby (const std::string &key, const std::string &incr, const std::string &member)

client &	zinterstore (const std::string &destination, std::size_t numkeys, const std::vector< std::string > &keys, const std::vector< std::size_t > weights,aggregate_method method, constreply_callback_t &reply_callback)

std::future<reply >	zinterstore (const std::string &destination, std::size_t numkeys, const std::vector< std::string > &keys, const std::vector< std::size_t > weights,aggregate_method method)

client &	zlexcount (const std::string &key, int min, int max, constreply_callback_t &reply_callback)

std::future<reply >	zlexcount (const std::string &key, int min, int max)

client &	zlexcount (const std::string &key, double min, double max, constreply_callback_t &reply_callback)

std::future<reply >	zlexcount (const std::string &key, double min, double max)

client &	zlexcount (const std::string &key, const std::string &min, const std::string &max, constreply_callback_t &reply_callback)

std::future<reply >	zlexcount (const std::string &key, const std::string &min, const std::string &max)

client &	zrange (const std::string &key, int start, int stop, constreply_callback_t &reply_callback)

client &	zrange (const std::string &key, int start, int stop, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrange (const std::string &key, int start, int stop, bool withscores=false)

client &	zrange (const std::string &key, double start, double stop, constreply_callback_t &reply_callback)

client &	zrange (const std::string &key, double start, double stop, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrange (const std::string &key, double start, double stop, bool withscores=false)

client &	zrange (const std::string &key, const std::string &start, const std::string &stop, constreply_callback_t &reply_callback)

client &	zrange (const std::string &key, const std::string &start, const std::string &stop, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrange (const std::string &key, const std::string &start, const std::string &stop, bool withscores=false)

client &	zrangebylex (const std::string &key, int min, int max, constreply_callback_t &reply_callback)

client &	zrangebylex (const std::string &key, int min, int max, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebylex (const std::string &key, int min, int max, bool withscores=false)

client &	zrangebylex (const std::string &key, double min, double max, constreply_callback_t &reply_callback)

client &	zrangebylex (const std::string &key, double min, double max, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebylex (const std::string &key, double min, double max, bool withscores=false)

client &	zrangebylex (const std::string &key, const std::string &min, const std::string &max, constreply_callback_t &reply_callback)

client &	zrangebylex (const std::string &key, const std::string &min, const std::string &max, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebylex (const std::string &key, const std::string &min, const std::string &max, bool withscores=false)

client &	zrangebylex (const std::string &key, int min, int max, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrangebylex (const std::string &key, int min, int max, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebylex (const std::string &key, int min, int max, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrangebylex (const std::string &key, double min, double max, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrangebylex (const std::string &key, double min, double max, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebylex (const std::string &key, double min, double max, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrangebylex (const std::string &key, const std::string &min, const std::string &max, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrangebylex (const std::string &key, const std::string &min, const std::string &max, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebylex (const std::string &key, const std::string &min, const std::string &max, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrangebyscore (const std::string &key, int min, int max, constreply_callback_t &reply_callback)

client &	zrangebyscore (const std::string &key, int min, int max, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebyscore (const std::string &key, int min, int max, bool withscores=false)

client &	zrangebyscore (const std::string &key, double min, double max, constreply_callback_t &reply_callback)

client &	zrangebyscore (const std::string &key, double min, double max, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebyscore (const std::string &key, double min, double max, bool withscores=false)

client &	zrangebyscore (const std::string &key, const std::string &min, const std::string &max, constreply_callback_t &reply_callback)

client &	zrangebyscore (const std::string &key, const std::string &min, const std::string &max, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebyscore (const std::string &key, const std::string &min, const std::string &max, bool withscores=false)

client &	zrangebyscore (const std::string &key, int min, int max, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrangebyscore (const std::string &key, int min, int max, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebyscore (const std::string &key, int min, int max, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrangebyscore (const std::string &key, double min, double max, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrangebyscore (const std::string &key, double min, double max, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebyscore (const std::string &key, double min, double max, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrangebyscore (const std::string &key, const std::string &min, const std::string &max, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrangebyscore (const std::string &key, const std::string &min, const std::string &max, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrangebyscore (const std::string &key, const std::string &min, const std::string &max, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrank (const std::string &key, const std::string &member, constreply_callback_t &reply_callback)

std::future<reply >	zrank (const std::string &key, const std::string &member)

client &	zrem (const std::string &key, const std::vector< std::string > &members, constreply_callback_t &reply_callback)

std::future<reply >	zrem (const std::string &key, const std::vector< std::string > &members)

client &	zremrangebylex (const std::string &key, int min, int max, constreply_callback_t &reply_callback)

std::future<reply >	zremrangebylex (const std::string &key, int min, int max)

client &	zremrangebylex (const std::string &key, double min, double max, constreply_callback_t &reply_callback)

std::future<reply >	zremrangebylex (const std::string &key, double min, double max)

client &	zremrangebylex (const std::string &key, const std::string &min, const std::string &max, constreply_callback_t &reply_callback)

std::future<reply >	zremrangebylex (const std::string &key, const std::string &min, const std::string &max)

client &	zremrangebyrank (const std::string &key, int start, int stop, constreply_callback_t &reply_callback)

std::future<reply >	zremrangebyrank (const std::string &key, int start, int stop)

client &	zremrangebyrank (const std::string &key, double start, double stop, constreply_callback_t &reply_callback)

std::future<reply >	zremrangebyrank (const std::string &key, double start, double stop)

client &	zremrangebyrank (const std::string &key, const std::string &start, const std::string &stop, constreply_callback_t &reply_callback)

std::future<reply >	zremrangebyrank (const std::string &key, const std::string &start, const std::string &stop)

client &	zremrangebyscore (const std::string &key, int min, int max, constreply_callback_t &reply_callback)

std::future<reply >	zremrangebyscore (const std::string &key, int min, int max)

client &	zremrangebyscore (const std::string &key, double min, double max, constreply_callback_t &reply_callback)

std::future<reply >	zremrangebyscore (const std::string &key, double min, double max)

client &	zremrangebyscore (const std::string &key, const std::string &min, const std::string &max, constreply_callback_t &reply_callback)

std::future<reply >	zremrangebyscore (const std::string &key, const std::string &min, const std::string &max)

client &	zrevrange (const std::string &key, int start, int stop, constreply_callback_t &reply_callback)

client &	zrevrange (const std::string &key, int start, int stop, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrange (const std::string &key, int start, int stop, bool withscores=false)

client &	zrevrange (const std::string &key, double start, double stop, constreply_callback_t &reply_callback)

client &	zrevrange (const std::string &key, double start, double stop, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrange (const std::string &key, double start, double stop, bool withscores=false)

client &	zrevrange (const std::string &key, const std::string &start, const std::string &stop, constreply_callback_t &reply_callback)

client &	zrevrange (const std::string &key, const std::string &start, const std::string &stop, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrange (const std::string &key, const std::string &start, const std::string &stop, bool withscores=false)

client &	zrevrangebylex (const std::string &key, int max, int min, constreply_callback_t &reply_callback)

client &	zrevrangebylex (const std::string &key, int max, int min, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebylex (const std::string &key, int max, int min, bool withscores=false)

client &	zrevrangebylex (const std::string &key, double max, double min, constreply_callback_t &reply_callback)

client &	zrevrangebylex (const std::string &key, double max, double min, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebylex (const std::string &key, double max, double min, bool withscores=false)

client &	zrevrangebylex (const std::string &key, const std::string &max, const std::string &min, constreply_callback_t &reply_callback)

client &	zrevrangebylex (const std::string &key, const std::string &max, const std::string &min, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebylex (const std::string &key, const std::string &max, const std::string &min, bool withscores=false)

client &	zrevrangebylex (const std::string &key, int max, int min, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrevrangebylex (const std::string &key, int max, int min, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebylex (const std::string &key, int max, int min, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrevrangebylex (const std::string &key, double max, double min, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrevrangebylex (const std::string &key, double max, double min, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebylex (const std::string &key, double max, double min, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrevrangebylex (const std::string &key, const std::string &max, const std::string &min, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrevrangebylex (const std::string &key, const std::string &max, const std::string &min, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebylex (const std::string &key, const std::string &max, const std::string &min, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrevrangebyscore (const std::string &key, int max, int min, constreply_callback_t &reply_callback)

client &	zrevrangebyscore (const std::string &key, int max, int min, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebyscore (const std::string &key, int max, int min, bool withscores=false)

client &	zrevrangebyscore (const std::string &key, double max, double min, constreply_callback_t &reply_callback)

client &	zrevrangebyscore (const std::string &key, double max, double min, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebyscore (const std::string &key, double max, double min, bool withscores=false)

client &	zrevrangebyscore (const std::string &key, const std::string &max, const std::string &min, constreply_callback_t &reply_callback)

client &	zrevrangebyscore (const std::string &key, const std::string &max, const std::string &min, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebyscore (const std::string &key, const std::string &max, const std::string &min, bool withscores=false)

client &	zrevrangebyscore (const std::string &key, int max, int min, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrevrangebyscore (const std::string &key, int max, int min, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebyscore (const std::string &key, int max, int min, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrevrangebyscore (const std::string &key, double max, double min, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrevrangebyscore (const std::string &key, double max, double min, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebyscore (const std::string &key, double max, double min, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrevrangebyscore (const std::string &key, const std::string &max, const std::string &min, std::size_t offset, std::size_t count, constreply_callback_t &reply_callback)

client &	zrevrangebyscore (const std::string &key, const std::string &max, const std::string &min, std::size_t offset, std::size_t count, bool withscores, constreply_callback_t &reply_callback)

std::future<reply >	zrevrangebyscore (const std::string &key, const std::string &max, const std::string &min, std::size_t offset, std::size_t count, bool withscores=false)

client &	zrevrank (const std::string &key, const std::string &member, constreply_callback_t &reply_callback)

std::future<reply >	zrevrank (const std::string &key, const std::string &member)

client &	zscan (const std::string &key, std::size_t cursor, constreply_callback_t &reply_callback)

std::future<reply >	zscan (const std::string &key, std::size_t cursor)

client &	zscan (const std::string &key, std::size_t cursor, const std::string &pattern, constreply_callback_t &reply_callback)

std::future<reply >	zscan (const std::string &key, std::size_t cursor, const std::string &pattern)

client &	zscan (const std::string &key, std::size_t cursor, std::size_t count, constreply_callback_t &reply_callback)

std::future<reply >	zscan (const std::string &key, std::size_t cursor, std::size_t count)

client &	zscan (const std::string &key, std::size_t cursor, const std::string &pattern, std::size_t count, constreply_callback_t &reply_callback)

std::future<reply >	zscan (const std::string &key, std::size_t cursor, const std::string &pattern, std::size_t count)

client &	zscore (const std::string &key, const std::string &member, constreply_callback_t &reply_callback)

std::future<reply >	zscore (const std::string &key, const std::string &member)

client &	zunionstore (const std::string &destination, std::size_t numkeys, const std::vector< std::string > &keys, const std::vector< std::size_t > weights,aggregate_method method, constreply_callback_t &reply_callback)

std::future<reply >	zunionstore (const std::string &destination, std::size_t numkeys, const std::vector< std::string > &keys, const std::vector< std::size_t > weights,aggregate_method method)

template<typename T, typename... Ts>
client &	client_kill (const T &arg, const Ts &... args)

Detailed Description

cpp_redis::client is the class providing communication with a Redis server. It is meant to be used for sending commands to the remote server and receiving its replies. The client support asynchronous requests, as well as synchronous ones. Moreover, commands pipelining is supported.

Member Typedef Documentation

◆ connect_callback_t

typedef std::function<void(const std::string& host, std::size_t port,connect_state status)>cpp_redis::client::connect_callback_t

connect handler, called whenever a new connection even occurred

◆ reply_callback_t

typedef std::function<void(reply&)>cpp_redis::client::reply_callback_t

reply callback called whenever a reply is received takes as parameter the received reply

Member Enumeration Documentation

◆ aggregate_method

enumcpp_redis::client::aggregate_method

strong

aggregate method to be used for some commands (like zunionstore) these match the aggregate methods supported by redis use server_default if you are not willing to specify this parameter and let the server defaults

◆ bitfield_operation_type

enumcpp_redis::client::bitfield_operation_type

strong

bitfield operation type to be used for some commands (like bitfield) these match the bitfield operation types supported by redis-server

◆ client_type

enumcpp_redis::client::client_type

strong

client type used for client kill

◆ connect_state

enumcpp_redis::client::connect_state

strong

high availability (re)connection states

dropped: connection has dropped
start: attemp of connection has started
sleeping: sleep between two attemps
ok: connected
failed: failed to connect
lookup failed: failed to retrieve master sentinel
stopped: stop to try to reconnect

◆ geo_unit

enumcpp_redis::client::geo_unit

strong

geographic unit to be used for some commands (like georadius) these match the geo units supported by redis-server

◆ overflow_type

enumcpp_redis::client::overflow_type

strong

overflow type to be used for some commands (like bitfield) these match the overflow types supported by redis-server use server_default if you are not willing to specify this parameter and let the server defaults

Constructor & Destructor Documentation

◆ client()

cpp_redis::client::client

(

const std::shared_ptr<network::tcp_client_iface > &

tcp_client

)

explicit

custom ctor to specify custom tcp_client

Parameters

tcp_client

tcp client to be used for network communications

Member Function Documentation

◆ add_sentinel()

void cpp_redis::client::add_sentinel	(	const std::string &	host,
		std::size_t	port,
		std::uint32_t	timeout_msecs =`0`
	)

add a sentinel definition. Required forconnect() or get_master_addr_by_name() when autoconnect is enabled.

Parameters

host	sentinel host
port	sentinel port
timeout_msecs	maximum time to connect

◆ aggregate_method_to_string()

std::string cpp_redis::client::aggregate_method_to_string

(

aggregate_method

method

)

const

convert an aggregate_method enum to its equivalent redis-server string

Parameters

method

aggregate_method to convert

Returns: conversion

◆ bitfield_operation_type_to_string()

std::string cpp_redis::client::bitfield_operation_type_to_string

(

bitfield_operation_type

operation

)

const

convert a bitfield operation type to its equivalent redis-server string

Parameters

operation

operation type to convert

Returns: conversion

◆ cancel_reconnect()

void cpp_redis::client::cancel_reconnect

(

void

)

stop any reconnect in progress

◆ clear_sentinels()

void cpp_redis::client::clear_sentinels

(

void

)

clear all existing sentinels.

◆ client_kill()

template<typename T , typename... Ts>

client & cpp_redis::client::client_kill	(	const std::string &	host,
		int	port,
		const T &	arg,
		const Ts &...	args
	)

inline

If we have other type than lambda, then it's a filter

◆ client_kill_future()

template<typename T , typename... Ts>

std::future<reply > cpp_redis::client::client_kill_future	(	const T	arg,
		const Ts...	args
	)

gcc 4.8 doesn't handle variadic template capture arguments (appears in 4.9) so std::bind should capture all arguments because of the compiler.

◆ commit()

client& cpp_redis::client::commit

(

void

)

Sends all the commands that have been stored by callingsend() since the lastcommit() call to the redis server. That is, pipelining is supported in a very simple and efficient way:client.send(...).send(...).send(...).commit() will send the 3 commands at once (instead of sending 3 network requests, one for each command, as it would have been done without pipelining). Pipelined commands are always removed from the buffer, even in the case of an error (for example, calling commit while the client is not connected, something that throws an exception).commit() works asynchronously: it returns immediately after sending the queued requests and replies are processed asynchronously.

Please note that, whilecommit() can safely be called from inside a reply callback, callingsync_commit() from inside a reply callback is not permitted and will lead to undefined behavior, mostly deadlock.

◆ connect()[1/2]

void cpp_redis::client::connect	(	const std::string &	host =`"127.0.0.1"`,
		std::size_t	port =`6379`,
		constconnect_callback_t &	connect_callback =`nullptr`,
		std::uint32_t	timeout_msecs =`0`,
		std::int32_t	max_reconnects =`0`,
		std::uint32_t	reconnect_interval_msecs =`0`
	)

Connect to redis server

Parameters

host	host to be connected to
port	port to be connected to
connect_callback	connect handler to be called on connect events (may be null)
timeout_msecs	maximum time to connect
max_reconnects	maximum attemps of reconnection if connection dropped
reconnect_interval_msecs	time between two attemps of reconnection

◆ connect()[2/2]

void cpp_redis::client::connect	(	const std::string &	name,
		constconnect_callback_t &	connect_callback =`nullptr`,
		std::uint32_t	timeout_msecs =`0`,
		std::int32_t	max_reconnects =`0`,
		std::uint32_t	reconnect_interval_msecs =`0`
	)

Connect to redis server

Parameters

name	sentinel name
connect_callback	connect handler to be called on connect events (may be null)
timeout_msecs	maximum time to connect
max_reconnects	maximum attemps of reconnection if connection dropped
reconnect_interval_msecs	time between two attemps of reconnection

◆ disconnect()

void cpp_redis::client::disconnect ( bool wait_for_removal =false )

disconnect from redis server

Parameters

wait_for_removal

when sets to true, disconnect blocks until the underlying TCP client has been effectively removed from the io_service and that all the underlying callbacks have completed.

◆ geo_unit_to_string()

std::string cpp_redis::client::geo_unit_to_string

(

geo_unit

unit

)

const

convert a geo unit to its equivalent redis-server string

Parameters

unit	geo_unit to convert

Returns: conversion

◆ get_sentinel()[1/2]

constsentinel& cpp_redis::client::get_sentinel

(

void

)

const

retrieve sentinel for current client

Returns: sentinel associated to current client

◆ get_sentinel()[2/2]

sentinel& cpp_redis::client::get_sentinel

(

void

)

retrieve sentinel for current client non-const version

Returns: sentinel associated to current client

◆ is_connected()

bool cpp_redis::client::is_connected

(

void

)

const

Returns: whether we are connected to the redis server

◆ is_reconnecting()

bool cpp_redis::client::is_reconnecting

(

void

)

const

Returns: whether an attemp to reconnect is in progress

◆ overflow_type_to_string()

std::string cpp_redis::client::overflow_type_to_string

(

overflow_type

type

)

const

convert an overflow type to its equivalent redis-server string

Parameters

type	overflow type to convert

Returns: conversion

◆ send()[1/2]

client& cpp_redis::client::send	(	const std::vector< std::string > &	redis_cmd,
		constreply_callback_t &	callback
	)

send the given command the command is actually pipelined and only buffered, so nothing is sent to the network please callcommit() /sync_commit() to flush the buffer

Parameters

redis_cmd	command to be sent
callback	callback to be called on received reply

Returns: current instance

◆ send()[2/2]

std::future<reply> cpp_redis::client::send

(

const std::vector< std::string > &

redis_cmd

)

same as the other send method but future based: does not take any callback and return an std:;future to handle the reply

Parameters

redis_cmd

command to be sent

Returns: std::future to handler redis reply

◆ sync_commit()[1/2]

client& cpp_redis::client::sync_commit

(

void

)

same ascommit(), but synchronous will block until all pending commands have been sent and that a reply has been received for each of them and all underlying callbacks completed

Returns: current instance

◆ sync_commit()[2/2]

template<class Rep , class Period >

client& cpp_redis::client::sync_commit

(

const std::chrono::duration< Rep, Period > &

timeout

)

inline

same as sync_commit, but with a timeout will simply block until it completes or timeout expires

Returns: current instance

no need to call commit in case of reconnection the reconnection flow will do it for us

The documentation for this class was generated from the following files:

includes/cpp_redis/core/client.hpp
includes/cpp_redis/impl/client.ipp

Movatterモバイル変換

Classes

Public Types

Public Member Functions

Detailed Description

Member Typedef Documentation

◆ connect_callback_t

◆ reply_callback_t

Member Enumeration Documentation

◆ aggregate_method

◆ bitfield_operation_type

◆ client_type

◆ connect_state

◆ geo_unit

◆ overflow_type

Constructor & Destructor Documentation

◆ client()

Member Function Documentation

◆ add_sentinel()

◆ aggregate_method_to_string()

◆ bitfield_operation_type_to_string()

◆ cancel_reconnect()

◆ clear_sentinels()

◆ client_kill()

◆ client_kill_future()

◆ commit()

◆ connect()[1/2]

◆ connect()[2/2]

◆ disconnect()

◆ geo_unit_to_string()

◆ get_sentinel()[1/2]

◆ get_sentinel()[2/2]

◆ is_connected()

◆ is_reconnecting()

◆ overflow_type_to_string()

◆ send()[1/2]

◆ send()[2/2]

◆ sync_commit()[1/2]

◆ sync_commit()[2/2]