io.vertx.tp.plugin.redis

Class RedisClientStub.RedisTransactionImpl

java.lang.Object

io.vertx.tp.plugin.redis.RedisClientStub.RedisTransactionImpl

All Implemented Interfaces:

io.vertx.redis.RedisTransaction

Enclosing class:

RedisClientStub

public class RedisClientStub.RedisTransactionImpl
extends Object
implements io.vertx.redis.RedisTransaction

Constructor Summary

Constructors

Constructor and Description
RedisTransactionImpl()

Method Summary

Modifier and Type	Method and Description
io.vertx.redis.RedisTransaction	append(String key, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	auth(String password, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	bgrewriteaof(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	bgsave(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	bitcount(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	bitcountRange(String key, long start, long end, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	bitop(io.vertx.redis.op.BitOperation operation, String destkey, List<String> keys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	bitpos(String key, int bit, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	bitposFrom(String key, int bit, int start, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	bitposRange(String key, int bit, int start, int stop, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	blpop(String key, int seconds, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	blpopMany(List<String> keys, int seconds, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	brpop(String key, int seconds, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	brpoplpush(String key, String destkey, int seconds, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	brpopMany(List<String> keys, int seconds, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clientGetname(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clientKill(io.vertx.redis.op.KillFilter filter, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clientList(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clientPause(long millis, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clientSetname(String name, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
void	close(io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> handler)
io.vertx.redis.RedisTransaction	clusterAddslots(List<String> slots, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterCountFailureReports(String nodeId, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterCountkeysinslot(long slot, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterDelslots(long slot, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterDelslotsMany(List<String> slots, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterFailover(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterFailOverWithOptions(io.vertx.redis.op.FailoverOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterForget(String nodeId, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterGetkeysinslot(long slot, long count, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterInfo(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterKeyslot(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterMeet(String ip, long port, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterReplicate(String nodeId, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterReset(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterResetWithOptions(io.vertx.redis.op.ResetOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterSaveconfig(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterSetConfigEpoch(long epoch, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterSetslot(long slot, io.vertx.redis.op.SlotCmd subcommand, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterSetslotWithNode(long slot, io.vertx.redis.op.SlotCmd subcommand, String nodeId, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterSlaves(String nodeId, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	clusterSlots(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	command(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	commandCount(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	commandGetkeys(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	commandInfo(List<String> commands, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	configGet(String parameter, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	configResetstat(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	configRewrite(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	configSet(String parameter, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	dbsize(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	debugObject(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	debugSegfault(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	decr(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	decrby(String key, long decrement, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	del(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	delMany(List<String> keys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	discard(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	dump(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	echo(String message, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	eval(String script, List<String> keys, List<String> args, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	evalsha(String sha1, List<String> keys, List<String> args, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	exec(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.json.JsonArray>> handler)
io.vertx.redis.RedisTransaction	exists(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	existsMany(List<String> keys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	expire(String key, int seconds, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	expireat(String key, long seconds, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	flushall(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	flushdb(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	geoadd(String key, double longitude, double latitude, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	geoaddMany(String key, List<io.vertx.redis.op.GeoMember> members, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	geodist(String key, String member1, String member2, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	geodistWithUnit(String key, String member1, String member2, io.vertx.redis.op.GeoUnit unit, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	geohash(String key, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	geohashMany(String key, List<String> members, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	geopos(String key, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	geoposMany(String key, List<String> members, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	georadius(String key, double longitude, double latitude, double radius, io.vertx.redis.op.GeoUnit unit, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	georadiusbymember(String key, String member, double radius, io.vertx.redis.op.GeoUnit unit, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	georadiusbymemberWithOptions(String key, String member, double radius, io.vertx.redis.op.GeoUnit unit, io.vertx.redis.op.GeoRadiusOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	georadiusWithOptions(String key, double longitude, double latitude, double radius, io.vertx.redis.op.GeoUnit unit, io.vertx.redis.op.GeoRadiusOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	get(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	getBinary(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.buffer.Buffer>> handler)
io.vertx.redis.RedisTransaction	getbit(String key, long offset, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	getrange(String key, long start, long end, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	getset(String key, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hdel(String key, String field, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hdelMany(String key, List<String> fields, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hexists(String key, String field, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hget(String key, String field, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hgetall(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hincrby(String key, String field, long increment, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hincrbyfloat(String key, String field, double increment, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hkeys(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hlen(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hmget(String key, List<String> fields, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hmset(String key, io.vertx.core.json.JsonObject values, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hscan(String key, String cursor, io.vertx.redis.op.ScanOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hset(String key, String field, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hsetnx(String key, String field, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	hvals(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	incr(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	incrby(String key, long increment, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	incrbyfloat(String key, double increment, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	info(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	infoSection(String section, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	keys(String pattern, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	lastsave(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	lindex(String key, int index, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	linsert(String key, io.vertx.redis.op.InsertOptions option, String pivot, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	llen(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	lpop(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	lpush(String key, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	lpushMany(String key, List<String> values, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	lpushx(String key, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	lrange(String key, long from, long to, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	lrem(String key, long count, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	lset(String key, long index, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	ltrim(String key, long from, long to, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	mget(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	mgetMany(List<String> keys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	migrate(String host, int port, String key, int destdb, long timeout, io.vertx.redis.op.MigrateOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	monitor(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	move(String key, int destdb, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	mset(io.vertx.core.json.JsonObject keyvals, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	msetnx(io.vertx.core.json.JsonObject keyvals, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	multi(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	object(String key, io.vertx.redis.op.ObjectCmd cmd, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	persist(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	pexpire(String key, long millis, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	pexpireat(String key, long millis, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	pfadd(String key, String element, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	pfaddMany(String key, List<String> elements, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	pfcount(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	pfcountMany(List<String> key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	pfmerge(String destkey, List<String> keys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	ping(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	psetex(String key, long millis, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	psubscribe(String pattern, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	psubscribeMany(List<String> patterns, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	pttl(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	publish(String channel, String message, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	pubsubChannels(String pattern, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	pubsubNumpat(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	pubsubNumsub(List<String> channels, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	punsubscribe(List<String> patterns, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	randomkey(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	rename(String key, String newkey, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	renamenx(String key, String newkey, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	restore(String key, long millis, String serialized, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	role(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	rpop(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	rpoplpush(String key, String destkey, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	rpush(String key, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	rpushMany(String key, List<String> values, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	rpushx(String key, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sadd(String key, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	saddMany(String key, List<String> members, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	save(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	scan(String cursor, io.vertx.redis.op.ScanOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	scard(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	scriptExists(String script, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	scriptExistsMany(List<String> scripts, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	scriptFlush(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	scriptKill(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	scriptLoad(String script, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sdiff(String key, List<String> cmpkeys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sdiffstore(String destkey, String key, List<String> cmpkeys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	select(int dbindex, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	set(String key, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	setBinary(String key, io.vertx.core.buffer.Buffer value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	setBinaryWithOptions(String key, io.vertx.core.buffer.Buffer value, io.vertx.redis.op.SetOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	setbit(String key, long offset, int bit, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	setex(String key, long seconds, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	setnx(String key, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	setrange(String key, int offset, String value, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	setWithOptions(String key, String value, io.vertx.redis.op.SetOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sinter(List<String> keys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sinterstore(String destkey, List<String> keys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sismember(String key, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	slaveof(String host, int port, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	slaveofNoone(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	slowlogGet(int limit, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	slowlogLen(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	slowlogReset(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	smembers(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.json.JsonArray>> handler)
io.vertx.redis.RedisTransaction	smove(String key, String destkey, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sort(String key, io.vertx.redis.op.SortOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	spop(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	spopMany(String key, int count, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	srandmember(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	srandmemberCount(String key, int count, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	srem(String key, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sremMany(String key, List<String> members, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sscan(String key, String cursor, io.vertx.redis.op.ScanOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	strlen(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	subscribe(String channel, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	subscribeMany(List<String> channels, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sunion(List<String> keys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sunionstore(String destkey, List<String> keys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	swapdb(int index1, int index2, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	sync(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	time(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	ttl(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	type(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	unlink(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	unlinkMany(List<String> keys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	unsubscribe(List<String> channels, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	unwatch(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	wait(long numSlaves, long timeout, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	watch(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	watchMany(List<String> keys, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zadd(String key, double score, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zaddMany(String key, Map<String,Double> members, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zcard(String key, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zcount(String key, double min, double max, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zincrby(String key, double increment, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zinterstore(String destkey, List<String> sets, io.vertx.redis.op.AggregateOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zinterstoreWeighed(String destkey, Map<String,Double> sets, io.vertx.redis.op.AggregateOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zlexcount(String key, String min, String max, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zrange(String key, long start, long stop, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zrangebylex(String key, String min, String max, io.vertx.redis.op.LimitOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zrangebyscore(String key, String min, String max, io.vertx.redis.op.RangeLimitOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zrangeWithOptions(String key, long start, long stop, io.vertx.redis.op.RangeOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zrank(String key, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zrem(String key, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zremMany(String key, List<String> members, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zremrangebylex(String key, String min, String max, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zremrangebyrank(String key, long start, long stop, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zremrangebyscore(String key, String min, String max, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zrevrange(String key, long start, long stop, io.vertx.redis.op.RangeOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zrevrangebylex(String key, String max, String min, io.vertx.redis.op.LimitOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zrevrangebyscore(String key, String max, String min, io.vertx.redis.op.RangeLimitOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zrevrank(String key, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zscan(String key, String cursor, io.vertx.redis.op.ScanOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zscore(String key, String member, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zunionstore(String destkey, List<String> sets, io.vertx.redis.op.AggregateOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)
io.vertx.redis.RedisTransaction	zunionstoreWeighed(String destkey, Map<String,Double> sets, io.vertx.redis.op.AggregateOptions options, io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

RedisTransactionImpl

public RedisTransactionImpl()

Method Detail

close

public void close(io.vertx.core.Handler<io.vertx.core.AsyncResult<Void>> handler)

Specified by:

close in interface io.vertx.redis.RedisTransaction

append

public io.vertx.redis.RedisTransaction append(String key,
                                              String value,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

append in interface io.vertx.redis.RedisTransaction

auth

public io.vertx.redis.RedisTransaction auth(String password,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

auth in interface io.vertx.redis.RedisTransaction

bgrewriteaof

public io.vertx.redis.RedisTransaction bgrewriteaof(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

bgrewriteaof in interface io.vertx.redis.RedisTransaction

bgsave

public io.vertx.redis.RedisTransaction bgsave(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

bgsave in interface io.vertx.redis.RedisTransaction

bitcount

public io.vertx.redis.RedisTransaction bitcount(String key,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

bitcount in interface io.vertx.redis.RedisTransaction

bitcountRange

public io.vertx.redis.RedisTransaction bitcountRange(String key,
                                                     long start,
                                                     long end,
                                                     io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

bitcountRange in interface io.vertx.redis.RedisTransaction

bitop

public io.vertx.redis.RedisTransaction bitop(io.vertx.redis.op.BitOperation operation,
                                             String destkey,
                                             List<String> keys,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

bitop in interface io.vertx.redis.RedisTransaction

bitpos

public io.vertx.redis.RedisTransaction bitpos(String key,
                                              int bit,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

bitpos in interface io.vertx.redis.RedisTransaction

bitposFrom

public io.vertx.redis.RedisTransaction bitposFrom(String key,
                                                  int bit,
                                                  int start,
                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

bitposFrom in interface io.vertx.redis.RedisTransaction

bitposRange

public io.vertx.redis.RedisTransaction bitposRange(String key,
                                                   int bit,
                                                   int start,
                                                   int stop,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

bitposRange in interface io.vertx.redis.RedisTransaction

blpop

public io.vertx.redis.RedisTransaction blpop(String key,
                                             int seconds,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

blpop in interface io.vertx.redis.RedisTransaction

blpopMany

public io.vertx.redis.RedisTransaction blpopMany(List<String> keys,
                                                 int seconds,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

blpopMany in interface io.vertx.redis.RedisTransaction

brpop

public io.vertx.redis.RedisTransaction brpop(String key,
                                             int seconds,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

brpop in interface io.vertx.redis.RedisTransaction

brpopMany

public io.vertx.redis.RedisTransaction brpopMany(List<String> keys,
                                                 int seconds,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

brpopMany in interface io.vertx.redis.RedisTransaction

brpoplpush

public io.vertx.redis.RedisTransaction brpoplpush(String key,
                                                  String destkey,
                                                  int seconds,
                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

brpoplpush in interface io.vertx.redis.RedisTransaction

clientKill

public io.vertx.redis.RedisTransaction clientKill(io.vertx.redis.op.KillFilter filter,
                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clientKill in interface io.vertx.redis.RedisTransaction

clientList

public io.vertx.redis.RedisTransaction clientList(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clientList in interface io.vertx.redis.RedisTransaction

clientGetname

public io.vertx.redis.RedisTransaction clientGetname(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clientGetname in interface io.vertx.redis.RedisTransaction

clientPause

public io.vertx.redis.RedisTransaction clientPause(long millis,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clientPause in interface io.vertx.redis.RedisTransaction

clientSetname

public io.vertx.redis.RedisTransaction clientSetname(String name,
                                                     io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clientSetname in interface io.vertx.redis.RedisTransaction

clusterAddslots

public io.vertx.redis.RedisTransaction clusterAddslots(List<String> slots,
                                                       io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterAddslots in interface io.vertx.redis.RedisTransaction

clusterCountFailureReports

public io.vertx.redis.RedisTransaction clusterCountFailureReports(String nodeId,
                                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterCountFailureReports in interface io.vertx.redis.RedisTransaction

clusterCountkeysinslot

public io.vertx.redis.RedisTransaction clusterCountkeysinslot(long slot,
                                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterCountkeysinslot in interface io.vertx.redis.RedisTransaction

clusterDelslots

public io.vertx.redis.RedisTransaction clusterDelslots(long slot,
                                                       io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterDelslots in interface io.vertx.redis.RedisTransaction

clusterDelslotsMany

public io.vertx.redis.RedisTransaction clusterDelslotsMany(List<String> slots,
                                                           io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterDelslotsMany in interface io.vertx.redis.RedisTransaction

clusterFailover

public io.vertx.redis.RedisTransaction clusterFailover(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterFailover in interface io.vertx.redis.RedisTransaction

clusterFailOverWithOptions

public io.vertx.redis.RedisTransaction clusterFailOverWithOptions(io.vertx.redis.op.FailoverOptions options,
                                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterFailOverWithOptions in interface io.vertx.redis.RedisTransaction

clusterForget

public io.vertx.redis.RedisTransaction clusterForget(String nodeId,
                                                     io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterForget in interface io.vertx.redis.RedisTransaction

clusterGetkeysinslot

public io.vertx.redis.RedisTransaction clusterGetkeysinslot(long slot,
                                                            long count,
                                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterGetkeysinslot in interface io.vertx.redis.RedisTransaction

clusterInfo

public io.vertx.redis.RedisTransaction clusterInfo(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterInfo in interface io.vertx.redis.RedisTransaction

clusterKeyslot

public io.vertx.redis.RedisTransaction clusterKeyslot(String key,
                                                      io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterKeyslot in interface io.vertx.redis.RedisTransaction

clusterMeet

public io.vertx.redis.RedisTransaction clusterMeet(String ip,
                                                   long port,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterMeet in interface io.vertx.redis.RedisTransaction

clusterNodes

public io.vertx.redis.RedisTransaction clusterNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterNodes in interface io.vertx.redis.RedisTransaction

clusterReplicate

public io.vertx.redis.RedisTransaction clusterReplicate(String nodeId,
                                                        io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterReplicate in interface io.vertx.redis.RedisTransaction

clusterReset

public io.vertx.redis.RedisTransaction clusterReset(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterReset in interface io.vertx.redis.RedisTransaction

clusterResetWithOptions

public io.vertx.redis.RedisTransaction clusterResetWithOptions(io.vertx.redis.op.ResetOptions options,
                                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterResetWithOptions in interface io.vertx.redis.RedisTransaction

clusterSaveconfig

public io.vertx.redis.RedisTransaction clusterSaveconfig(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterSaveconfig in interface io.vertx.redis.RedisTransaction

clusterSetConfigEpoch

public io.vertx.redis.RedisTransaction clusterSetConfigEpoch(long epoch,
                                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterSetConfigEpoch in interface io.vertx.redis.RedisTransaction

clusterSetslot

public io.vertx.redis.RedisTransaction clusterSetslot(long slot,
                                                      io.vertx.redis.op.SlotCmd subcommand,
                                                      io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterSetslot in interface io.vertx.redis.RedisTransaction

clusterSetslotWithNode

public io.vertx.redis.RedisTransaction clusterSetslotWithNode(long slot,
                                                              io.vertx.redis.op.SlotCmd subcommand,
                                                              String nodeId,
                                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterSetslotWithNode in interface io.vertx.redis.RedisTransaction

clusterSlaves

public io.vertx.redis.RedisTransaction clusterSlaves(String nodeId,
                                                     io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterSlaves in interface io.vertx.redis.RedisTransaction

clusterSlots

public io.vertx.redis.RedisTransaction clusterSlots(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

clusterSlots in interface io.vertx.redis.RedisTransaction

command

public io.vertx.redis.RedisTransaction command(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

command in interface io.vertx.redis.RedisTransaction

commandCount

public io.vertx.redis.RedisTransaction commandCount(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

commandCount in interface io.vertx.redis.RedisTransaction

commandGetkeys

public io.vertx.redis.RedisTransaction commandGetkeys(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

commandGetkeys in interface io.vertx.redis.RedisTransaction

commandInfo

public io.vertx.redis.RedisTransaction commandInfo(List<String> commands,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

commandInfo in interface io.vertx.redis.RedisTransaction

configGet

public io.vertx.redis.RedisTransaction configGet(String parameter,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

configGet in interface io.vertx.redis.RedisTransaction

configRewrite

public io.vertx.redis.RedisTransaction configRewrite(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

configRewrite in interface io.vertx.redis.RedisTransaction

configSet

public io.vertx.redis.RedisTransaction configSet(String parameter,
                                                 String value,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

configSet in interface io.vertx.redis.RedisTransaction

configResetstat

public io.vertx.redis.RedisTransaction configResetstat(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

configResetstat in interface io.vertx.redis.RedisTransaction

dbsize

public io.vertx.redis.RedisTransaction dbsize(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

dbsize in interface io.vertx.redis.RedisTransaction

debugObject

public io.vertx.redis.RedisTransaction debugObject(String key,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

debugObject in interface io.vertx.redis.RedisTransaction

debugSegfault

public io.vertx.redis.RedisTransaction debugSegfault(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

debugSegfault in interface io.vertx.redis.RedisTransaction

decr

public io.vertx.redis.RedisTransaction decr(String key,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

decr in interface io.vertx.redis.RedisTransaction

decrby

public io.vertx.redis.RedisTransaction decrby(String key,
                                              long decrement,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

decrby in interface io.vertx.redis.RedisTransaction

del

public io.vertx.redis.RedisTransaction del(String key,
                                           io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

del in interface io.vertx.redis.RedisTransaction

delMany

public io.vertx.redis.RedisTransaction delMany(List<String> keys,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

delMany in interface io.vertx.redis.RedisTransaction

discard

public io.vertx.redis.RedisTransaction discard(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

discard in interface io.vertx.redis.RedisTransaction

dump

public io.vertx.redis.RedisTransaction dump(String key,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

dump in interface io.vertx.redis.RedisTransaction

echo

public io.vertx.redis.RedisTransaction echo(String message,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

echo in interface io.vertx.redis.RedisTransaction

eval

public io.vertx.redis.RedisTransaction eval(String script,
                                            List<String> keys,
                                            List<String> args,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

eval in interface io.vertx.redis.RedisTransaction

evalsha

public io.vertx.redis.RedisTransaction evalsha(String sha1,
                                               List<String> keys,
                                               List<String> args,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

evalsha in interface io.vertx.redis.RedisTransaction

exec

public io.vertx.redis.RedisTransaction exec(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.json.JsonArray>> handler)

Specified by:

exec in interface io.vertx.redis.RedisTransaction

exists

public io.vertx.redis.RedisTransaction exists(String key,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

exists in interface io.vertx.redis.RedisTransaction

existsMany

public io.vertx.redis.RedisTransaction existsMany(List<String> keys,
                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

existsMany in interface io.vertx.redis.RedisTransaction

expire

public io.vertx.redis.RedisTransaction expire(String key,
                                              int seconds,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

expire in interface io.vertx.redis.RedisTransaction

expireat

public io.vertx.redis.RedisTransaction expireat(String key,
                                                long seconds,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

expireat in interface io.vertx.redis.RedisTransaction

flushall

public io.vertx.redis.RedisTransaction flushall(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

flushall in interface io.vertx.redis.RedisTransaction

flushdb

public io.vertx.redis.RedisTransaction flushdb(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

flushdb in interface io.vertx.redis.RedisTransaction

get

public io.vertx.redis.RedisTransaction get(String key,
                                           io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

get in interface io.vertx.redis.RedisTransaction

getBinary

public io.vertx.redis.RedisTransaction getBinary(String key,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.buffer.Buffer>> handler)

Specified by:

getBinary in interface io.vertx.redis.RedisTransaction

getbit

public io.vertx.redis.RedisTransaction getbit(String key,
                                              long offset,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

getbit in interface io.vertx.redis.RedisTransaction

getrange

public io.vertx.redis.RedisTransaction getrange(String key,
                                                long start,
                                                long end,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

getrange in interface io.vertx.redis.RedisTransaction

getset

public io.vertx.redis.RedisTransaction getset(String key,
                                              String value,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

getset in interface io.vertx.redis.RedisTransaction

hdel

public io.vertx.redis.RedisTransaction hdel(String key,
                                            String field,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hdel in interface io.vertx.redis.RedisTransaction

hdelMany

public io.vertx.redis.RedisTransaction hdelMany(String key,
                                                List<String> fields,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hdelMany in interface io.vertx.redis.RedisTransaction

hexists

public io.vertx.redis.RedisTransaction hexists(String key,
                                               String field,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hexists in interface io.vertx.redis.RedisTransaction

hget

public io.vertx.redis.RedisTransaction hget(String key,
                                            String field,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hget in interface io.vertx.redis.RedisTransaction

hgetall

public io.vertx.redis.RedisTransaction hgetall(String key,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hgetall in interface io.vertx.redis.RedisTransaction

hincrby

public io.vertx.redis.RedisTransaction hincrby(String key,
                                               String field,
                                               long increment,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hincrby in interface io.vertx.redis.RedisTransaction

hincrbyfloat

public io.vertx.redis.RedisTransaction hincrbyfloat(String key,
                                                    String field,
                                                    double increment,
                                                    io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hincrbyfloat in interface io.vertx.redis.RedisTransaction

hkeys

public io.vertx.redis.RedisTransaction hkeys(String key,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hkeys in interface io.vertx.redis.RedisTransaction

hlen

public io.vertx.redis.RedisTransaction hlen(String key,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hlen in interface io.vertx.redis.RedisTransaction

hmget

public io.vertx.redis.RedisTransaction hmget(String key,
                                             List<String> fields,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hmget in interface io.vertx.redis.RedisTransaction

hmset

public io.vertx.redis.RedisTransaction hmset(String key,
                                             io.vertx.core.json.JsonObject values,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hmset in interface io.vertx.redis.RedisTransaction

hset

public io.vertx.redis.RedisTransaction hset(String key,
                                            String field,
                                            String value,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hset in interface io.vertx.redis.RedisTransaction

hsetnx

public io.vertx.redis.RedisTransaction hsetnx(String key,
                                              String field,
                                              String value,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hsetnx in interface io.vertx.redis.RedisTransaction

hvals

public io.vertx.redis.RedisTransaction hvals(String key,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hvals in interface io.vertx.redis.RedisTransaction

incr

public io.vertx.redis.RedisTransaction incr(String key,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

incr in interface io.vertx.redis.RedisTransaction

incrby

public io.vertx.redis.RedisTransaction incrby(String key,
                                              long increment,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

incrby in interface io.vertx.redis.RedisTransaction

incrbyfloat

public io.vertx.redis.RedisTransaction incrbyfloat(String key,
                                                   double increment,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

incrbyfloat in interface io.vertx.redis.RedisTransaction

info

public io.vertx.redis.RedisTransaction info(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

info in interface io.vertx.redis.RedisTransaction

infoSection

public io.vertx.redis.RedisTransaction infoSection(String section,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

infoSection in interface io.vertx.redis.RedisTransaction

keys

public io.vertx.redis.RedisTransaction keys(String pattern,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

keys in interface io.vertx.redis.RedisTransaction

lastsave

public io.vertx.redis.RedisTransaction lastsave(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

lastsave in interface io.vertx.redis.RedisTransaction

lindex

public io.vertx.redis.RedisTransaction lindex(String key,
                                              int index,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

lindex in interface io.vertx.redis.RedisTransaction

linsert

public io.vertx.redis.RedisTransaction linsert(String key,
                                               io.vertx.redis.op.InsertOptions option,
                                               String pivot,
                                               String value,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

linsert in interface io.vertx.redis.RedisTransaction

llen

public io.vertx.redis.RedisTransaction llen(String key,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

llen in interface io.vertx.redis.RedisTransaction

lpop

public io.vertx.redis.RedisTransaction lpop(String key,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

lpop in interface io.vertx.redis.RedisTransaction

lpushMany

public io.vertx.redis.RedisTransaction lpushMany(String key,
                                                 List<String> values,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

lpushMany in interface io.vertx.redis.RedisTransaction

lpush

public io.vertx.redis.RedisTransaction lpush(String key,
                                             String value,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

lpush in interface io.vertx.redis.RedisTransaction

lpushx

public io.vertx.redis.RedisTransaction lpushx(String key,
                                              String value,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

lpushx in interface io.vertx.redis.RedisTransaction

lrange

public io.vertx.redis.RedisTransaction lrange(String key,
                                              long from,
                                              long to,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

lrange in interface io.vertx.redis.RedisTransaction

lrem

public io.vertx.redis.RedisTransaction lrem(String key,
                                            long count,
                                            String value,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

lrem in interface io.vertx.redis.RedisTransaction

lset

public io.vertx.redis.RedisTransaction lset(String key,
                                            long index,
                                            String value,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

lset in interface io.vertx.redis.RedisTransaction

ltrim

public io.vertx.redis.RedisTransaction ltrim(String key,
                                             long from,
                                             long to,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

ltrim in interface io.vertx.redis.RedisTransaction

mget

public io.vertx.redis.RedisTransaction mget(String key,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

mget in interface io.vertx.redis.RedisTransaction

mgetMany

public io.vertx.redis.RedisTransaction mgetMany(List<String> keys,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

mgetMany in interface io.vertx.redis.RedisTransaction

migrate

public io.vertx.redis.RedisTransaction migrate(String host,
                                               int port,
                                               String key,
                                               int destdb,
                                               long timeout,
                                               io.vertx.redis.op.MigrateOptions options,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

migrate in interface io.vertx.redis.RedisTransaction

monitor

public io.vertx.redis.RedisTransaction monitor(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

monitor in interface io.vertx.redis.RedisTransaction

move

public io.vertx.redis.RedisTransaction move(String key,
                                            int destdb,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

move in interface io.vertx.redis.RedisTransaction

mset

public io.vertx.redis.RedisTransaction mset(io.vertx.core.json.JsonObject keyvals,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

mset in interface io.vertx.redis.RedisTransaction

msetnx

public io.vertx.redis.RedisTransaction msetnx(io.vertx.core.json.JsonObject keyvals,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

msetnx in interface io.vertx.redis.RedisTransaction

multi

public io.vertx.redis.RedisTransaction multi(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

multi in interface io.vertx.redis.RedisTransaction

object

public io.vertx.redis.RedisTransaction object(String key,
                                              io.vertx.redis.op.ObjectCmd cmd,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

object in interface io.vertx.redis.RedisTransaction

persist

public io.vertx.redis.RedisTransaction persist(String key,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

persist in interface io.vertx.redis.RedisTransaction

pexpire

public io.vertx.redis.RedisTransaction pexpire(String key,
                                               long millis,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

pexpire in interface io.vertx.redis.RedisTransaction

pexpireat

public io.vertx.redis.RedisTransaction pexpireat(String key,
                                                 long millis,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

pexpireat in interface io.vertx.redis.RedisTransaction

pfadd

public io.vertx.redis.RedisTransaction pfadd(String key,
                                             String element,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

pfadd in interface io.vertx.redis.RedisTransaction

pfaddMany

public io.vertx.redis.RedisTransaction pfaddMany(String key,
                                                 List<String> elements,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

pfaddMany in interface io.vertx.redis.RedisTransaction

pfcount

public io.vertx.redis.RedisTransaction pfcount(String key,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

pfcount in interface io.vertx.redis.RedisTransaction

pfcountMany

public io.vertx.redis.RedisTransaction pfcountMany(List<String> key,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

pfcountMany in interface io.vertx.redis.RedisTransaction

pfmerge

public io.vertx.redis.RedisTransaction pfmerge(String destkey,
                                               List<String> keys,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

pfmerge in interface io.vertx.redis.RedisTransaction

ping

public io.vertx.redis.RedisTransaction ping(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

ping in interface io.vertx.redis.RedisTransaction

psetex

public io.vertx.redis.RedisTransaction psetex(String key,
                                              long millis,
                                              String value,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

psetex in interface io.vertx.redis.RedisTransaction

psubscribe

public io.vertx.redis.RedisTransaction psubscribe(String pattern,
                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

psubscribe in interface io.vertx.redis.RedisTransaction

psubscribeMany

public io.vertx.redis.RedisTransaction psubscribeMany(List<String> patterns,
                                                      io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

psubscribeMany in interface io.vertx.redis.RedisTransaction

pubsubChannels

public io.vertx.redis.RedisTransaction pubsubChannels(String pattern,
                                                      io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

pubsubChannels in interface io.vertx.redis.RedisTransaction

pubsubNumsub

public io.vertx.redis.RedisTransaction pubsubNumsub(List<String> channels,
                                                    io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

pubsubNumsub in interface io.vertx.redis.RedisTransaction

pubsubNumpat

public io.vertx.redis.RedisTransaction pubsubNumpat(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

pubsubNumpat in interface io.vertx.redis.RedisTransaction

pttl

public io.vertx.redis.RedisTransaction pttl(String key,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

pttl in interface io.vertx.redis.RedisTransaction

publish

public io.vertx.redis.RedisTransaction publish(String channel,
                                               String message,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

publish in interface io.vertx.redis.RedisTransaction

punsubscribe

public io.vertx.redis.RedisTransaction punsubscribe(List<String> patterns,
                                                    io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

punsubscribe in interface io.vertx.redis.RedisTransaction

randomkey

public io.vertx.redis.RedisTransaction randomkey(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

randomkey in interface io.vertx.redis.RedisTransaction

rename

public io.vertx.redis.RedisTransaction rename(String key,
                                              String newkey,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

rename in interface io.vertx.redis.RedisTransaction

renamenx

public io.vertx.redis.RedisTransaction renamenx(String key,
                                                String newkey,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

renamenx in interface io.vertx.redis.RedisTransaction

restore

public io.vertx.redis.RedisTransaction restore(String key,
                                               long millis,
                                               String serialized,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

restore in interface io.vertx.redis.RedisTransaction

role

public io.vertx.redis.RedisTransaction role(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

role in interface io.vertx.redis.RedisTransaction

rpop

public io.vertx.redis.RedisTransaction rpop(String key,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

rpop in interface io.vertx.redis.RedisTransaction

rpoplpush

public io.vertx.redis.RedisTransaction rpoplpush(String key,
                                                 String destkey,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

rpoplpush in interface io.vertx.redis.RedisTransaction

rpushMany

public io.vertx.redis.RedisTransaction rpushMany(String key,
                                                 List<String> values,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

rpushMany in interface io.vertx.redis.RedisTransaction

rpush

public io.vertx.redis.RedisTransaction rpush(String key,
                                             String value,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

rpush in interface io.vertx.redis.RedisTransaction

rpushx

public io.vertx.redis.RedisTransaction rpushx(String key,
                                              String value,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

rpushx in interface io.vertx.redis.RedisTransaction

sadd

public io.vertx.redis.RedisTransaction sadd(String key,
                                            String member,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sadd in interface io.vertx.redis.RedisTransaction

saddMany

public io.vertx.redis.RedisTransaction saddMany(String key,
                                                List<String> members,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

saddMany in interface io.vertx.redis.RedisTransaction

save

public io.vertx.redis.RedisTransaction save(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

save in interface io.vertx.redis.RedisTransaction

scard

public io.vertx.redis.RedisTransaction scard(String key,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

scard in interface io.vertx.redis.RedisTransaction

scriptExists

public io.vertx.redis.RedisTransaction scriptExists(String script,
                                                    io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

scriptExists in interface io.vertx.redis.RedisTransaction

scriptExistsMany

public io.vertx.redis.RedisTransaction scriptExistsMany(List<String> scripts,
                                                        io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

scriptExistsMany in interface io.vertx.redis.RedisTransaction

scriptFlush

public io.vertx.redis.RedisTransaction scriptFlush(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

scriptFlush in interface io.vertx.redis.RedisTransaction

scriptKill

public io.vertx.redis.RedisTransaction scriptKill(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

scriptKill in interface io.vertx.redis.RedisTransaction

scriptLoad

public io.vertx.redis.RedisTransaction scriptLoad(String script,
                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

scriptLoad in interface io.vertx.redis.RedisTransaction

sdiff

public io.vertx.redis.RedisTransaction sdiff(String key,
                                             List<String> cmpkeys,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sdiff in interface io.vertx.redis.RedisTransaction

sdiffstore

public io.vertx.redis.RedisTransaction sdiffstore(String destkey,
                                                  String key,
                                                  List<String> cmpkeys,
                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sdiffstore in interface io.vertx.redis.RedisTransaction

select

public io.vertx.redis.RedisTransaction select(int dbindex,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

select in interface io.vertx.redis.RedisTransaction

set

public io.vertx.redis.RedisTransaction set(String key,
                                           String value,
                                           io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

set in interface io.vertx.redis.RedisTransaction

setWithOptions

public io.vertx.redis.RedisTransaction setWithOptions(String key,
                                                      String value,
                                                      io.vertx.redis.op.SetOptions options,
                                                      io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

setWithOptions in interface io.vertx.redis.RedisTransaction

setBinary

public io.vertx.redis.RedisTransaction setBinary(String key,
                                                 io.vertx.core.buffer.Buffer value,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

setBinary in interface io.vertx.redis.RedisTransaction

setBinaryWithOptions

public io.vertx.redis.RedisTransaction setBinaryWithOptions(String key,
                                                            io.vertx.core.buffer.Buffer value,
                                                            io.vertx.redis.op.SetOptions options,
                                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

setBinaryWithOptions in interface io.vertx.redis.RedisTransaction

setbit

public io.vertx.redis.RedisTransaction setbit(String key,
                                              long offset,
                                              int bit,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

setbit in interface io.vertx.redis.RedisTransaction

setex

public io.vertx.redis.RedisTransaction setex(String key,
                                             long seconds,
                                             String value,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

setex in interface io.vertx.redis.RedisTransaction

setnx

public io.vertx.redis.RedisTransaction setnx(String key,
                                             String value,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

setnx in interface io.vertx.redis.RedisTransaction

setrange

public io.vertx.redis.RedisTransaction setrange(String key,
                                                int offset,
                                                String value,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

setrange in interface io.vertx.redis.RedisTransaction

sinter

public io.vertx.redis.RedisTransaction sinter(List<String> keys,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sinter in interface io.vertx.redis.RedisTransaction

sinterstore

public io.vertx.redis.RedisTransaction sinterstore(String destkey,
                                                   List<String> keys,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sinterstore in interface io.vertx.redis.RedisTransaction

sismember

public io.vertx.redis.RedisTransaction sismember(String key,
                                                 String member,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sismember in interface io.vertx.redis.RedisTransaction

slaveof

public io.vertx.redis.RedisTransaction slaveof(String host,
                                               int port,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

slaveof in interface io.vertx.redis.RedisTransaction

slaveofNoone

public io.vertx.redis.RedisTransaction slaveofNoone(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

slaveofNoone in interface io.vertx.redis.RedisTransaction

slowlogGet

public io.vertx.redis.RedisTransaction slowlogGet(int limit,
                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

slowlogGet in interface io.vertx.redis.RedisTransaction

slowlogLen

public io.vertx.redis.RedisTransaction slowlogLen(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

slowlogLen in interface io.vertx.redis.RedisTransaction

slowlogReset

public io.vertx.redis.RedisTransaction slowlogReset(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

slowlogReset in interface io.vertx.redis.RedisTransaction

smembers

public io.vertx.redis.RedisTransaction smembers(String key,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.json.JsonArray>> handler)

Specified by:

smembers in interface io.vertx.redis.RedisTransaction

smove

public io.vertx.redis.RedisTransaction smove(String key,
                                             String destkey,
                                             String member,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

smove in interface io.vertx.redis.RedisTransaction

sort

public io.vertx.redis.RedisTransaction sort(String key,
                                            io.vertx.redis.op.SortOptions options,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sort in interface io.vertx.redis.RedisTransaction

spop

public io.vertx.redis.RedisTransaction spop(String key,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

spop in interface io.vertx.redis.RedisTransaction

spopMany

public io.vertx.redis.RedisTransaction spopMany(String key,
                                                int count,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

spopMany in interface io.vertx.redis.RedisTransaction

srandmember

public io.vertx.redis.RedisTransaction srandmember(String key,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

srandmember in interface io.vertx.redis.RedisTransaction

srandmemberCount

public io.vertx.redis.RedisTransaction srandmemberCount(String key,
                                                        int count,
                                                        io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

srandmemberCount in interface io.vertx.redis.RedisTransaction

srem

public io.vertx.redis.RedisTransaction srem(String key,
                                            String member,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

srem in interface io.vertx.redis.RedisTransaction

sremMany

public io.vertx.redis.RedisTransaction sremMany(String key,
                                                List<String> members,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sremMany in interface io.vertx.redis.RedisTransaction

strlen

public io.vertx.redis.RedisTransaction strlen(String key,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

strlen in interface io.vertx.redis.RedisTransaction

subscribe

public io.vertx.redis.RedisTransaction subscribe(String channel,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

subscribe in interface io.vertx.redis.RedisTransaction

subscribeMany

public io.vertx.redis.RedisTransaction subscribeMany(List<String> channels,
                                                     io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

subscribeMany in interface io.vertx.redis.RedisTransaction

sunion

public io.vertx.redis.RedisTransaction sunion(List<String> keys,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sunion in interface io.vertx.redis.RedisTransaction

sunionstore

public io.vertx.redis.RedisTransaction sunionstore(String destkey,
                                                   List<String> keys,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sunionstore in interface io.vertx.redis.RedisTransaction

sync

public io.vertx.redis.RedisTransaction sync(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sync in interface io.vertx.redis.RedisTransaction

time

public io.vertx.redis.RedisTransaction time(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

time in interface io.vertx.redis.RedisTransaction

ttl

public io.vertx.redis.RedisTransaction ttl(String key,
                                           io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

ttl in interface io.vertx.redis.RedisTransaction

type

public io.vertx.redis.RedisTransaction type(String key,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

type in interface io.vertx.redis.RedisTransaction

unsubscribe

public io.vertx.redis.RedisTransaction unsubscribe(List<String> channels,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

unsubscribe in interface io.vertx.redis.RedisTransaction

unwatch

public io.vertx.redis.RedisTransaction unwatch(io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

unwatch in interface io.vertx.redis.RedisTransaction

wait

public io.vertx.redis.RedisTransaction wait(long numSlaves,
                                            long timeout,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

wait in interface io.vertx.redis.RedisTransaction

watch

public io.vertx.redis.RedisTransaction watch(String key,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

watch in interface io.vertx.redis.RedisTransaction

watchMany

public io.vertx.redis.RedisTransaction watchMany(List<String> keys,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

watchMany in interface io.vertx.redis.RedisTransaction

zadd

public io.vertx.redis.RedisTransaction zadd(String key,
                                            double score,
                                            String member,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zadd in interface io.vertx.redis.RedisTransaction

zaddMany

public io.vertx.redis.RedisTransaction zaddMany(String key,
                                                Map<String,Double> members,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zaddMany in interface io.vertx.redis.RedisTransaction

zcard

public io.vertx.redis.RedisTransaction zcard(String key,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zcard in interface io.vertx.redis.RedisTransaction

zcount

public io.vertx.redis.RedisTransaction zcount(String key,
                                              double min,
                                              double max,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zcount in interface io.vertx.redis.RedisTransaction

zincrby

public io.vertx.redis.RedisTransaction zincrby(String key,
                                               double increment,
                                               String member,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zincrby in interface io.vertx.redis.RedisTransaction

zinterstore

public io.vertx.redis.RedisTransaction zinterstore(String destkey,
                                                   List<String> sets,
                                                   io.vertx.redis.op.AggregateOptions options,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zinterstore in interface io.vertx.redis.RedisTransaction

zinterstoreWeighed

public io.vertx.redis.RedisTransaction zinterstoreWeighed(String destkey,
                                                          Map<String,Double> sets,
                                                          io.vertx.redis.op.AggregateOptions options,
                                                          io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zinterstoreWeighed in interface io.vertx.redis.RedisTransaction

zlexcount

public io.vertx.redis.RedisTransaction zlexcount(String key,
                                                 String min,
                                                 String max,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zlexcount in interface io.vertx.redis.RedisTransaction

zrange

public io.vertx.redis.RedisTransaction zrange(String key,
                                              long start,
                                              long stop,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zrange in interface io.vertx.redis.RedisTransaction

zrangeWithOptions

public io.vertx.redis.RedisTransaction zrangeWithOptions(String key,
                                                         long start,
                                                         long stop,
                                                         io.vertx.redis.op.RangeOptions options,
                                                         io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zrangeWithOptions in interface io.vertx.redis.RedisTransaction

zrangebylex

public io.vertx.redis.RedisTransaction zrangebylex(String key,
                                                   String min,
                                                   String max,
                                                   io.vertx.redis.op.LimitOptions options,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zrangebylex in interface io.vertx.redis.RedisTransaction

zrangebyscore

public io.vertx.redis.RedisTransaction zrangebyscore(String key,
                                                     String min,
                                                     String max,
                                                     io.vertx.redis.op.RangeLimitOptions options,
                                                     io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zrangebyscore in interface io.vertx.redis.RedisTransaction

zrank

public io.vertx.redis.RedisTransaction zrank(String key,
                                             String member,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zrank in interface io.vertx.redis.RedisTransaction

zrem

public io.vertx.redis.RedisTransaction zrem(String key,
                                            String member,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zrem in interface io.vertx.redis.RedisTransaction

zremMany

public io.vertx.redis.RedisTransaction zremMany(String key,
                                                List<String> members,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zremMany in interface io.vertx.redis.RedisTransaction

zremrangebylex

public io.vertx.redis.RedisTransaction zremrangebylex(String key,
                                                      String min,
                                                      String max,
                                                      io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zremrangebylex in interface io.vertx.redis.RedisTransaction

zremrangebyrank

public io.vertx.redis.RedisTransaction zremrangebyrank(String key,
                                                       long start,
                                                       long stop,
                                                       io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zremrangebyrank in interface io.vertx.redis.RedisTransaction

zremrangebyscore

public io.vertx.redis.RedisTransaction zremrangebyscore(String key,
                                                        String min,
                                                        String max,
                                                        io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zremrangebyscore in interface io.vertx.redis.RedisTransaction

zrevrange

public io.vertx.redis.RedisTransaction zrevrange(String key,
                                                 long start,
                                                 long stop,
                                                 io.vertx.redis.op.RangeOptions options,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zrevrange in interface io.vertx.redis.RedisTransaction

zrevrangebylex

public io.vertx.redis.RedisTransaction zrevrangebylex(String key,
                                                      String max,
                                                      String min,
                                                      io.vertx.redis.op.LimitOptions options,
                                                      io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zrevrangebylex in interface io.vertx.redis.RedisTransaction

zrevrangebyscore

public io.vertx.redis.RedisTransaction zrevrangebyscore(String key,
                                                        String max,
                                                        String min,
                                                        io.vertx.redis.op.RangeLimitOptions options,
                                                        io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zrevrangebyscore in interface io.vertx.redis.RedisTransaction

zrevrank

public io.vertx.redis.RedisTransaction zrevrank(String key,
                                                String member,
                                                io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zrevrank in interface io.vertx.redis.RedisTransaction

zscore

public io.vertx.redis.RedisTransaction zscore(String key,
                                              String member,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zscore in interface io.vertx.redis.RedisTransaction

zunionstore

public io.vertx.redis.RedisTransaction zunionstore(String destkey,
                                                   List<String> sets,
                                                   io.vertx.redis.op.AggregateOptions options,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zunionstore in interface io.vertx.redis.RedisTransaction

zunionstoreWeighed

public io.vertx.redis.RedisTransaction zunionstoreWeighed(String destkey,
                                                          Map<String,Double> sets,
                                                          io.vertx.redis.op.AggregateOptions options,
                                                          io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zunionstoreWeighed in interface io.vertx.redis.RedisTransaction

scan

public io.vertx.redis.RedisTransaction scan(String cursor,
                                            io.vertx.redis.op.ScanOptions options,
                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

scan in interface io.vertx.redis.RedisTransaction

sscan

public io.vertx.redis.RedisTransaction sscan(String key,
                                             String cursor,
                                             io.vertx.redis.op.ScanOptions options,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

sscan in interface io.vertx.redis.RedisTransaction

hscan

public io.vertx.redis.RedisTransaction hscan(String key,
                                             String cursor,
                                             io.vertx.redis.op.ScanOptions options,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

hscan in interface io.vertx.redis.RedisTransaction

zscan

public io.vertx.redis.RedisTransaction zscan(String key,
                                             String cursor,
                                             io.vertx.redis.op.ScanOptions options,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

zscan in interface io.vertx.redis.RedisTransaction

geoadd

public io.vertx.redis.RedisTransaction geoadd(String key,
                                              double longitude,
                                              double latitude,
                                              String member,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

geoadd in interface io.vertx.redis.RedisTransaction

geoaddMany

public io.vertx.redis.RedisTransaction geoaddMany(String key,
                                                  List<io.vertx.redis.op.GeoMember> members,
                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

geoaddMany in interface io.vertx.redis.RedisTransaction

geohash

public io.vertx.redis.RedisTransaction geohash(String key,
                                               String member,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

geohash in interface io.vertx.redis.RedisTransaction

geohashMany

public io.vertx.redis.RedisTransaction geohashMany(String key,
                                                   List<String> members,
                                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

geohashMany in interface io.vertx.redis.RedisTransaction

geopos

public io.vertx.redis.RedisTransaction geopos(String key,
                                              String member,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

geopos in interface io.vertx.redis.RedisTransaction

geoposMany

public io.vertx.redis.RedisTransaction geoposMany(String key,
                                                  List<String> members,
                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

geoposMany in interface io.vertx.redis.RedisTransaction

geodist

public io.vertx.redis.RedisTransaction geodist(String key,
                                               String member1,
                                               String member2,
                                               io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

geodist in interface io.vertx.redis.RedisTransaction

geodistWithUnit

public io.vertx.redis.RedisTransaction geodistWithUnit(String key,
                                                       String member1,
                                                       String member2,
                                                       io.vertx.redis.op.GeoUnit unit,
                                                       io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

geodistWithUnit in interface io.vertx.redis.RedisTransaction

georadius

public io.vertx.redis.RedisTransaction georadius(String key,
                                                 double longitude,
                                                 double latitude,
                                                 double radius,
                                                 io.vertx.redis.op.GeoUnit unit,
                                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

georadius in interface io.vertx.redis.RedisTransaction

georadiusWithOptions

public io.vertx.redis.RedisTransaction georadiusWithOptions(String key,
                                                            double longitude,
                                                            double latitude,
                                                            double radius,
                                                            io.vertx.redis.op.GeoUnit unit,
                                                            io.vertx.redis.op.GeoRadiusOptions options,
                                                            io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

georadiusWithOptions in interface io.vertx.redis.RedisTransaction

georadiusbymember

public io.vertx.redis.RedisTransaction georadiusbymember(String key,
                                                         String member,
                                                         double radius,
                                                         io.vertx.redis.op.GeoUnit unit,
                                                         io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

georadiusbymember in interface io.vertx.redis.RedisTransaction

georadiusbymemberWithOptions

public io.vertx.redis.RedisTransaction georadiusbymemberWithOptions(String key,
                                                                    String member,
                                                                    double radius,
                                                                    io.vertx.redis.op.GeoUnit unit,
                                                                    io.vertx.redis.op.GeoRadiusOptions options,
                                                                    io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

georadiusbymemberWithOptions in interface io.vertx.redis.RedisTransaction

unlink

public io.vertx.redis.RedisTransaction unlink(String key,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

unlink in interface io.vertx.redis.RedisTransaction

unlinkMany

public io.vertx.redis.RedisTransaction unlinkMany(List<String> keys,
                                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

unlinkMany in interface io.vertx.redis.RedisTransaction

swapdb

public io.vertx.redis.RedisTransaction swapdb(int index1,
                                              int index2,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<String>> handler)

Specified by:

swapdb in interface io.vertx.redis.RedisTransaction