lettucef-core
lettucef-core
dev.naoh.lettucef.api
Commands
LettuceF
ShutdownConfig
ShutdownConfig
dev.naoh.lettucef.api.commands
AclCommandsF
BaseCommandsF
ClusterCommandsF
EvalScriptingCommandsF
GeoCommandsF
HLLCommandsF
HashCommandsF
KeyCommandsF
ListCommandsF
ScriptingCommandsF
SentinelCommandsF
ServerCommandsF
SetCommandsF
SortedSetCommandsF
StreamCommandsF
StringCommandsF
TransactionCommandsF
dev.naoh.lettucef.api.models
RedisData
RedisData
RedisArray
RedisBoolean
RedisBulk
RedisDouble
RedisError
RedisInteger
RedisNull
RedisString
RedisRange
RedisRange
Boundary
Exclusive
Inclusive
Unbounded
Boundary
RedisScanCursor
RedisScanCursor
dev.naoh.lettucef.api.models.geo
GeoWithin
GeoWithin
dev.naoh.lettucef.api.models.pubsub
RedisPushed
RedisPushed
Message
PMessage
PSubscribed
PUnsubscribed
Subscribed
Unsubscribed
dev.naoh.lettucef.api.models.stream
ClaimedMessages
ClaimedMessages
PendingMessage
PendingMessage
PendingMessages
PendingMessages
StreamMessage
StreamMessage
dev.naoh.lettucef.core
CommonConnectionF
MasterReplicaRedisConnectionF
RedisAsyncCommandsF
RedisClientF
RedisClusterAsyncCommandsF
RedisClusterClientF
RedisClusterConnectionF
RedisClusterSyncCommandsF
RedisConnectionF
RedisPubSubF
RedisPubSubF
RedisSentinelCommandsF
RedisSyncCommandsF
dev.naoh.lettucef.core.async
AclCommands
BaseCommands
ClusterCommands
GeoCommands
HLLCommands
HashCommands
KeyCommands
ListCommands
ScriptingCommands
SentinelCommands
ServerCommands
SetCommands
SortedSetCommands
StreamCommands
StringCommands
TransactionCommands
dev.naoh.lettucef.core.commands
CommandsDeps
dev.naoh.lettucef.core.sync
AclCommands
BaseCommands
ClusterCommands
GeoCommands
HLLCommands
HashCommands
KeyCommands
ListCommands
ScriptingCommands
SentinelCommands
ServerCommands
SetCommands
SortedSetCommands
StreamCommands
StringCommands
TransactionCommands
dev.naoh.lettucef.core.util
JavaFutureUtil
LettuceValueConverter
ManualDispatchHelper
RedisDataOutput
lettucef-core
/
dev.naoh.lettucef.core.sync
/
SortedSetCommands
SortedSetCommands
trait
SortedSetCommands
[
F
[
_
],
K
,
V
]
extends
CommandsDeps
[
F
,
K
,
V
]
with
SortedSetCommandsF
[
F
,
K
,
V
]
Graph
Supertypes
Known subtypes
trait
SortedSetCommandsF
[
F
,
K
,
V
]
trait
CommandsDeps
[
F
,
K
,
V
]
class
Object
trait
Matchable
class
Any
class
RedisClusterSyncCommandsF
[
F
,
K
,
V
]
class
RedisSyncCommandsF
[
F
,
K
,
V
]
Value members
Implicits
Value members
Concrete methods
def
bzpopmax
(
timeout:
Long
,
keys:
K
*):
F
[
Option
[(
K
, (
Double
,
V
))]]
def
bzpopmax
(
timeout:
Double
,
keys:
K
*):
F
[
Option
[(
K
, (
Double
,
V
))]]
def
bzpopmin
(
timeout:
Long
,
keys:
K
*):
F
[
Option
[(
K
, (
Double
,
V
))]]
def
bzpopmin
(
timeout:
Double
,
keys:
K
*):
F
[
Option
[(
K
, (
Double
,
V
))]]
def
zadd
(
key:
K
,
score:
Double
,
member:
V
):
F
[
Long
]
def
zadd
(
key:
K
,
scoredValues: (
Double
,
V
)*):
F
[
Long
]
def
zadd
(
key:
K
,
zAddArgs:
ZAddArgs
,
score:
Double
,
member:
V
):
F
[
Long
]
def
zadd
(
key:
K
,
zAddArgs:
ZAddArgs
,
scoredValues: (
Double
,
V
)*):
F
[
Long
]
def
zaddincr
(
key:
K
,
score:
Double
,
member:
V
):
F
[
Option
[
Double
]]
def
zaddincr
(
key:
K
,
zAddArgs:
ZAddArgs
,
score:
Double
,
member:
V
):
F
[
Option
[
Double
]]
def
zcard
(
key:
K
):
F
[
Long
]
def
zcount
(
key:
K
,
range:
RedisRange
[
Double
]):
F
[
Long
]
def
zdiff
(
keys:
K
*):
F
[
Seq
[
V
]]
def
zdiffWithScores
(
keys:
K
*):
F
[
Seq
[(
Double
,
V
)]]
def
zdiffstore
(
destKey:
K
,
srcKeys:
K
*):
F
[
Long
]
def
zincrby
(
key:
K
,
amount:
Double
,
member:
V
):
F
[
Double
]
def
zinter
(
keys:
K
*):
F
[
Seq
[
V
]]
def
zinter
(
aggregateArgs:
ZAggregateArgs
,
keys:
K
*):
F
[
Seq
[
V
]]
def
zinterWithScores
(
aggregateArgs:
ZAggregateArgs
,
keys:
K
*):
F
[
Seq
[(
Double
,
V
)]]
def
zinterWithScores
(
keys:
K
*):
F
[
Seq
[(
Double
,
V
)]]
def
zintercard
(
keys:
K
*):
F
[
Long
]
def
zintercard
(
limit:
Long
,
keys:
K
*):
F
[
Long
]
def
zinterstore
(
destination:
K
,
keys:
K
*):
F
[
Long
]
def
zinterstore
(
destination:
K
,
storeArgs:
ZStoreArgs
,
keys:
K
*):
F
[
Long
]
def
zlexcount
(
key:
K
,
range:
RedisRange
[
V
]):
F
[
Long
]
def
zmscore
(
key:
K
,
members:
V
*):
F
[
Seq
[
Option
[
Double
]]]
def
zpopmax
(
key:
K
):
F
[
Option
[(
Double
,
V
)]]
def
zpopmax
(
key:
K
,
count:
Long
):
F
[
Seq
[(
Double
,
V
)]]
def
zpopmin
(
key:
K
):
F
[
Option
[(
Double
,
V
)]]
def
zpopmin
(
key:
K
,
count:
Long
):
F
[
Seq
[(
Double
,
V
)]]
def
zrandmember
(
key:
K
):
F
[
Option
[
V
]]
def
zrandmember
(
key:
K
,
count:
Long
):
F
[
Seq
[
V
]]
def
zrandmemberWithScores
(
key:
K
):
F
[
Option
[(
Double
,
V
)]]
def
zrandmemberWithScores
(
key:
K
,
count:
Long
):
F
[
Seq
[(
Double
,
V
)]]
def
zrange
(
key:
K
,
start:
Long
,
stop:
Long
):
F
[
Seq
[
V
]]
def
zrangeWithScores
(
key:
K
,
start:
Long
,
stop:
Long
):
F
[
Seq
[(
Double
,
V
)]]
def
zrangebylex
(
key:
K
,
range:
RedisRange
[
V
]):
F
[
Seq
[
V
]]
def
zrangebylex
(
key:
K
,
range:
RedisRange
[
V
],
limit:
Limit
):
F
[
Seq
[
V
]]
def
zrangebyscore
(
key:
K
,
range:
RedisRange
[
Double
]):
F
[
Seq
[
V
]]
def
zrangebyscore
(
key:
K
,
range:
RedisRange
[
Double
],
limit:
Limit
):
F
[
Seq
[
V
]]
def
zrangebyscoreWithScores
(
key:
K
,
range:
RedisRange
[
Double
]):
F
[
Seq
[(
Double
,
V
)]]
def
zrangebyscoreWithScores
(
key:
K
,
range:
RedisRange
[
Double
],
limit:
Limit
):
F
[
Seq
[(
Double
,
V
)]]
def
zrangestorebylex
(
dstKey:
K
,
srcKey:
K
,
range:
RedisRange
[
V
],
limit:
Limit
):
F
[
Long
]
def
zrangestorebyscore
(
dstKey:
K
,
srcKey:
K
,
range:
RedisRange
[
Double
],
limit:
Limit
):
F
[
Long
]
def
zrank
(
key:
K
,
member:
V
):
F
[
Option
[
Long
]]
def
zrem
(
key:
K
,
members:
V
*):
F
[
Long
]
def
zremrangebylex
(
key:
K
,
range:
RedisRange
[
V
]):
F
[
Long
]
def
zremrangebyrank
(
key:
K
,
start:
Long
,
stop:
Long
):
F
[
Long
]
def
zremrangebyscore
(
key:
K
,
range:
RedisRange
[
Double
]):
F
[
Long
]
def
zrevrange
(
key:
K
,
start:
Long
,
stop:
Long
):
F
[
Seq
[
V
]]
def
zrevrangeWithScores
(
key:
K
,
start:
Long
,
stop:
Long
):
F
[
Seq
[(
Double
,
V
)]]
def
zrevrangebylex
(
key:
K
,
range:
RedisRange
[
V
]):
F
[
Seq
[
V
]]
def
zrevrangebylex
(
key:
K
,
range:
RedisRange
[
V
],
limit:
Limit
):
F
[
Seq
[
V
]]
def
zrevrangebyscore
(
key:
K
,
range:
RedisRange
[
Double
]):
F
[
Seq
[
V
]]
def
zrevrangebyscore
(
key:
K
,
range:
RedisRange
[
Double
],
limit:
Limit
):
F
[
Seq
[
V
]]
def
zrevrangebyscoreWithScores
(
key:
K
,
range:
RedisRange
[
Double
]):
F
[
Seq
[(
Double
,
V
)]]
def
zrevrangebyscoreWithScores
(
key:
K
,
range:
RedisRange
[
Double
],
limit:
Limit
):
F
[
Seq
[(
Double
,
V
)]]
def
zrevrangestorebylex
(
dstKey:
K
,
srcKey:
K
,
range:
RedisRange
[
V
],
limit:
Limit
):
F
[
Long
]
def
zrevrangestorebyscore
(
dstKey:
K
,
srcKey:
K
,
range:
RedisRange
[
Double
],
limit:
Limit
):
F
[
Long
]
def
zrevrank
(
key:
K
,
member:
V
):
F
[
Option
[
Long
]]
def
zscan
(
key:
K
):
F
[
RedisScanCursor
[(
Double
,
V
)]]
def
zscan
(
key:
K
,
scanArgs:
ScanArgs
):
F
[
RedisScanCursor
[(
Double
,
V
)]]
def
zscan
(
key:
K
,
scanCursor:
ScanCursor
,
scanArgs:
ScanArgs
):
F
[
RedisScanCursor
[(
Double
,
V
)]]
def
zscan
(
key:
K
,
scanCursor:
ScanCursor
):
F
[
RedisScanCursor
[(
Double
,
V
)]]
def
zscore
(
key:
K
,
member:
V
):
F
[
Option
[
Double
]]
def
zunion
(
keys:
K
*):
F
[
Seq
[
V
]]
def
zunion
(
aggregateArgs:
ZAggregateArgs
,
keys:
K
*):
F
[
Seq
[
V
]]
def
zunionWithScores
(
aggregateArgs:
ZAggregateArgs
,
keys:
K
*):
F
[
Seq
[(
Double
,
V
)]]
def
zunionWithScores
(
keys:
K
*):
F
[
Seq
[(
Double
,
V
)]]
def
zunionstore
(
destination:
K
,
keys:
K
*):
F
[
Long
]
def
zunionstore
(
destination:
K
,
storeArgs:
ZStoreArgs
,
keys:
K
*):
F
[
Long
]
Abstract fields
protected
val
underlying
:
RedisSortedSetAsyncCommands
[
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