RedisCommand

abstract def decodeExpected: ReplyDecoder[A]

abstract def encoded: ArrayMsg[BulkStringMsg]

abstract def level: Level

final def !=(arg0: Any): Boolean

final def ##(): Int

def *>[B](other: RedisBatch[B]): RedisBatch[B]

Merges two batches into a single batch where result of the right-hand-side batch is returned while result of left-hand-side is discarded.

def <*[B](other: RedisBatch[B]): RedisBatch[A]

Merges two batches into a single batch where result of the left-hand-side batch is returned while result of right-hand-side is discarded.

def <*>[B, C](other: RedisBatch[B])(f: (A, B) ⇒ C): RedisBatch[C]

This is a symbolic alias for map2.

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def asking: RedisBatch[A]

Ensures that every keyed command in this batch is prepended with ASKING special command.

def atomic: RedisBatch[A]

Ensures that this batch is atomic, i.e.

def checkLevel(minAllowed: Level, clientType: String): Unit

def clone(): AnyRef

def createPreprocessor(replyCount: Int): RawCommand

def decode(replyMsg: RedisReply): A

def decodeReplies(replies: (Int) ⇒ RedisReply, idx: Index, inTransaction: Boolean): A

def emitCommandPacks(consumer: (RawCommandPack) ⇒ Unit): Unit

def emitCommands(consumer: (RawCommand) ⇒ Unit): Unit

final def encodedSize: Int

def encoder(commandName: String*): CommandEncoder

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def failed: RedisBatch[Throwable]

def finalize(): Unit

def foreachKey(consumer: (ByteString) ⇒ Unit): Unit

final def getClass(): Class[_]

def hashCode(): Int

def ignoreFailures: RedisBatch[Unit]

def isAsking: Boolean

final def isInstanceOf[T0]: Boolean

def map[B](fun: (A) ⇒ B): RedisCommand[B]

def map2[B, C](other: RedisBatch[B])(f: (A, B) ⇒ C): RedisBatch[C]

Merges two batches into one.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def operation: RedisOp[A]

Transforms this batch into a RedisOp.

def preprocess(message: RedisMsg, state: WatchState): misc.Opt[RedisMsg]

def rawCommandPacks: AtomicBatch[A]

def rawCommands(inTransaction: Boolean): RawCommand

def recover[B >: A](f: PartialFunction[Throwable, B]): RedisBatch[B]

def requireLevel(minAllowed: Level, clientType: String): RedisCommand.this.type

def requireNonEmpty(seq: TraversableOnce[Any], what: String): Unit

def single: commons.Opt[RawCommandPack]

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

def toString(): String

def transaction: RedisBatch[A]

Ensures that this batch is executed inside a MULTI-EXEC block.

def transform[B](fun: (commons.Try[A]) ⇒ commons.Try[B]): RedisBatch[B]

def tried: RedisBatch[commons.Try[A]]

def updateWatchState(message: RedisMsg, state: WatchState): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[B](other: RedisBatch[B]): RedisBatch[(A, B)]