ListsApi

abstract def execute[A](command: RedisCommand[A]): Result[A]

abstract val serialization: RedisSerialization

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def blpop(keys: Iterable[Key], timeout: Int): Result[commons.Opt[(Key, Value)]]

Executes BLPOP

def blpop(key: Key, timeout: Int): Result[commons.Opt[Value]]

Executes BLPOP

def brpop(keys: Iterable[Key], timeout: Int): Result[commons.Opt[(Key, Value)]]

Executes BRPOP

def brpop(key: Key, timeout: Int): Result[commons.Opt[Value]]

Executes BRPOP

def brpoplpush(source: Key, destination: Key, timeout: Int): Result[commons.Opt[Value]]

Executes BRPOPLPUSH

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit final def fieldCodec: RedisDataCodec[Field]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

implicit def headOps[T](head: T): HeadOps[T]

final def isInstanceOf[T0]: Boolean

implicit def iterableTailOps[T](tail: Iterable[T]): IterableTailOps[T]

implicit def iteratorTailOps[T](tail: Iterator[T]): IteratorTailOps[T]

implicit final def keyCodec: RedisDataCodec[Key]

def lindex(key: Key, index: Long): Result[commons.Opt[Value]]

Executes LINDEX

def linsert(key: Key, pivot: Value, value: Value, before: Boolean = false): Result[commons.Opt[Long]]

Executes LINSERT

def llen(key: Key): Result[Long]

Executes LLEN

def lpop(key: Key): Result[commons.Opt[Value]]

Executes LPOP

def lpush(key: Key, values: Iterable[Value]): Result[Long]

Executes LPUSH NOTE: values MUST NOT be empty - consider using lpushOrLlen in such case.

def lpush(key: Key, value: Value, values: Value*): Result[Long]

Executes LPUSH

def lpushOrLlen(key: Key, values: Iterable[Value]): Result[Long]

Executes LPUSH or LLEN when values is empty

def lpushx(key: Key, values: Iterable[Value]): Result[Long]

Executes LPUSHX

def lpushx(key: Key, value: Value, values: Value*): Result[Long]

Executes LPUSHX

def lpushxOrLlen(key: Key, values: Iterable[Value]): Result[Long]

Executes LPUSHX or LLEN when values is empty

def lrange(key: Key, start: Long = 0, stop: Long = 1): Result[Seq[Value]]

Executes LRANGE

def lrem(key: Key, value: Value, count: RemCount = RemCount.All): Result[Long]

Executes LREM

def lset(key: Key, index: Long, value: Value): Result[Unit]

Executes LSET

def ltrim(key: Key, start: Long = 0, stop: Long = 1): Result[Unit]

Executes LTRIM

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit final def recordCodec: RedisRecordCodec[Record]

def rpop(key: Key): Result[commons.Opt[Value]]

Executes RPOP

def rpoplpush(source: Key, destination: Key): Result[commons.Opt[Value]]

Executes RPOPLPUSH

def rpush(key: Key, values: Iterable[Value]): Result[Long]

Executes RPUSH NOTE: values MUST NOT be empty - consider using rpushOrLlen in such case.

def rpush(key: Key, value: Value, values: Value*): Result[Long]

Executes RPUSH

def rpushOrLlen(key: Key, values: Iterable[Value]): Result[Long]

Executes RPUSH or LLEN when values is empty

def rpushx(key: Key, values: Iterable[Value]): Result[Long]

Executes RPUSHX

def rpushx(key: Key, value: Value, values: Value*): Result[Long]

Executes RPUSHX

def rpushxOrLlen(key: Key, values: Iterable[Value]): Result[Long]

Executes RPUSHX or LLEN when values is empty

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

implicit final def valueCodec: RedisDataCodec[Value]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit