Packages

class RedisAPI extends AnyRef

Auto generated Redis API client wrapper.

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. RedisAPI
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new RedisAPI(_asJava: AnyRef)

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def append(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command append.

    Redis command append. * @return fluent self

  5. def appendFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like append but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def asJava: AnyRef
  8. def asking(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command asking.

    Redis command asking. * @return fluent self

  9. def askingFuture(): Future[Option[Response]]

    Like asking but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  10. def auth(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command auth.

    Redis command auth. * @return fluent self

  11. def authFuture(arg0: String): Future[Option[Response]]

    Like auth but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  12. def bgrewriteaof(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command bgrewriteaof.

    Redis command bgrewriteaof. * @return fluent self

  13. def bgrewriteaofFuture(): Future[Option[Response]]

    Like bgrewriteaof but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  14. def bgsave(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command bgsave.

    Redis command bgsave. * @return fluent self

  15. def bgsaveFuture(args: Buffer[String]): Future[Option[Response]]

    Like bgsave but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  16. def bitcount(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command bitcount.

    Redis command bitcount. * @return fluent self

  17. def bitcountFuture(args: Buffer[String]): Future[Option[Response]]

    Like bitcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  18. def bitfield(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command bitfield.

    Redis command bitfield. * @return fluent self

  19. def bitfieldFuture(args: Buffer[String]): Future[Option[Response]]

    Like bitfield but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  20. def bitop(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command bitop.

    Redis command bitop. * @return fluent self

  21. def bitopFuture(args: Buffer[String]): Future[Option[Response]]

    Like bitop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  22. def bitpos(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command bitpos.

    Redis command bitpos. * @return fluent self

  23. def bitposFuture(args: Buffer[String]): Future[Option[Response]]

    Like bitpos but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  24. def blpop(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command blpop.

    Redis command blpop. * @return fluent self

  25. def blpopFuture(args: Buffer[String]): Future[Option[Response]]

    Like blpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  26. def brpop(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command brpop.

    Redis command brpop. * @return fluent self

  27. def brpopFuture(args: Buffer[String]): Future[Option[Response]]

    Like brpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  28. def brpoplpush(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command brpoplpush.

    Redis command brpoplpush. * @return fluent self

  29. def brpoplpushFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like brpoplpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  30. def bzpopmax(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command bzpopmax.

    Redis command bzpopmax. * @return fluent self

  31. def bzpopmaxFuture(args: Buffer[String]): Future[Option[Response]]

    Like bzpopmax but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  32. def bzpopmin(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command bzpopmin.

    Redis command bzpopmin. * @return fluent self

  33. def bzpopminFuture(args: Buffer[String]): Future[Option[Response]]

    Like bzpopmin but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  34. def client(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command client.

    Redis command client. * @return fluent self

  35. def clientFuture(args: Buffer[String]): Future[Option[Response]]

    Like client but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  36. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  37. def close(): Unit
  38. def cluster(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command cluster.

    Redis command cluster. * @return fluent self

  39. def clusterFuture(args: Buffer[String]): Future[Option[Response]]

    Like cluster but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  40. def command(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command command.

    Redis command command. * @return fluent self

  41. def commandFuture(): Future[Option[Response]]

    Like command but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  42. def config(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command config.

    Redis command config. * @return fluent self

  43. def configFuture(args: Buffer[String]): Future[Option[Response]]

    Like config but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  44. def dbsize(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command dbsize.

    Redis command dbsize. * @return fluent self

  45. def dbsizeFuture(): Future[Option[Response]]

    Like dbsize but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  46. def debug(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command debug.

    Redis command debug. * @return fluent self

  47. def debugFuture(args: Buffer[String]): Future[Option[Response]]

    Like debug but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  48. def decr(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command decr.

    Redis command decr. * @return fluent self

  49. def decrFuture(arg0: String): Future[Option[Response]]

    Like decr but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  50. def decrby(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command decrby.

    Redis command decrby. * @return fluent self

  51. def decrbyFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like decrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  52. def del(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command del.

    Redis command del. * @return fluent self

  53. def delFuture(args: Buffer[String]): Future[Option[Response]]

    Like del but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  54. def discard(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command discard.

    Redis command discard. * @return fluent self

  55. def discardFuture(): Future[Option[Response]]

    Like discard but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  56. def dump(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command dump.

    Redis command dump. * @return fluent self

  57. def dumpFuture(arg0: String): Future[Option[Response]]

    Like dump but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  58. def echo(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command echo.

    Redis command echo. * @return fluent self

  59. def echoFuture(arg0: String): Future[Option[Response]]

    Like echo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  60. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  61. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  62. def eval(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command eval.

    Redis command eval. * @return fluent self

  63. def evalFuture(args: Buffer[String]): Future[Option[Response]]

    Like eval but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  64. def evalsha(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command evalsha.

    Redis command evalsha. * @return fluent self

  65. def evalshaFuture(args: Buffer[String]): Future[Option[Response]]

    Like evalsha but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  66. def exec(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command exec.

    Redis command exec. * @return fluent self

  67. def execFuture(): Future[Option[Response]]

    Like exec but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  68. def exists(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command exists.

    Redis command exists. * @return fluent self

  69. def existsFuture(args: Buffer[String]): Future[Option[Response]]

    Like exists but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  70. def expire(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command expire.

    Redis command expire. * @return fluent self

  71. def expireFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like expire but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  72. def expireat(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command expireat.

    Redis command expireat. * @return fluent self

  73. def expireatFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like expireat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  74. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  75. def flushall(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command flushall.

    Redis command flushall. * @return fluent self

  76. def flushallFuture(args: Buffer[String]): Future[Option[Response]]

    Like flushall but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  77. def flushdb(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command flushdb.

    Redis command flushdb. * @return fluent self

  78. def flushdbFuture(args: Buffer[String]): Future[Option[Response]]

    Like flushdb but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  79. def geoadd(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command geoadd.

    Redis command geoadd. * @return fluent self

  80. def geoaddFuture(args: Buffer[String]): Future[Option[Response]]

    Like geoadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  81. def geodist(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command geodist.

    Redis command geodist. * @return fluent self

  82. def geodistFuture(args: Buffer[String]): Future[Option[Response]]

    Like geodist but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  83. def geohash(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command geohash.

    Redis command geohash. * @return fluent self

  84. def geohashFuture(args: Buffer[String]): Future[Option[Response]]

    Like geohash but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  85. def geopos(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command geopos.

    Redis command geopos. * @return fluent self

  86. def geoposFuture(args: Buffer[String]): Future[Option[Response]]

    Like geopos but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  87. def georadius(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command georadius.

    Redis command georadius. * @return fluent self

  88. def georadiusFuture(args: Buffer[String]): Future[Option[Response]]

    Like georadius but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  89. def georadiusRo(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command georadiusRo.

    Redis command georadiusRo. * @return fluent self

  90. def georadiusRoFuture(args: Buffer[String]): Future[Option[Response]]

    Like georadiusRo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  91. def georadiusbymember(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command georadiusbymember.

    Redis command georadiusbymember. * @return fluent self

  92. def georadiusbymemberFuture(args: Buffer[String]): Future[Option[Response]]

    Like georadiusbymember but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  93. def georadiusbymemberRo(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command georadiusbymemberRo.

    Redis command georadiusbymemberRo. * @return fluent self

  94. def georadiusbymemberRoFuture(args: Buffer[String]): Future[Option[Response]]

    Like georadiusbymemberRo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  95. def get(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command get.

    Redis command get. * @return fluent self

  96. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  97. def getFuture(arg0: String): Future[Option[Response]]

    Like get but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  98. def getbit(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command getbit.

    Redis command getbit. * @return fluent self

  99. def getbitFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like getbit but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  100. def getrange(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command getrange.

    Redis command getrange. * @return fluent self

  101. def getrangeFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like getrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  102. def getset(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command getset.

    Redis command getset. * @return fluent self

  103. def getsetFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like getset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  104. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  105. def hdel(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hdel.

    Redis command hdel. * @return fluent self

  106. def hdelFuture(args: Buffer[String]): Future[Option[Response]]

    Like hdel but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  107. def hexists(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hexists.

    Redis command hexists. * @return fluent self

  108. def hexistsFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like hexists but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  109. def hget(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hget.

    Redis command hget. * @return fluent self

  110. def hgetFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like hget but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  111. def hgetall(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hgetall.

    Redis command hgetall. * @return fluent self

  112. def hgetallFuture(arg0: String): Future[Option[Response]]

    Like hgetall but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  113. def hincrby(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hincrby.

    Redis command hincrby. * @return fluent self

  114. def hincrbyFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like hincrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  115. def hincrbyfloat(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hincrbyfloat.

    Redis command hincrbyfloat. * @return fluent self

  116. def hincrbyfloatFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like hincrbyfloat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  117. def hkeys(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hkeys.

    Redis command hkeys. * @return fluent self

  118. def hkeysFuture(arg0: String): Future[Option[Response]]

    Like hkeys but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  119. def hlen(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hlen.

    Redis command hlen. * @return fluent self

  120. def hlenFuture(arg0: String): Future[Option[Response]]

    Like hlen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  121. def hmget(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hmget.

    Redis command hmget. * @return fluent self

  122. def hmgetFuture(args: Buffer[String]): Future[Option[Response]]

    Like hmget but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  123. def hmset(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hmset.

    Redis command hmset. * @return fluent self

  124. def hmsetFuture(args: Buffer[String]): Future[Option[Response]]

    Like hmset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  125. def host(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command host.

    Redis command host. * @return fluent self

  126. def hostFuture(args: Buffer[String]): Future[Option[Response]]

    Like host but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  127. def hscan(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hscan.

    Redis command hscan. * @return fluent self

  128. def hscanFuture(args: Buffer[String]): Future[Option[Response]]

    Like hscan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  129. def hset(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hset.

    Redis command hset. * @return fluent self

  130. def hsetFuture(args: Buffer[String]): Future[Option[Response]]

    Like hset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  131. def hsetnx(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hsetnx.

    Redis command hsetnx. * @return fluent self

  132. def hsetnxFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like hsetnx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  133. def hstrlen(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hstrlen.

    Redis command hstrlen. * @return fluent self

  134. def hstrlenFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like hstrlen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  135. def hvals(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command hvals.

    Redis command hvals. * @return fluent self

  136. def hvalsFuture(arg0: String): Future[Option[Response]]

    Like hvals but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  137. def incr(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command incr.

    Redis command incr. * @return fluent self

  138. def incrFuture(arg0: String): Future[Option[Response]]

    Like incr but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  139. def incrby(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command incrby.

    Redis command incrby. * @return fluent self

  140. def incrbyFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like incrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  141. def incrbyfloat(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command incrbyfloat.

    Redis command incrbyfloat. * @return fluent self

  142. def incrbyfloatFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like incrbyfloat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  143. def info(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command info.

    Redis command info. * @return fluent self

  144. def infoFuture(args: Buffer[String]): Future[Option[Response]]

    Like info but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  145. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  146. def keys(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command keys.

    Redis command keys. * @return fluent self

  147. def keysFuture(arg0: String): Future[Option[Response]]

    Like keys but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  148. def lastsave(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command lastsave.

    Redis command lastsave. * @return fluent self

  149. def lastsaveFuture(): Future[Option[Response]]

    Like lastsave but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  150. def latency(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command latency.

    Redis command latency. * @return fluent self

  151. def latencyFuture(args: Buffer[String]): Future[Option[Response]]

    Like latency but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  152. def lindex(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command lindex.

    Redis command lindex. * @return fluent self

  153. def lindexFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like lindex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  154. 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

  155. 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.

  156. def llen(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command llen.

    Redis command llen. * @return fluent self

  157. def llenFuture(arg0: String): Future[Option[Response]]

    Like llen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  158. def lolwut(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command lolwut.

    Redis command lolwut. * @return fluent self

  159. def lolwutFuture(args: Buffer[String]): Future[Option[Response]]

    Like lolwut but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  160. def lpop(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command lpop.

    Redis command lpop. * @return fluent self

  161. def lpopFuture(arg0: String): Future[Option[Response]]

    Like lpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  162. def lpush(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command lpush.

    Redis command lpush. * @return fluent self

  163. def lpushFuture(args: Buffer[String]): Future[Option[Response]]

    Like lpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  164. def lpushx(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command lpushx.

    Redis command lpushx. * @return fluent self

  165. def lpushxFuture(args: Buffer[String]): Future[Option[Response]]

    Like lpushx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  166. def lrange(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command lrange.

    Redis command lrange. * @return fluent self

  167. def lrangeFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like lrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  168. def lrem(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command lrem.

    Redis command lrem. * @return fluent self

  169. def lremFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like lrem but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  170. def lset(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command lset.

    Redis command lset. * @return fluent self

  171. def lsetFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like lset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  172. def ltrim(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command ltrim.

    Redis command ltrim. * @return fluent self

  173. def ltrimFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like ltrim but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  174. def memory(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command memory.

    Redis command memory. * @return fluent self

  175. def memoryFuture(args: Buffer[String]): Future[Option[Response]]

    Like memory but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  176. def mget(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command mget.

    Redis command mget. * @return fluent self

  177. def mgetFuture(args: Buffer[String]): Future[Option[Response]]

    Like mget but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  178. def migrate(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command migrate.

    Redis command migrate. * @return fluent self

  179. def migrateFuture(args: Buffer[String]): Future[Option[Response]]

    Like migrate but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  180. def module(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command module.

    Redis command module. * @return fluent self

  181. def moduleFuture(args: Buffer[String]): Future[Option[Response]]

    Like module but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  182. def monitor(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command monitor.

    Redis command monitor. * @return fluent self

  183. def monitorFuture(): Future[Option[Response]]

    Like monitor but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  184. def move(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command move.

    Redis command move. * @return fluent self

  185. def moveFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like move but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  186. def mset(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command mset.

    Redis command mset. * @return fluent self

  187. def msetFuture(args: Buffer[String]): Future[Option[Response]]

    Like mset but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  188. def msetnx(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command msetnx.

    Redis command msetnx. * @return fluent self

  189. def msetnxFuture(args: Buffer[String]): Future[Option[Response]]

    Like msetnx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  190. def multi(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command multi.

    Redis command multi. * @return fluent self

  191. def multiFuture(): Future[Option[Response]]

    Like multi but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  192. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  193. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  194. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  195. def object(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command object.

    Redis command object. * @return fluent self

  196. def objectFuture(args: Buffer[String]): Future[Option[Response]]

    Like object but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  197. def persist(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command persist.

    Redis command persist. * @return fluent self

  198. def persistFuture(arg0: String): Future[Option[Response]]

    Like persist but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  199. def pexpire(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command pexpire.

    Redis command pexpire. * @return fluent self

  200. def pexpireFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like pexpire but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  201. def pexpireat(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command pexpireat.

    Redis command pexpireat. * @return fluent self

  202. def pexpireatFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like pexpireat but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  203. def pfadd(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command pfadd.

    Redis command pfadd. * @return fluent self

  204. def pfaddFuture(args: Buffer[String]): Future[Option[Response]]

    Like pfadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  205. def pfcount(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command pfcount.

    Redis command pfcount. * @return fluent self

  206. def pfcountFuture(args: Buffer[String]): Future[Option[Response]]

    Like pfcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  207. def pfdebug(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command pfdebug.

    Redis command pfdebug. * @return fluent self

  208. def pfdebugFuture(args: Buffer[String]): Future[Option[Response]]

    Like pfdebug but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  209. def pfmerge(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command pfmerge.

    Redis command pfmerge. * @return fluent self

  210. def pfmergeFuture(args: Buffer[String]): Future[Option[Response]]

    Like pfmerge but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  211. def pfselftest(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command pfselftest.

    Redis command pfselftest. * @return fluent self

  212. def pfselftestFuture(): Future[Option[Response]]

    Like pfselftest but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  213. def ping(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command ping.

    Redis command ping. * @return fluent self

  214. def pingFuture(args: Buffer[String]): Future[Option[Response]]

    Like ping but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  215. def post(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command post.

    Redis command post. * @return fluent self

  216. def postFuture(args: Buffer[String]): Future[Option[Response]]

    Like post but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  217. def psetex(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command psetex.

    Redis command psetex. * @return fluent self

  218. def psetexFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like psetex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  219. def psubscribe(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command psubscribe.

    Redis command psubscribe. * @return fluent self

  220. def psubscribeFuture(args: Buffer[String]): Future[Option[Response]]

    Like psubscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  221. def psync(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command psync.

    Redis command psync. * @return fluent self

  222. def psyncFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like psync but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  223. def pttl(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command pttl.

    Redis command pttl. * @return fluent self

  224. def pttlFuture(arg0: String): Future[Option[Response]]

    Like pttl but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  225. def publish(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command publish.

    Redis command publish. * @return fluent self

  226. def publishFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like publish but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  227. def pubsub(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command pubsub.

    Redis command pubsub. * @return fluent self

  228. def pubsubFuture(args: Buffer[String]): Future[Option[Response]]

    Like pubsub but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  229. def punsubscribe(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command punsubscribe.

    Redis command punsubscribe. * @return fluent self

  230. def punsubscribeFuture(args: Buffer[String]): Future[Option[Response]]

    Like punsubscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  231. def randomkey(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command randomkey.

    Redis command randomkey. * @return fluent self

  232. def randomkeyFuture(): Future[Option[Response]]

    Like randomkey but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  233. def readonly(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command readonly.

    Redis command readonly. * @return fluent self

  234. def readonlyFuture(): Future[Option[Response]]

    Like readonly but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  235. def readwrite(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command readwrite.

    Redis command readwrite. * @return fluent self

  236. def readwriteFuture(): Future[Option[Response]]

    Like readwrite but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  237. def rename(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command rename.

    Redis command rename. * @return fluent self

  238. def renameFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like rename but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  239. def renamenx(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command renamenx.

    Redis command renamenx. * @return fluent self

  240. def renamenxFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like renamenx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  241. def replconf(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command replconf.

    Redis command replconf. * @return fluent self

  242. def replconfFuture(args: Buffer[String]): Future[Option[Response]]

    Like replconf but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  243. def replicaof(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command replicaof.

    Redis command replicaof. * @return fluent self

  244. def replicaofFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like replicaof but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  245. def restore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command restore.

    Redis command restore. * @return fluent self

  246. def restoreAsking(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command restoreAsking.

    Redis command restoreAsking. * @return fluent self

  247. def restoreAskingFuture(args: Buffer[String]): Future[Option[Response]]

    Like restoreAsking but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  248. def restoreFuture(args: Buffer[String]): Future[Option[Response]]

    Like restore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  249. def role(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command role.

    Redis command role. * @return fluent self

  250. def roleFuture(): Future[Option[Response]]

    Like role but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  251. def rpop(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command rpop.

    Redis command rpop. * @return fluent self

  252. def rpopFuture(arg0: String): Future[Option[Response]]

    Like rpop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  253. def rpoplpush(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command rpoplpush.

    Redis command rpoplpush. * @return fluent self

  254. def rpoplpushFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like rpoplpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  255. def rpush(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command rpush.

    Redis command rpush. * @return fluent self

  256. def rpushFuture(args: Buffer[String]): Future[Option[Response]]

    Like rpush but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  257. def rpushx(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command rpushx.

    Redis command rpushx. * @return fluent self

  258. def rpushxFuture(args: Buffer[String]): Future[Option[Response]]

    Like rpushx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  259. def sadd(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command sadd.

    Redis command sadd. * @return fluent self

  260. def saddFuture(args: Buffer[String]): Future[Option[Response]]

    Like sadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  261. def save(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command save.

    Redis command save. * @return fluent self

  262. def saveFuture(): Future[Option[Response]]

    Like save but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  263. def scan(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command scan.

    Redis command scan. * @return fluent self

  264. def scanFuture(args: Buffer[String]): Future[Option[Response]]

    Like scan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  265. def scard(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command scard.

    Redis command scard. * @return fluent self

  266. def scardFuture(arg0: String): Future[Option[Response]]

    Like scard but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  267. def script(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command script.

    Redis command script. * @return fluent self

  268. def scriptFuture(args: Buffer[String]): Future[Option[Response]]

    Like script but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  269. def sdiff(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command sdiff.

    Redis command sdiff. * @return fluent self

  270. def sdiffFuture(args: Buffer[String]): Future[Option[Response]]

    Like sdiff but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  271. def sdiffstore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command sdiffstore.

    Redis command sdiffstore. * @return fluent self

  272. def sdiffstoreFuture(args: Buffer[String]): Future[Option[Response]]

    Like sdiffstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  273. def select(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command select.

    Redis command select. * @return fluent self

  274. def selectFuture(arg0: String): Future[Option[Response]]

    Like select but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  275. def set(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command set.

    Redis command set. * @return fluent self

  276. def setFuture(args: Buffer[String]): Future[Option[Response]]

    Like set but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  277. def setbit(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command setbit.

    Redis command setbit. * @return fluent self

  278. def setbitFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like setbit but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  279. def setex(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command setex.

    Redis command setex. * @return fluent self

  280. def setexFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like setex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  281. def setnx(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command setnx.

    Redis command setnx. * @return fluent self

  282. def setnxFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like setnx but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  283. def setrange(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command setrange.

    Redis command setrange. * @return fluent self

  284. def setrangeFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like setrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  285. def shutdown(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command shutdown.

    Redis command shutdown. * @return fluent self

  286. def shutdownFuture(args: Buffer[String]): Future[Option[Response]]

    Like shutdown but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  287. def sinter(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command sinter.

    Redis command sinter. * @return fluent self

  288. def sinterFuture(args: Buffer[String]): Future[Option[Response]]

    Like sinter but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  289. def sinterstore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command sinterstore.

    Redis command sinterstore. * @return fluent self

  290. def sinterstoreFuture(args: Buffer[String]): Future[Option[Response]]

    Like sinterstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  291. def sismember(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command sismember.

    Redis command sismember. * @return fluent self

  292. def sismemberFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like sismember but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  293. def slaveof(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command slaveof.

    Redis command slaveof. * @return fluent self

  294. def slaveofFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like slaveof but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  295. def slowlog(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command slowlog.

    Redis command slowlog. * @return fluent self

  296. def slowlogFuture(args: Buffer[String]): Future[Option[Response]]

    Like slowlog but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  297. def smembers(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command smembers.

    Redis command smembers. * @return fluent self

  298. def smembersFuture(arg0: String): Future[Option[Response]]

    Like smembers but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  299. def smove(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command smove.

    Redis command smove. * @return fluent self

  300. def smoveFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like smove but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  301. def sort(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command sort.

    Redis command sort. * @return fluent self

  302. def sortFuture(args: Buffer[String]): Future[Option[Response]]

    Like sort but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  303. def spop(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command spop.

    Redis command spop. * @return fluent self

  304. def spopFuture(args: Buffer[String]): Future[Option[Response]]

    Like spop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  305. def srandmember(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command srandmember.

    Redis command srandmember. * @return fluent self

  306. def srandmemberFuture(args: Buffer[String]): Future[Option[Response]]

    Like srandmember but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  307. def srem(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command srem.

    Redis command srem. * @return fluent self

  308. def sremFuture(args: Buffer[String]): Future[Option[Response]]

    Like srem but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  309. def sscan(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command sscan.

    Redis command sscan. * @return fluent self

  310. def sscanFuture(args: Buffer[String]): Future[Option[Response]]

    Like sscan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  311. def strlen(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command strlen.

    Redis command strlen. * @return fluent self

  312. def strlenFuture(arg0: String): Future[Option[Response]]

    Like strlen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  313. def subscribe(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command subscribe.

    Redis command subscribe. * @return fluent self

  314. def subscribeFuture(args: Buffer[String]): Future[Option[Response]]

    Like subscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  315. def substr(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command substr.

    Redis command substr. * @return fluent self

  316. def substrFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like substr but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  317. def sunion(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command sunion.

    Redis command sunion. * @return fluent self

  318. def sunionFuture(args: Buffer[String]): Future[Option[Response]]

    Like sunion but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  319. def sunionstore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command sunionstore.

    Redis command sunionstore. * @return fluent self

  320. def sunionstoreFuture(args: Buffer[String]): Future[Option[Response]]

    Like sunionstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  321. def swapdb(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command swapdb.

    Redis command swapdb. * @return fluent self

  322. def swapdbFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like swapdb but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  323. def sync(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command sync.

    Redis command sync. * @return fluent self

  324. def syncFuture(): Future[Option[Response]]

    Like sync but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  325. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  326. def time(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command time.

    Redis command time. * @return fluent self

  327. def timeFuture(): Future[Option[Response]]

    Like time but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  328. def toString(): String
    Definition Classes
    AnyRef → Any
  329. def touch(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command touch.

    Redis command touch. * @return fluent self

  330. def touchFuture(args: Buffer[String]): Future[Option[Response]]

    Like touch but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  331. def ttl(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command ttl.

    Redis command ttl. * @return fluent self

  332. def ttlFuture(arg0: String): Future[Option[Response]]

    Like ttl but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  333. def type(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command type.

    Redis command type. * @return fluent self

  334. def typeFuture(arg0: String): Future[Option[Response]]

    Like type but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  335. def unlink(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command unlink.

    Redis command unlink. * @return fluent self

  336. def unlinkFuture(args: Buffer[String]): Future[Option[Response]]

    Like unlink but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  337. def unsubscribe(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command unsubscribe.

    Redis command unsubscribe. * @return fluent self

  338. def unsubscribeFuture(args: Buffer[String]): Future[Option[Response]]

    Like unsubscribe but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  339. def unwatch(handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command unwatch.

    Redis command unwatch. * @return fluent self

  340. def unwatchFuture(): Future[Option[Response]]

    Like unwatch but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  341. def wait(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command wait.

    Redis command wait. * @return fluent self

  342. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  343. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  344. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  345. def waitFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like wait but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  346. def watch(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command watch.

    Redis command watch. * @return fluent self

  347. def watchFuture(args: Buffer[String]): Future[Option[Response]]

    Like watch but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  348. def xack(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xack.

    Redis command xack. * @return fluent self

  349. def xackFuture(args: Buffer[String]): Future[Option[Response]]

    Like xack but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  350. def xadd(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xadd.

    Redis command xadd. * @return fluent self

  351. def xaddFuture(args: Buffer[String]): Future[Option[Response]]

    Like xadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  352. def xclaim(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xclaim.

    Redis command xclaim. * @return fluent self

  353. def xclaimFuture(args: Buffer[String]): Future[Option[Response]]

    Like xclaim but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  354. def xdel(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xdel.

    Redis command xdel. * @return fluent self

  355. def xdelFuture(args: Buffer[String]): Future[Option[Response]]

    Like xdel but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  356. def xgroup(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xgroup.

    Redis command xgroup. * @return fluent self

  357. def xgroupFuture(args: Buffer[String]): Future[Option[Response]]

    Like xgroup but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  358. def xinfo(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xinfo.

    Redis command xinfo. * @return fluent self

  359. def xinfoFuture(args: Buffer[String]): Future[Option[Response]]

    Like xinfo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  360. def xlen(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xlen.

    Redis command xlen. * @return fluent self

  361. def xlenFuture(arg0: String): Future[Option[Response]]

    Like xlen but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  362. def xpending(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xpending.

    Redis command xpending. * @return fluent self

  363. def xpendingFuture(args: Buffer[String]): Future[Option[Response]]

    Like xpending but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  364. def xrange(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xrange.

    Redis command xrange. * @return fluent self

  365. def xrangeFuture(args: Buffer[String]): Future[Option[Response]]

    Like xrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  366. def xread(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xread.

    Redis command xread. * @return fluent self

  367. def xreadFuture(args: Buffer[String]): Future[Option[Response]]

    Like xread but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  368. def xreadgroup(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xreadgroup.

    Redis command xreadgroup. * @return fluent self

  369. def xreadgroupFuture(args: Buffer[String]): Future[Option[Response]]

    Like xreadgroup but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  370. def xrevrange(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xrevrange.

    Redis command xrevrange. * @return fluent self

  371. def xrevrangeFuture(args: Buffer[String]): Future[Option[Response]]

    Like xrevrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  372. def xsetid(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xsetid.

    Redis command xsetid. * @return fluent self

  373. def xsetidFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like xsetid but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  374. def xtrim(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command xtrim.

    Redis command xtrim. * @return fluent self

  375. def xtrimFuture(args: Buffer[String]): Future[Option[Response]]

    Like xtrim but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  376. def zadd(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zadd.

    Redis command zadd. * @return fluent self

  377. def zaddFuture(args: Buffer[String]): Future[Option[Response]]

    Like zadd but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  378. def zcard(arg0: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zcard.

    Redis command zcard. * @return fluent self

  379. def zcardFuture(arg0: String): Future[Option[Response]]

    Like zcard but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  380. def zcount(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zcount.

    Redis command zcount. * @return fluent self

  381. def zcountFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like zcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  382. def zincrby(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zincrby.

    Redis command zincrby. * @return fluent self

  383. def zincrbyFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like zincrby but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  384. def zinterstore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zinterstore.

    Redis command zinterstore. * @return fluent self

  385. def zinterstoreFuture(args: Buffer[String]): Future[Option[Response]]

    Like zinterstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  386. def zlexcount(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zlexcount.

    Redis command zlexcount. * @return fluent self

  387. def zlexcountFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like zlexcount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  388. def zpopmax(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zpopmax.

    Redis command zpopmax. * @return fluent self

  389. def zpopmaxFuture(args: Buffer[String]): Future[Option[Response]]

    Like zpopmax but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  390. def zpopmin(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zpopmin.

    Redis command zpopmin. * @return fluent self

  391. def zpopminFuture(args: Buffer[String]): Future[Option[Response]]

    Like zpopmin but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  392. def zrange(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zrange.

    Redis command zrange. * @return fluent self

  393. def zrangeFuture(args: Buffer[String]): Future[Option[Response]]

    Like zrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  394. def zrangebylex(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zrangebylex.

    Redis command zrangebylex. * @return fluent self

  395. def zrangebylexFuture(args: Buffer[String]): Future[Option[Response]]

    Like zrangebylex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  396. def zrangebyscore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zrangebyscore.

    Redis command zrangebyscore. * @return fluent self

  397. def zrangebyscoreFuture(args: Buffer[String]): Future[Option[Response]]

    Like zrangebyscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  398. def zrank(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zrank.

    Redis command zrank. * @return fluent self

  399. def zrankFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like zrank but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  400. def zrem(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zrem.

    Redis command zrem. * @return fluent self

  401. def zremFuture(args: Buffer[String]): Future[Option[Response]]

    Like zrem but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  402. def zremrangebylex(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zremrangebylex.

    Redis command zremrangebylex. * @return fluent self

  403. def zremrangebylexFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like zremrangebylex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  404. def zremrangebyrank(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zremrangebyrank.

    Redis command zremrangebyrank. * @return fluent self

  405. def zremrangebyrankFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like zremrangebyrank but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  406. def zremrangebyscore(arg0: String, arg1: String, arg2: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zremrangebyscore.

    Redis command zremrangebyscore. * @return fluent self

  407. def zremrangebyscoreFuture(arg0: String, arg1: String, arg2: String): Future[Option[Response]]

    Like zremrangebyscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  408. def zrevrange(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zrevrange.

    Redis command zrevrange. * @return fluent self

  409. def zrevrangeFuture(args: Buffer[String]): Future[Option[Response]]

    Like zrevrange but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  410. def zrevrangebylex(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zrevrangebylex.

    Redis command zrevrangebylex. * @return fluent self

  411. def zrevrangebylexFuture(args: Buffer[String]): Future[Option[Response]]

    Like zrevrangebylex but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  412. def zrevrangebyscore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zrevrangebyscore.

    Redis command zrevrangebyscore. * @return fluent self

  413. def zrevrangebyscoreFuture(args: Buffer[String]): Future[Option[Response]]

    Like zrevrangebyscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  414. def zrevrank(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zrevrank.

    Redis command zrevrank. * @return fluent self

  415. def zrevrankFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like zrevrank but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  416. def zscan(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zscan.

    Redis command zscan. * @return fluent self

  417. def zscanFuture(args: Buffer[String]): Future[Option[Response]]

    Like zscan but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  418. def zscore(arg0: String, arg1: String, handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zscore.

    Redis command zscore. * @return fluent self

  419. def zscoreFuture(arg0: String, arg1: String): Future[Option[Response]]

    Like zscore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  420. def zunionstore(args: Buffer[String], handler: Handler[AsyncResult[Option[Response]]]): RedisAPI

    Redis command zunionstore.

    Redis command zunionstore. * @return fluent self

  421. def zunionstoreFuture(args: Buffer[String]): Future[Option[Response]]

    Like zunionstore but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

Inherited from AnyRef

Inherited from Any

Ungrouped