class RedisAPI extends AnyRef
Auto generated Redis API client wrapper.
- Alphabetic
- By Inheritance
- RedisAPI
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new RedisAPI(_asJava: AnyRef)
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
append(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command append.
Redis command append. * @return fluent self
-
def
appendFuture(arg0: String, arg1: String): Future[Option[Response]]
Like append but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- def asJava: AnyRef
-
def
asking(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command asking.
Redis command asking. * @return fluent self
-
def
askingFuture(): Future[Option[Response]]
Like asking but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
auth(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command auth.
Redis command auth. * @return fluent self
-
def
authFuture(arg0: String): Future[Option[Response]]
Like auth but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
bgrewriteaof(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command bgrewriteaof.
Redis command bgrewriteaof. * @return fluent self
-
def
bgrewriteaofFuture(): Future[Option[Response]]
Like bgrewriteaof but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
bgsave(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command bgsave.
Redis command bgsave. * @return fluent self
-
def
bgsaveFuture(args: Buffer[String]): Future[Option[Response]]
Like bgsave but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
bitcount(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command bitcount.
Redis command bitcount. * @return fluent self
-
def
bitcountFuture(args: Buffer[String]): Future[Option[Response]]
Like bitcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
bitfield(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command bitfield.
Redis command bitfield. * @return fluent self
-
def
bitfieldFuture(args: Buffer[String]): Future[Option[Response]]
Like bitfield but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
bitop(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command bitop.
Redis command bitop. * @return fluent self
-
def
bitopFuture(args: Buffer[String]): Future[Option[Response]]
Like bitop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
bitpos(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command bitpos.
Redis command bitpos. * @return fluent self
-
def
bitposFuture(args: Buffer[String]): Future[Option[Response]]
Like bitpos but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
blpop(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command blpop.
Redis command blpop. * @return fluent self
-
def
blpopFuture(args: Buffer[String]): Future[Option[Response]]
Like blpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
brpop(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command brpop.
Redis command brpop. * @return fluent self
-
def
brpopFuture(args: Buffer[String]): Future[Option[Response]]
Like brpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
brpoplpush(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command brpoplpush.
Redis command brpoplpush. * @return fluent self
-
def
brpoplpushFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like brpoplpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
bzpopmax(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command bzpopmax.
Redis command bzpopmax. * @return fluent self
-
def
bzpopmaxFuture(args: Buffer[String]): Future[Option[Response]]
Like bzpopmax but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
bzpopmin(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command bzpopmin.
Redis command bzpopmin. * @return fluent self
-
def
bzpopminFuture(args: Buffer[String]): Future[Option[Response]]
Like bzpopmin but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
client(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command client.
Redis command client. * @return fluent self
-
def
clientFuture(args: Buffer[String]): Future[Option[Response]]
Like client but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
- def close(): Unit
-
def
cluster(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command cluster.
Redis command cluster. * @return fluent self
-
def
clusterFuture(args: Buffer[String]): Future[Option[Response]]
Like cluster but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
command(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command command.
Redis command command. * @return fluent self
-
def
commandFuture(): Future[Option[Response]]
Like command but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
config(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command config.
Redis command config. * @return fluent self
-
def
configFuture(args: Buffer[String]): Future[Option[Response]]
Like config but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
dbsize(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command dbsize.
Redis command dbsize. * @return fluent self
-
def
dbsizeFuture(): Future[Option[Response]]
Like dbsize but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
debug(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command debug.
Redis command debug. * @return fluent self
-
def
debugFuture(args: Buffer[String]): Future[Option[Response]]
Like debug but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
decr(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command decr.
Redis command decr. * @return fluent self
-
def
decrFuture(arg0: String): Future[Option[Response]]
Like decr but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
decrby(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command decrby.
Redis command decrby. * @return fluent self
-
def
decrbyFuture(arg0: String, arg1: String): Future[Option[Response]]
Like decrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
del(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command del.
Redis command del. * @return fluent self
-
def
delFuture(args: Buffer[String]): Future[Option[Response]]
Like del but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
discard(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command discard.
Redis command discard. * @return fluent self
-
def
discardFuture(): Future[Option[Response]]
Like discard but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
dump(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command dump.
Redis command dump. * @return fluent self
-
def
dumpFuture(arg0: String): Future[Option[Response]]
Like dump but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
echo(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command echo.
Redis command echo. * @return fluent self
-
def
echoFuture(arg0: String): Future[Option[Response]]
Like echo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
eval(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command eval.
Redis command eval. * @return fluent self
-
def
evalFuture(args: Buffer[String]): Future[Option[Response]]
Like eval but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
evalsha(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command evalsha.
Redis command evalsha. * @return fluent self
-
def
evalshaFuture(args: Buffer[String]): Future[Option[Response]]
Like evalsha but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
exec(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command exec.
Redis command exec. * @return fluent self
-
def
execFuture(): Future[Option[Response]]
Like exec but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
exists(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command exists.
Redis command exists. * @return fluent self
-
def
existsFuture(args: Buffer[String]): Future[Option[Response]]
Like exists but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
expire(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command expire.
Redis command expire. * @return fluent self
-
def
expireFuture(arg0: String, arg1: String): Future[Option[Response]]
Like expire but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
expireat(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command expireat.
Redis command expireat. * @return fluent self
-
def
expireatFuture(arg0: String, arg1: String): Future[Option[Response]]
Like expireat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
flushall(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command flushall.
Redis command flushall. * @return fluent self
-
def
flushallFuture(args: Buffer[String]): Future[Option[Response]]
Like flushall but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
flushdb(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command flushdb.
Redis command flushdb. * @return fluent self
-
def
flushdbFuture(args: Buffer[String]): Future[Option[Response]]
Like flushdb but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
geoadd(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command geoadd.
Redis command geoadd. * @return fluent self
-
def
geoaddFuture(args: Buffer[String]): Future[Option[Response]]
Like geoadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
geodist(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command geodist.
Redis command geodist. * @return fluent self
-
def
geodistFuture(args: Buffer[String]): Future[Option[Response]]
Like geodist but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
geohash(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command geohash.
Redis command geohash. * @return fluent self
-
def
geohashFuture(args: Buffer[String]): Future[Option[Response]]
Like geohash but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
geopos(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command geopos.
Redis command geopos. * @return fluent self
-
def
geoposFuture(args: Buffer[String]): Future[Option[Response]]
Like geopos but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
georadius(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command georadius.
Redis command georadius. * @return fluent self
-
def
georadiusFuture(args: Buffer[String]): Future[Option[Response]]
Like georadius but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
georadiusRo(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command georadiusRo.
Redis command georadiusRo. * @return fluent self
-
def
georadiusRoFuture(args: Buffer[String]): Future[Option[Response]]
Like georadiusRo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
georadiusbymember(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command georadiusbymember.
Redis command georadiusbymember. * @return fluent self
-
def
georadiusbymemberFuture(args: Buffer[String]): Future[Option[Response]]
Like georadiusbymember but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
georadiusbymemberRo(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command georadiusbymemberRo.
Redis command georadiusbymemberRo. * @return fluent self
-
def
georadiusbymemberRoFuture(args: Buffer[String]): Future[Option[Response]]
Like georadiusbymemberRo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
get(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command get.
Redis command get. * @return fluent self
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
getFuture(arg0: String): Future[Option[Response]]
Like get but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
getbit(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command getbit.
Redis command getbit. * @return fluent self
-
def
getbitFuture(arg0: String, arg1: String): Future[Option[Response]]
Like getbit but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
getrange(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command getrange.
Redis command getrange. * @return fluent self
-
def
getrangeFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like getrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
getset(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command getset.
Redis command getset. * @return fluent self
-
def
getsetFuture(arg0: String, arg1: String): Future[Option[Response]]
Like getset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hdel(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hdel.
Redis command hdel. * @return fluent self
-
def
hdelFuture(args: Buffer[String]): Future[Option[Response]]
Like hdel but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hexists(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hexists.
Redis command hexists. * @return fluent self
-
def
hexistsFuture(arg0: String, arg1: String): Future[Option[Response]]
Like hexists but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hget(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hget.
Redis command hget. * @return fluent self
-
def
hgetFuture(arg0: String, arg1: String): Future[Option[Response]]
Like hget but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hgetall(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hgetall.
Redis command hgetall. * @return fluent self
-
def
hgetallFuture(arg0: String): Future[Option[Response]]
Like hgetall but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hincrby(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hincrby.
Redis command hincrby. * @return fluent self
-
def
hincrbyFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like hincrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hincrbyfloat(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hincrbyfloat.
Redis command hincrbyfloat. * @return fluent self
-
def
hincrbyfloatFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like hincrbyfloat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hkeys(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hkeys.
Redis command hkeys. * @return fluent self
-
def
hkeysFuture(arg0: String): Future[Option[Response]]
Like hkeys but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hlen(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hlen.
Redis command hlen. * @return fluent self
-
def
hlenFuture(arg0: String): Future[Option[Response]]
Like hlen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hmget(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hmget.
Redis command hmget. * @return fluent self
-
def
hmgetFuture(args: Buffer[String]): Future[Option[Response]]
Like hmget but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hmset(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hmset.
Redis command hmset. * @return fluent self
-
def
hmsetFuture(args: Buffer[String]): Future[Option[Response]]
Like hmset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
host(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command host.
Redis command host. * @return fluent self
-
def
hostFuture(args: Buffer[String]): Future[Option[Response]]
Like host but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hscan(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hscan.
Redis command hscan. * @return fluent self
-
def
hscanFuture(args: Buffer[String]): Future[Option[Response]]
Like hscan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hset(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hset.
Redis command hset. * @return fluent self
-
def
hsetFuture(args: Buffer[String]): Future[Option[Response]]
Like hset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hsetnx(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hsetnx.
Redis command hsetnx. * @return fluent self
-
def
hsetnxFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like hsetnx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hstrlen(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hstrlen.
Redis command hstrlen. * @return fluent self
-
def
hstrlenFuture(arg0: String, arg1: String): Future[Option[Response]]
Like hstrlen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
hvals(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command hvals.
Redis command hvals. * @return fluent self
-
def
hvalsFuture(arg0: String): Future[Option[Response]]
Like hvals but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
incr(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command incr.
Redis command incr. * @return fluent self
-
def
incrFuture(arg0: String): Future[Option[Response]]
Like incr but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
incrby(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command incrby.
Redis command incrby. * @return fluent self
-
def
incrbyFuture(arg0: String, arg1: String): Future[Option[Response]]
Like incrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
incrbyfloat(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command incrbyfloat.
Redis command incrbyfloat. * @return fluent self
-
def
incrbyfloatFuture(arg0: String, arg1: String): Future[Option[Response]]
Like incrbyfloat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
info(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command info.
Redis command info. * @return fluent self
-
def
infoFuture(args: Buffer[String]): Future[Option[Response]]
Like info but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
keys(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command keys.
Redis command keys. * @return fluent self
-
def
keysFuture(arg0: String): Future[Option[Response]]
Like keys but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
lastsave(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command lastsave.
Redis command lastsave. * @return fluent self
-
def
lastsaveFuture(): Future[Option[Response]]
Like lastsave but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
latency(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command latency.
Redis command latency. * @return fluent self
-
def
latencyFuture(args: Buffer[String]): Future[Option[Response]]
Like latency but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
lindex(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command lindex.
Redis command lindex. * @return fluent self
-
def
lindexFuture(arg0: String, arg1: String): Future[Option[Response]]
Like lindex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
linsert(arg0: String, arg1: String, arg2: String, arg3: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command linsert.
Redis command linsert. * @return fluent self
-
def
linsertFuture(arg0: String, arg1: String, arg2: String, arg3: String): Future[Option[Response]]
Like linsert but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
llen(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command llen.
Redis command llen. * @return fluent self
-
def
llenFuture(arg0: String): Future[Option[Response]]
Like llen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
lolwut(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command lolwut.
Redis command lolwut. * @return fluent self
-
def
lolwutFuture(args: Buffer[String]): Future[Option[Response]]
Like lolwut but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
lpop(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command lpop.
Redis command lpop. * @return fluent self
-
def
lpopFuture(arg0: String): Future[Option[Response]]
Like lpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
lpush(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command lpush.
Redis command lpush. * @return fluent self
-
def
lpushFuture(args: Buffer[String]): Future[Option[Response]]
Like lpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
lpushx(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command lpushx.
Redis command lpushx. * @return fluent self
-
def
lpushxFuture(args: Buffer[String]): Future[Option[Response]]
Like lpushx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
lrange(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command lrange.
Redis command lrange. * @return fluent self
-
def
lrangeFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like lrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
lrem(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command lrem.
Redis command lrem. * @return fluent self
-
def
lremFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like lrem but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
lset(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command lset.
Redis command lset. * @return fluent self
-
def
lsetFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like lset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
ltrim(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command ltrim.
Redis command ltrim. * @return fluent self
-
def
ltrimFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like ltrim but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
memory(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command memory.
Redis command memory. * @return fluent self
-
def
memoryFuture(args: Buffer[String]): Future[Option[Response]]
Like memory but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
mget(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command mget.
Redis command mget. * @return fluent self
-
def
mgetFuture(args: Buffer[String]): Future[Option[Response]]
Like mget but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
migrate(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command migrate.
Redis command migrate. * @return fluent self
-
def
migrateFuture(args: Buffer[String]): Future[Option[Response]]
Like migrate but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
module(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command module.
Redis command module. * @return fluent self
-
def
moduleFuture(args: Buffer[String]): Future[Option[Response]]
Like module but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
monitor(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command monitor.
Redis command monitor. * @return fluent self
-
def
monitorFuture(): Future[Option[Response]]
Like monitor but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
move(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command move.
Redis command move. * @return fluent self
-
def
moveFuture(arg0: String, arg1: String): Future[Option[Response]]
Like move but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
mset(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command mset.
Redis command mset. * @return fluent self
-
def
msetFuture(args: Buffer[String]): Future[Option[Response]]
Like mset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
msetnx(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command msetnx.
Redis command msetnx. * @return fluent self
-
def
msetnxFuture(args: Buffer[String]): Future[Option[Response]]
Like msetnx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
multi(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command multi.
Redis command multi. * @return fluent self
-
def
multiFuture(): Future[Option[Response]]
Like multi but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
object(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command object.
Redis command object. * @return fluent self
-
def
objectFuture(args: Buffer[String]): Future[Option[Response]]
Like object but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
persist(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command persist.
Redis command persist. * @return fluent self
-
def
persistFuture(arg0: String): Future[Option[Response]]
Like persist but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
pexpire(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command pexpire.
Redis command pexpire. * @return fluent self
-
def
pexpireFuture(arg0: String, arg1: String): Future[Option[Response]]
Like pexpire but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
pexpireat(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command pexpireat.
Redis command pexpireat. * @return fluent self
-
def
pexpireatFuture(arg0: String, arg1: String): Future[Option[Response]]
Like pexpireat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
pfadd(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command pfadd.
Redis command pfadd. * @return fluent self
-
def
pfaddFuture(args: Buffer[String]): Future[Option[Response]]
Like pfadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
pfcount(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command pfcount.
Redis command pfcount. * @return fluent self
-
def
pfcountFuture(args: Buffer[String]): Future[Option[Response]]
Like pfcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
pfdebug(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command pfdebug.
Redis command pfdebug. * @return fluent self
-
def
pfdebugFuture(args: Buffer[String]): Future[Option[Response]]
Like pfdebug but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
pfmerge(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command pfmerge.
Redis command pfmerge. * @return fluent self
-
def
pfmergeFuture(args: Buffer[String]): Future[Option[Response]]
Like pfmerge but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
pfselftest(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command pfselftest.
Redis command pfselftest. * @return fluent self
-
def
pfselftestFuture(): Future[Option[Response]]
Like pfselftest but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
ping(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command ping.
Redis command ping. * @return fluent self
-
def
pingFuture(args: Buffer[String]): Future[Option[Response]]
Like ping but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
post(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command post.
Redis command post. * @return fluent self
-
def
postFuture(args: Buffer[String]): Future[Option[Response]]
Like post but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
psetex(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command psetex.
Redis command psetex. * @return fluent self
-
def
psetexFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like psetex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
psubscribe(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command psubscribe.
Redis command psubscribe. * @return fluent self
-
def
psubscribeFuture(args: Buffer[String]): Future[Option[Response]]
Like psubscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
psync(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command psync.
Redis command psync. * @return fluent self
-
def
psyncFuture(arg0: String, arg1: String): Future[Option[Response]]
Like psync but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
pttl(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command pttl.
Redis command pttl. * @return fluent self
-
def
pttlFuture(arg0: String): Future[Option[Response]]
Like pttl but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
publish(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command publish.
Redis command publish. * @return fluent self
-
def
publishFuture(arg0: String, arg1: String): Future[Option[Response]]
Like publish but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
pubsub(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command pubsub.
Redis command pubsub. * @return fluent self
-
def
pubsubFuture(args: Buffer[String]): Future[Option[Response]]
Like pubsub but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
punsubscribe(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command punsubscribe.
Redis command punsubscribe. * @return fluent self
-
def
punsubscribeFuture(args: Buffer[String]): Future[Option[Response]]
Like punsubscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
randomkey(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command randomkey.
Redis command randomkey. * @return fluent self
-
def
randomkeyFuture(): Future[Option[Response]]
Like randomkey but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
readonly(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command readonly.
Redis command readonly. * @return fluent self
-
def
readonlyFuture(): Future[Option[Response]]
Like readonly but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
readwrite(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command readwrite.
Redis command readwrite. * @return fluent self
-
def
readwriteFuture(): Future[Option[Response]]
Like readwrite but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
rename(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command rename.
Redis command rename. * @return fluent self
-
def
renameFuture(arg0: String, arg1: String): Future[Option[Response]]
Like rename but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
renamenx(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command renamenx.
Redis command renamenx. * @return fluent self
-
def
renamenxFuture(arg0: String, arg1: String): Future[Option[Response]]
Like renamenx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
replconf(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command replconf.
Redis command replconf. * @return fluent self
-
def
replconfFuture(args: Buffer[String]): Future[Option[Response]]
Like replconf but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
replicaof(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command replicaof.
Redis command replicaof. * @return fluent self
-
def
replicaofFuture(arg0: String, arg1: String): Future[Option[Response]]
Like replicaof but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
restore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command restore.
Redis command restore. * @return fluent self
-
def
restoreAsking(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command restoreAsking.
Redis command restoreAsking. * @return fluent self
-
def
restoreAskingFuture(args: Buffer[String]): Future[Option[Response]]
Like restoreAsking but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
restoreFuture(args: Buffer[String]): Future[Option[Response]]
Like restore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
role(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command role.
Redis command role. * @return fluent self
-
def
roleFuture(): Future[Option[Response]]
Like role but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
rpop(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command rpop.
Redis command rpop. * @return fluent self
-
def
rpopFuture(arg0: String): Future[Option[Response]]
Like rpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
rpoplpush(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command rpoplpush.
Redis command rpoplpush. * @return fluent self
-
def
rpoplpushFuture(arg0: String, arg1: String): Future[Option[Response]]
Like rpoplpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
rpush(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command rpush.
Redis command rpush. * @return fluent self
-
def
rpushFuture(args: Buffer[String]): Future[Option[Response]]
Like rpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
rpushx(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command rpushx.
Redis command rpushx. * @return fluent self
-
def
rpushxFuture(args: Buffer[String]): Future[Option[Response]]
Like rpushx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
sadd(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command sadd.
Redis command sadd. * @return fluent self
-
def
saddFuture(args: Buffer[String]): Future[Option[Response]]
Like sadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
save(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command save.
Redis command save. * @return fluent self
-
def
saveFuture(): Future[Option[Response]]
Like save but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
scan(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command scan.
Redis command scan. * @return fluent self
-
def
scanFuture(args: Buffer[String]): Future[Option[Response]]
Like scan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
scard(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command scard.
Redis command scard. * @return fluent self
-
def
scardFuture(arg0: String): Future[Option[Response]]
Like scard but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
script(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command script.
Redis command script. * @return fluent self
-
def
scriptFuture(args: Buffer[String]): Future[Option[Response]]
Like script but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
sdiff(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command sdiff.
Redis command sdiff. * @return fluent self
-
def
sdiffFuture(args: Buffer[String]): Future[Option[Response]]
Like sdiff but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
sdiffstore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command sdiffstore.
Redis command sdiffstore. * @return fluent self
-
def
sdiffstoreFuture(args: Buffer[String]): Future[Option[Response]]
Like sdiffstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
select(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command select.
Redis command select. * @return fluent self
-
def
selectFuture(arg0: String): Future[Option[Response]]
Like select but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
set(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command set.
Redis command set. * @return fluent self
-
def
setFuture(args: Buffer[String]): Future[Option[Response]]
Like set but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
setbit(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command setbit.
Redis command setbit. * @return fluent self
-
def
setbitFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like setbit but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
setex(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command setex.
Redis command setex. * @return fluent self
-
def
setexFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like setex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
setnx(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command setnx.
Redis command setnx. * @return fluent self
-
def
setnxFuture(arg0: String, arg1: String): Future[Option[Response]]
Like setnx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
setrange(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command setrange.
Redis command setrange. * @return fluent self
-
def
setrangeFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like setrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
shutdown(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command shutdown.
Redis command shutdown. * @return fluent self
-
def
shutdownFuture(args: Buffer[String]): Future[Option[Response]]
Like shutdown but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
sinter(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command sinter.
Redis command sinter. * @return fluent self
-
def
sinterFuture(args: Buffer[String]): Future[Option[Response]]
Like sinter but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
sinterstore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command sinterstore.
Redis command sinterstore. * @return fluent self
-
def
sinterstoreFuture(args: Buffer[String]): Future[Option[Response]]
Like sinterstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
sismember(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command sismember.
Redis command sismember. * @return fluent self
-
def
sismemberFuture(arg0: String, arg1: String): Future[Option[Response]]
Like sismember but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
slaveof(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command slaveof.
Redis command slaveof. * @return fluent self
-
def
slaveofFuture(arg0: String, arg1: String): Future[Option[Response]]
Like slaveof but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
slowlog(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command slowlog.
Redis command slowlog. * @return fluent self
-
def
slowlogFuture(args: Buffer[String]): Future[Option[Response]]
Like slowlog but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
smembers(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command smembers.
Redis command smembers. * @return fluent self
-
def
smembersFuture(arg0: String): Future[Option[Response]]
Like smembers but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
smove(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command smove.
Redis command smove. * @return fluent self
-
def
smoveFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like smove but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
sort(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command sort.
Redis command sort. * @return fluent self
-
def
sortFuture(args: Buffer[String]): Future[Option[Response]]
Like sort but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
spop(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command spop.
Redis command spop. * @return fluent self
-
def
spopFuture(args: Buffer[String]): Future[Option[Response]]
Like spop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
srandmember(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command srandmember.
Redis command srandmember. * @return fluent self
-
def
srandmemberFuture(args: Buffer[String]): Future[Option[Response]]
Like srandmember but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
srem(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command srem.
Redis command srem. * @return fluent self
-
def
sremFuture(args: Buffer[String]): Future[Option[Response]]
Like srem but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
sscan(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command sscan.
Redis command sscan. * @return fluent self
-
def
sscanFuture(args: Buffer[String]): Future[Option[Response]]
Like sscan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
strlen(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command strlen.
Redis command strlen. * @return fluent self
-
def
strlenFuture(arg0: String): Future[Option[Response]]
Like strlen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
subscribe(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command subscribe.
Redis command subscribe. * @return fluent self
-
def
subscribeFuture(args: Buffer[String]): Future[Option[Response]]
Like subscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
substr(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command substr.
Redis command substr. * @return fluent self
-
def
substrFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like substr but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
sunion(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command sunion.
Redis command sunion. * @return fluent self
-
def
sunionFuture(args: Buffer[String]): Future[Option[Response]]
Like sunion but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
sunionstore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command sunionstore.
Redis command sunionstore. * @return fluent self
-
def
sunionstoreFuture(args: Buffer[String]): Future[Option[Response]]
Like sunionstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
swapdb(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command swapdb.
Redis command swapdb. * @return fluent self
-
def
swapdbFuture(arg0: String, arg1: String): Future[Option[Response]]
Like swapdb but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
sync(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command sync.
Redis command sync. * @return fluent self
-
def
syncFuture(): Future[Option[Response]]
Like sync but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
time(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command time.
Redis command time. * @return fluent self
-
def
timeFuture(): Future[Option[Response]]
Like time but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
touch(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command touch.
Redis command touch. * @return fluent self
-
def
touchFuture(args: Buffer[String]): Future[Option[Response]]
Like touch but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
ttl(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command ttl.
Redis command ttl. * @return fluent self
-
def
ttlFuture(arg0: String): Future[Option[Response]]
Like ttl but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
type(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command type.
Redis command type. * @return fluent self
-
def
typeFuture(arg0: String): Future[Option[Response]]
Like type but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
unlink(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command unlink.
Redis command unlink. * @return fluent self
-
def
unlinkFuture(args: Buffer[String]): Future[Option[Response]]
Like unlink but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
unsubscribe(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command unsubscribe.
Redis command unsubscribe. * @return fluent self
-
def
unsubscribeFuture(args: Buffer[String]): Future[Option[Response]]
Like unsubscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
unwatch(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command unwatch.
Redis command unwatch. * @return fluent self
-
def
unwatchFuture(): Future[Option[Response]]
Like unwatch but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
wait(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command wait.
Redis command wait. * @return fluent self
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
waitFuture(arg0: String, arg1: String): Future[Option[Response]]
Like wait but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
watch(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command watch.
Redis command watch. * @return fluent self
-
def
watchFuture(args: Buffer[String]): Future[Option[Response]]
Like watch but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xack(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xack.
Redis command xack. * @return fluent self
-
def
xackFuture(args: Buffer[String]): Future[Option[Response]]
Like xack but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xadd(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xadd.
Redis command xadd. * @return fluent self
-
def
xaddFuture(args: Buffer[String]): Future[Option[Response]]
Like xadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xclaim(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xclaim.
Redis command xclaim. * @return fluent self
-
def
xclaimFuture(args: Buffer[String]): Future[Option[Response]]
Like xclaim but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xdel(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xdel.
Redis command xdel. * @return fluent self
-
def
xdelFuture(args: Buffer[String]): Future[Option[Response]]
Like xdel but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xgroup(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xgroup.
Redis command xgroup. * @return fluent self
-
def
xgroupFuture(args: Buffer[String]): Future[Option[Response]]
Like xgroup but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xinfo(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xinfo.
Redis command xinfo. * @return fluent self
-
def
xinfoFuture(args: Buffer[String]): Future[Option[Response]]
Like xinfo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xlen(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xlen.
Redis command xlen. * @return fluent self
-
def
xlenFuture(arg0: String): Future[Option[Response]]
Like xlen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xpending(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xpending.
Redis command xpending. * @return fluent self
-
def
xpendingFuture(args: Buffer[String]): Future[Option[Response]]
Like xpending but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xrange(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xrange.
Redis command xrange. * @return fluent self
-
def
xrangeFuture(args: Buffer[String]): Future[Option[Response]]
Like xrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xread(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xread.
Redis command xread. * @return fluent self
-
def
xreadFuture(args: Buffer[String]): Future[Option[Response]]
Like xread but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xreadgroup(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xreadgroup.
Redis command xreadgroup. * @return fluent self
-
def
xreadgroupFuture(args: Buffer[String]): Future[Option[Response]]
Like xreadgroup but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xrevrange(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xrevrange.
Redis command xrevrange. * @return fluent self
-
def
xrevrangeFuture(args: Buffer[String]): Future[Option[Response]]
Like xrevrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xsetid(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xsetid.
Redis command xsetid. * @return fluent self
-
def
xsetidFuture(arg0: String, arg1: String): Future[Option[Response]]
Like xsetid but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
xtrim(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command xtrim.
Redis command xtrim. * @return fluent self
-
def
xtrimFuture(args: Buffer[String]): Future[Option[Response]]
Like xtrim but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zadd(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zadd.
Redis command zadd. * @return fluent self
-
def
zaddFuture(args: Buffer[String]): Future[Option[Response]]
Like zadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zcard(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zcard.
Redis command zcard. * @return fluent self
-
def
zcardFuture(arg0: String): Future[Option[Response]]
Like zcard but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zcount(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zcount.
Redis command zcount. * @return fluent self
-
def
zcountFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like zcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zincrby(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zincrby.
Redis command zincrby. * @return fluent self
-
def
zincrbyFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like zincrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zinterstore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zinterstore.
Redis command zinterstore. * @return fluent self
-
def
zinterstoreFuture(args: Buffer[String]): Future[Option[Response]]
Like zinterstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zlexcount(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zlexcount.
Redis command zlexcount. * @return fluent self
-
def
zlexcountFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like zlexcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zpopmax(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zpopmax.
Redis command zpopmax. * @return fluent self
-
def
zpopmaxFuture(args: Buffer[String]): Future[Option[Response]]
Like zpopmax but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zpopmin(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zpopmin.
Redis command zpopmin. * @return fluent self
-
def
zpopminFuture(args: Buffer[String]): Future[Option[Response]]
Like zpopmin but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zrange(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zrange.
Redis command zrange. * @return fluent self
-
def
zrangeFuture(args: Buffer[String]): Future[Option[Response]]
Like zrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zrangebylex(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zrangebylex.
Redis command zrangebylex. * @return fluent self
-
def
zrangebylexFuture(args: Buffer[String]): Future[Option[Response]]
Like zrangebylex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zrangebyscore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zrangebyscore.
Redis command zrangebyscore. * @return fluent self
-
def
zrangebyscoreFuture(args: Buffer[String]): Future[Option[Response]]
Like zrangebyscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zrank(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zrank.
Redis command zrank. * @return fluent self
-
def
zrankFuture(arg0: String, arg1: String): Future[Option[Response]]
Like zrank but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zrem(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zrem.
Redis command zrem. * @return fluent self
-
def
zremFuture(args: Buffer[String]): Future[Option[Response]]
Like zrem but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zremrangebylex(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zremrangebylex.
Redis command zremrangebylex. * @return fluent self
-
def
zremrangebylexFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like zremrangebylex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zremrangebyrank(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zremrangebyrank.
Redis command zremrangebyrank. * @return fluent self
-
def
zremrangebyrankFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like zremrangebyrank but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zremrangebyscore(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zremrangebyscore.
Redis command zremrangebyscore. * @return fluent self
-
def
zremrangebyscoreFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]
Like zremrangebyscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zrevrange(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zrevrange.
Redis command zrevrange. * @return fluent self
-
def
zrevrangeFuture(args: Buffer[String]): Future[Option[Response]]
Like zrevrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zrevrangebylex(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zrevrangebylex.
Redis command zrevrangebylex. * @return fluent self
-
def
zrevrangebylexFuture(args: Buffer[String]): Future[Option[Response]]
Like zrevrangebylex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zrevrangebyscore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zrevrangebyscore.
Redis command zrevrangebyscore. * @return fluent self
-
def
zrevrangebyscoreFuture(args: Buffer[String]): Future[Option[Response]]
Like zrevrangebyscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zrevrank(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zrevrank.
Redis command zrevrank. * @return fluent self
-
def
zrevrankFuture(arg0: String, arg1: String): Future[Option[Response]]
Like zrevrank but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zscan(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zscan.
Redis command zscan. * @return fluent self
-
def
zscanFuture(args: Buffer[String]): Future[Option[Response]]
Like zscan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zscore(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zscore.
Redis command zscore. * @return fluent self
-
def
zscoreFuture(arg0: String, arg1: String): Future[Option[Response]]
Like zscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.
-
def
zunionstore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI
Redis command zunionstore.
Redis command zunionstore. * @return fluent self
-
def
zunionstoreFuture(args: Buffer[String]): Future[Option[Response]]
Like zunionstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.