Packages

c

com.avsystem.commons.redis

RedisOptSeqCommand

abstract class RedisOptSeqCommand[T] extends AbstractRedisCommand[commons.Opt[Seq[T]]]

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. RedisOptSeqCommand
  2. AbstractRedisCommand
  3. RedisCommand
  4. RawCommand
  5. ReplyPreprocessor
  6. RawCommands
  7. SinglePackBatch
  8. RawCommandPack
  9. RawCommandPacks
  10. RedisBatch
  11. AnyRef
  12. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new RedisOptSeqCommand(elementDecoder: ReplyDecoder[T])

Type Members

  1. type Encoded = ArrayMsg[BulkStringMsg]
    Definition Classes
    RawCommand

Abstract Value Members

  1. abstract def encoded: Encoded
    Definition Classes
    RawCommand
  2. abstract def level: Level
    Definition Classes
    RawCommand

Concrete Value Members

  1. 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
  2. def <*[B](other: RedisBatch[B]): RedisBatch[commons.Opt[Seq[T]]]

    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
  3. def <*>[B, C](other: RedisBatch[B])(f: (commons.Opt[Seq[T]], 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
  4. def asking: RedisBatch[commons.Opt[Seq[T]]]

    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
  5. def atomic: RedisBatch[commons.Opt[Seq[T]]]

    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
  6. final def batchOrFallback: RedisBatch[commons.Opt[Seq[T]]]
    Definition Classes
    RedisCommand
  7. final def checkLevel(minAllowed: Level, clientType: String): Unit
    Definition Classes
    RawCommand → RawCommandPack
  8. final def computeSize(limit: Int): Int
    Definition Classes
    RawCommandPack → RawCommandPacks
  9. final def createPreprocessor(replyCount: Int): RawCommand
    Definition Classes
    RawCommand → RawCommandPack
  10. final def decodeReplies(replies: (Int) ⇒ RedisReply, idx: Index, inTransaction: Boolean): commons.Opt[Seq[T]]
    Definition Classes
    RedisCommand → RedisBatch
  11. final def emitCommandPacks(consumer: (RawCommandPack) ⇒ Unit): Unit
    Definition Classes
    RawCommandPack → RawCommandPacks
  12. final def emitCommands(consumer: (RawCommand) ⇒ Unit): Unit
    Definition Classes
    RawCommand → RawCommands
  13. final def encodedSize: Int
    Definition Classes
    RawCommandPacks
  14. def failed: RedisBatch[Throwable]
    Definition Classes
    RedisBatch
  15. final def foreachKey(consumer: (ByteString) ⇒ Unit): Unit
    Definition Classes
    RawCommandPacks
  16. def ignoreFailures: RedisBatch[Unit]
    Definition Classes
    RedisBatch
  17. def immediateResult: commons.Opt[commons.Opt[Seq[T]]]

    Returns optional value that may be used as immediate result of this command if it command can be treated as no-op.

    Returns optional value that may be used as immediate result of this command if it command can be treated as no-op. For example DEL command with no keys may simply return 0 as its immediate result.

    Definition Classes
    RedisCommand
  18. final def isAsking: Boolean
    Definition Classes
    RawCommand → RawCommandPack
  19. def map[B](fun: (commons.Opt[Seq[T]]) ⇒ B): RedisCommand[B]
    Definition Classes
    RedisCommand → RedisBatch
  20. def map2[B, C](other: RedisBatch[B])(f: (commons.Opt[Seq[T]], 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
  21. def maxBlockingMillis: Int

    Maximum amount of time that these command packs may block on Redis side (like e.g.

    Maximum amount of time that these command packs may block on Redis side (like e.g. BLPOP). This method is overridden for RawCommand to return 0 and should be further overridden by each blocking command. Int.MaxValue should be returned for unlimited blocking.

    Definition Classes
    RawCommand → RawCommandPacks
  22. def operation: RedisOp[commons.Opt[Seq[T]]]

    Transforms this batch into a RedisOp.

    Transforms this batch into a RedisOp.

    Definition Classes
    RedisBatch
  23. final def preprocess(message: RedisMsg, state: WatchState): commons.Opt[RedisMsg]
    Definition Classes
    RawCommand → ReplyPreprocessor
  24. final def rawCommandPacks: RawCommandPacks
    Definition Classes
    SinglePackBatch → RedisBatch
  25. final def rawCommands(inTransaction: Boolean): RawCommand
    Definition Classes
    RawCommand → RawCommandPack
  26. def recover[B >: commons.Opt[Seq[T]]](f: PartialFunction[Throwable, B]): RedisBatch[B]
    Definition Classes
    RedisBatch
  27. final def requireLevel(minAllowed: Level, clientType: String): RedisOptSeqCommand.this.type
    Definition Classes
    RawCommandPacks
  28. def toString(): String
    Definition Classes
    RedisCommand → AnyRef → Any
  29. def transaction: RedisBatch[commons.Opt[Seq[T]]]

    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
    RedisBatch
  30. def transform[B](fun: (commons.Try[commons.Opt[Seq[T]]]) ⇒ commons.Try[B]): RedisBatch[B]
    Definition Classes
    RedisBatch
  31. def tried: RedisBatch[commons.Try[commons.Opt[Seq[T]]]]
    Definition Classes
    RedisBatch
  32. def updateWatchState(message: RedisMsg, state: WatchState): Unit
    Definition Classes
    RawCommand
  33. def zip[B](other: RedisBatch[B]): RedisBatch[(commons.Opt[Seq[T]], B)]
    Definition Classes
    RedisBatch