Packages

final class Transaction[+A] extends SinglePackBatch[A]

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Transaction
  2. SinglePackBatch
  3. RawCommandPack
  4. RawCommandPacks
  5. RedisBatch
  6. AnyRef
  7. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Transaction(batch: RedisBatch[A])

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. 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.

    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. Useful when left-hand-side returns Unit. NOTE: errors for left-hand-side are NOT discarded, use ignoreFailures on it if that's your intention.

    Definition Classes
    RedisBatch
  4. 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.

    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. Useful when right-hand-side returns Unit. NOTE: errors for right-hand-side are NOT discarded, use ignoreFailures on it if that's your intention.

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

    This is a symbolic alias for map2.

    This is a symbolic alias for map2. The symbol (along with *> and <*) is inspired by its Haskell equivalent.

    Definition Classes
    RedisBatch
  6. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  7. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  8. def asking: RedisBatch[A]

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

    Ensures that every keyed command in this batch is prepended with ASKING special command. This is necessary only when manually handling Redis Cluster redirections.

    Definition Classes
    RedisBatch
  9. def atomic: RedisBatch[A]

    Returns a batch which invokes the same commands as this batch but atomically.

    Returns a batch which invokes the same commands as this batch but atomically. If this batch is already atomic then it's returned unchanged. Otherwise, it's wrapped into a Redis transaction (MULTI-EXEC block). Empty batches, single-command batches and transactions are atomic by themselves and therefore are returned unchanged.

    Definition Classes
    RedisBatch
  10. def checkLevel(minAllowed: Level, clientType: String): Unit
    Definition Classes
    TransactionRawCommandPack
  11. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  12. final def computeSize(limit: Int): Int
    Definition Classes
    RawCommandPackRawCommandPacks
  13. def createPreprocessor(replyCount: Int): ReplyPreprocessor
    Definition Classes
    TransactionRawCommandPack
  14. def decodeReplies(replies: (Int) ⇒ RedisReply, index: Index, inTransaction: Boolean): A
    Definition Classes
    TransactionRedisBatch
  15. final def emitCommandPacks(consumer: (RawCommandPack) ⇒ Unit): Unit
    Definition Classes
    RawCommandPackRawCommandPacks
  16. final def encodedSize: Int
    Definition Classes
    RawCommandPacks
  17. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  18. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  19. def failed: RedisBatch[Throwable]
    Definition Classes
    RedisBatch
  20. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  21. final def foreachKey(consumer: (ByteString) ⇒ Unit): Unit
    Definition Classes
    RawCommandPacks
  22. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  23. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  24. def ignoreFailures: RedisBatch[Unit]
    Definition Classes
    RedisBatch
  25. def isAsking: Boolean
    Definition Classes
    RawCommandPack
  26. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  27. def map[B](f: (A) ⇒ B): RedisBatch[B]
    Definition Classes
    RedisBatch
  28. def map2[B, C](other: RedisBatch[B])(f: (A, B) ⇒ C): RedisBatch[C]

    Merges two batches into one.

    Merges two batches into one. Provided function is applied on results of the batches being merged to obtain result of the merged batch. map2 is the fundamental primitive for composing multiple batches into one.

    Definition Classes
    RedisBatch
  29. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  30. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  31. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  32. def operation: RedisOp[A]

    Transforms this batch into a RedisOp.

    Transforms this batch into a RedisOp.

    Definition Classes
    RedisBatch
  33. final def rawCommandPacks: SinglePackBatch[A]
    Definition Classes
    SinglePackBatchRedisBatch
  34. def rawCommands(inTransaction: Boolean): RawCommands
    Definition Classes
    TransactionRawCommandPack
  35. def recover[B >: A](f: PartialFunction[Throwable, B]): RedisBatch[B]
    Definition Classes
    RedisBatch
  36. final def requireLevel(minAllowed: Level, clientType: String): Transaction.this.type
    Definition Classes
    RawCommandPacks
  37. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  38. def toString(): String
    Definition Classes
    AnyRef → Any
  39. def transaction: Transaction[A]

    Wraps this batch into a Redis transaction, i.e.

    Wraps this batch into a Redis transaction, i.e. ensures that it's executed inside a MULTI-EXEC block. NOTE: If you simply want to ensure atomicity, use atomic. NOTE: You can safely nest transactions, the driver will make sure that there are no nested MULTI-EXEC blocks on the wire.

    Definition Classes
    TransactionRedisBatch
  40. def transform[B](fun: (commons.Try[A]) ⇒ commons.Try[B]): RedisBatch[B]
    Definition Classes
    RedisBatch
  41. def tried: RedisBatch[commons.Try[A]]
    Definition Classes
    RedisBatch
  42. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  43. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  44. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  45. def zip[B](other: RedisBatch[B]): RedisBatch[(A, B)]
    Definition Classes
    RedisBatch

Inherited from SinglePackBatch[A]

Inherited from RawCommandPack

Inherited from RawCommandPacks

Inherited from RedisBatch[A]

Inherited from AnyRef

Inherited from Any

Ungrouped