lettucef-core/dev.naoh.lettucef.core.async/StreamCommands

StreamCommands

trait StreamCommands[F[_], K, V] extends CommandsDeps[F, K, V] with StreamCommandsF[<none>, K, V]
trait StreamCommandsF[<none>, K, V]
trait CommandsDeps[F, K, V]
class Object
trait Matchable
class Any
class RedisAsyncCommandsF[F, K, V]

Value members

Concrete methods

def xack(key: K, group: K, messageIds: String*): F[F[Long]]
def xadd(key: K, body: Map[K, V]): F[F[String]]
def xadd(key: K, args: XAddArgs, body: Map[K, V]): F[F[String]]
def xautoclaim(key: K, args: XAutoClaimArgs[K]): F[F[ClaimedMessages[K, V]]]
def xclaim(key: K, consumer: Consumer[K], minIdleTime: Long, messageIds: String*): F[F[Seq[StreamMessage[K, V]]]]
def xclaim(key: K, consumer: Consumer[K], args: XClaimArgs, messageIds: String*): F[F[Seq[StreamMessage[K, V]]]]
def xdel(key: K, messageIds: String*): F[F[Long]]
def xgroupCreate(streamOffset: StreamOffset[K], group: K): F[F[String]]
def xgroupCreate(streamOffset: StreamOffset[K], group: K, args: XGroupCreateArgs): F[F[String]]
def xgroupCreateconsumer(key: K, consumer: Consumer[K]): F[F[Boolean]]
def xgroupDelconsumer(key: K, consumer: Consumer[K]): F[F[Long]]
def xgroupDestroy(key: K, group: K): F[F[Boolean]]
def xgroupSetid(streamOffset: StreamOffset[K], group: K): F[F[String]]
def xinfoConsumers(key: K, group: K): F[F[List[RedisData[V]]]]
def xinfoGroups(key: K): F[F[List[RedisData[V]]]]
def xinfoStream(key: K): F[F[List[RedisData[V]]]]
def xlen(key: K): F[F[Long]]
def xpending(key: K, group: K): F[F[PendingMessages]]
def xpending(key: K, group: K, range: RedisRange[String], limit: Limit): F[F[Seq[PendingMessage]]]
def xpending(key: K, consumer: Consumer[K], range: RedisRange[String], limit: Limit): F[F[Seq[PendingMessage]]]
def xpending(key: K, args: XPendingArgs[K]): F[F[Seq[PendingMessage]]]
def xrange(key: K, range: RedisRange[String]): F[F[Seq[StreamMessage[K, V]]]]
def xrange(key: K, range: RedisRange[String], limit: Limit): F[F[Seq[StreamMessage[K, V]]]]
def xread(streams: StreamOffset[K]*): F[F[Seq[StreamMessage[K, V]]]]
def xread(args: XReadArgs, streams: StreamOffset[K]*): F[F[Seq[StreamMessage[K, V]]]]
def xreadgroup(consumer: Consumer[K], streams: StreamOffset[K]*): F[F[Seq[StreamMessage[K, V]]]]
def xreadgroup(consumer: Consumer[K], args: XReadArgs, streams: StreamOffset[K]*): F[F[Seq[StreamMessage[K, V]]]]
def xrevrange(key: K, range: RedisRange[String]): F[F[Seq[StreamMessage[K, V]]]]
def xrevrange(key: K, range: RedisRange[String], limit: Limit): F[F[Seq[StreamMessage[K, V]]]]
def xtrim(key: K, count: Long): F[F[Long]]
def xtrim(key: K, approximateTrimming: Boolean, count: Long): F[F[Long]]
def xtrim(key: K, args: XTrimArgs): F[F[Long]]

Abstract fields

protected
val underlying: RedisStreamAsyncCommands[K, V] & BaseRedisAsyncCommands[K, V]

Inherited fields

protected
val dispatchHelper: ManualDispatchHelper[K, V]
Inherited from
CommandsDeps

Implicits

Inherited implicits

implicit protected
val _async: Async[F]
Inherited from
CommandsDeps