StringsApi

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

def append(key: Key, value: Value): Result[Int]

Executes APPEND

final def asInstanceOf[T0]: T0

def bitcount(key: Key, range: commons.OptArg[(Int, Int)] = OptArg.Empty): Result[Long]

Executes BITCOUNT

def bitfield(key: Key, ops: Iterable[BitFieldOp]): Result[Seq[commons.Opt[Long]]]

Executes BITFIELD

def bitfield(key: Key, op: BitFieldOp, ops: BitFieldOp*): Result[Seq[commons.Opt[Long]]]

Executes BITFIELD

def bitfield(key: Key, op: BitFieldOp): Result[commons.Opt[Long]]

Executes BITFIELD

def bitop(multiOperation: MultiBitOp, destkey: Key, keys: Key*): Result[Int]

Executes BITOP

def bitopNot(destkey: Key, key: Key): Result[Int]

Executes BITOP

def bitpos(key: Key, bit: Boolean, start: Int, end: Int): Result[Long]

Executes BITPOS

def bitpos(key: Key, bit: Boolean, start: Int): Result[Long]

Executes BITPOS

def bitpos(key: Key, bit: Boolean): Result[Long]

Executes BITPOS

def clone(): AnyRef

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

Executes DECR

def decrby(key: Key, decrement: Long): Result[Long]

Executes DECRBY

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit final def fieldCodec: RedisDataCodec[Field]

def finalize(): Unit

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

Executes GET

final def getClass(): Class[_]

def getbit(key: Key, offset: Int): Result[Boolean]

Executes GETBIT

def getrange(key: Key, start: Int = 0, end: Int = 1): Result[Value]

Executes GETRANGE

def getset(key: Key, value: Value): Result[commons.Opt[Value]]

Executes GETSET

def hashCode(): Int

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

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

Executes INCR

def incrby(key: Key, increment: Long): Result[Long]

Executes INCRBY

def incrbyfloat(key: Key, increment: Double): Result[Double]

Executes INCRBYFLOAT

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 mget(keys: Iterable[Key]): Result[Seq[commons.Opt[Value]]]

Executes MGET or simply returns empty Seq when keys is empty, without sending the command to Redis

def mget(key: Key, keys: Key*): Result[Seq[commons.Opt[Value]]]

Executes MGET

def mset(keyValues: Iterable[(Key, Value)]): Result[Unit]

Executes MSET or does nothing when keyValues is empty, without sending the command to Redis

def mset(keyValue: (Key, Value), keyValues: (Key, Value)*): Result[Unit]

Executes MSET

def msetnx(keyValues: Iterable[(Key, Value)]): Result[Boolean]

Executes MSETNX or simply returns true when keyValues is empty, without sending the command to Redis

def msetnx(keyValue: (Key, Value), keyValues: (Key, Value)*): Result[Boolean]

Executes MSETNX

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def psetex(key: Key, milliseconds: Long, value: Value): Result[Unit]

Executes PSETEX

implicit final def recordCodec: RedisRecordCodec[Record]

def set(key: Key, value: Value, expiration: commons.OptArg[Expiration] = OptArg.Empty, existence: commons.OptArg[Boolean] = OptArg.Empty): Result[Boolean]

Executes SET

def setbit(key: Key, offset: Long, value: Boolean): Result[Boolean]

Executes SETBIT

def setex(key: Key, seconds: Long, value: Value): Result[Unit]

Executes SETEX

def setnx(key: Key, value: Value): Result[Boolean]

Executes SETNX

def setrange(key: Key, offset: Int, value: Value): Result[Int]

Executes SETRANGE

def strlen(key: Key): Result[Int]

Executes STRLEN

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