RedissonScoredSortedSet (Redisson 3.15.4 API)

java.lang.Object
- org.redisson.RedissonObject
- - org.redisson.RedissonScoredSortedSet<V>

Type Parameters:

V - value type

All Implemented Interfaces:

Iterable<V>, RExpirable, RExpirableAsync, RObject, RObjectAsync, RScoredSortedSet<V>, RScoredSortedSetAsync<V>, RSortable<Set<V>>, RSortableAsync<Set<V>>

Direct Known Subclasses:

RedissonGeo, RedissonLexSortedSet
```
public class RedissonScoredSortedSet<V>
extends RedissonObject
implements RScoredSortedSet<V>
```
Author:

Nikita Koksharov

Nested Class Summary
- Nested classes/interfaces inherited from interface org.redisson.api.RScoredSortedSet
  RScoredSortedSet.Aggregate

Field Summary
- Fields inherited from class org.redisson.RedissonObject
  codec, commandExecutor, name

Constructor Summary

Constructors
Constructor and Description
`RedissonScoredSortedSet(Codec codec, CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson)`
`RedissonScoredSortedSet(CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(double score, V object)` Adds element to this set, overrides previous score if it has been already added.
`int`	`addAll(Map<V,Double> objects)` Adds all elements contained in the specified map to this sorted set.
`RFuture<Integer>`	`addAllAsync(Map<V,Double> objects)` Adds all elements contained in the specified map to this sorted set.
`Integer`	`addAndGetRank(double score, V object)` Adds element to this set, overrides previous score if it has been already added.
`RFuture<Integer>`	`addAndGetRankAsync(double score, V object)` Adds element to this set, overrides previous score if it has been already added.
`Integer`	`addAndGetRevRank(double score, V object)` Adds element to this set, overrides previous score if it has been already added.
`List<Integer>`	`addAndGetRevRank(Map<? extends V,Double> map)` Adds elements to this set, overrides previous score if it has been already added.
`RFuture<Integer>`	`addAndGetRevRankAsync(double score, V object)` Adds element to this set, overrides previous score if it has been already added.
`RFuture<List<Integer>>`	`addAndGetRevRankAsync(Map<? extends V,Double> map)` Adds elements to this set, overrides previous score if it has been already added.
`RFuture<Boolean>`	`addAsync(double score, V object)` Adds element to this set, overrides previous score if it has been already added.
`boolean`	`addIfExists(double score, V object)` Adds element to this set only if it's already exists.
`RFuture<Boolean>`	`addIfExistsAsync(double score, V object)` Adds element to this set only if it's already exists.
`boolean`	`addIfGreater(double score, V object)` Adds element to this set only if new score greater than current score of existed element.
`RFuture<Boolean>`	`addIfGreaterAsync(double score, V object)` Adds element to this set only if new score greater than current score of existed element.
`boolean`	`addIfLess(double score, V object)` Adds element to this set only if new score less than current score of existed element.
`RFuture<Boolean>`	`addIfLessAsync(double score, V object)` Adds element to this set only if new score less than current score of existed element.
`int`	`addListener(ObjectListener listener)` Adds object event listener
`RFuture<Integer>`	`addListenerAsync(ObjectListener listener)` Adds object event listener
`Double`	`addScore(V object, Number value)` Increases score of specified element by value.
`Integer`	`addScoreAndGetRank(V object, Number value)` Adds score to element and returns its rank
`RFuture<Integer>`	`addScoreAndGetRankAsync(V object, Number value)` Adds score to element and returns its rank
`Integer`	`addScoreAndGetRevRank(V object, Number value)` Adds score to element and returns its reverse rank
`RFuture<Integer>`	`addScoreAndGetRevRankAsync(V object, Number value)` Adds score to element and returns its reverse rank
`RFuture<Double>`	`addScoreAsync(V object, Number value)` Increases score of specified element by value.
`void`	`clear()` Removes all elements of this sorted set.
`boolean`	`clearExpire()` Clear an expire timeout or expire date for object.
`RFuture<Boolean>`	`clearExpireAsync()` Clear an expire timeout or expire date for object in async mode.
`protected RFuture<Boolean>`	`clearExpireAsync(String... keys)`
`boolean`	`contains(Object object)` Returns `true` if this sorted set contains encoded state of the specified element.
`boolean`	`containsAll(Collection<?> c)` Returns `true` if this sorted set contains all of the elements in encoded state in the specified collection.
`RFuture<Boolean>`	`containsAllAsync(Collection<?> c)` Returns `true` if this sorted set contains all of the elements in encoded state in the specified collection.
`RFuture<Boolean>`	`containsAsync(Object o)` Returns `true` if this sorted set contains encoded state of the specified element.
`int`	`count(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Returns the number of elements with a score between `startScore` and `endScore`.
`RFuture<Integer>`	`countAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Returns the number of elements with a score between `startScore` and `endScore`.
`int`	`diff(String... names)` Diff provided ScoredSortedSets and store result to current ScoredSortedSet Requires Redis 6.2.0 and higher.
`RFuture<Integer>`	`diffAsync(String... names)` Diff provided ScoredSortedSets and store result to current ScoredSortedSet Requires Redis 6.2.0 and higher.
`Collection<ScoredEntry<V>>`	`entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Returns all entries (value and its score) between `startScore` and `endScore`.
`Collection<ScoredEntry<V>>`	`entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Returns all entries (value and its score) between `startScore` and `endScore`.
`Collection<ScoredEntry<V>>`	`entryRange(int startIndex, int endIndex)` Returns entries (value and its score) by rank range.
`RFuture<Collection<ScoredEntry<V>>>`	`entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Returns all entries (value and its score) between `startScore` and `endScore`.
`RFuture<Collection<ScoredEntry<V>>>`	`entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Returns all entries (value and its score) between `startScore` and `endScore`.
`RFuture<Collection<ScoredEntry<V>>>`	`entryRangeAsync(int startIndex, int endIndex)` Returns entries (value and its score) by rank range.
`Collection<ScoredEntry<V>>`	`entryRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Returns all entries (value and its score) between `startScore` and `endScore` in reversed order.
`Collection<ScoredEntry<V>>`	`entryRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Returns all entries (value and its score) between `startScore` and `endScore` in reversed order.
`Collection<ScoredEntry<V>>`	`entryRangeReversed(int startIndex, int endIndex)` Returns entries (value and its score) by rank range in reverse order.
`RFuture<Collection<ScoredEntry<V>>>`	`entryRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Returns all entries (value and its score) between `startScore` and `endScore` in reversed order.
`RFuture<Collection<ScoredEntry<V>>>`	`entryRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Returns all entries (value and its score) between `startScore` and `endScore` in reversed order.
`RFuture<Collection<ScoredEntry<V>>>`	`entryRangeReversedAsync(int startIndex, int endIndex)` Returns entries (value and its score) by rank range in reverse order.
`boolean`	`expire(Instant instant)` Set an expire date for object.
`boolean`	`expire(long timeToLive, TimeUnit timeUnit)` Set a timeout for object.
`RFuture<Boolean>`	`expireAsync(Instant instant)` Set an expire date for object.
`RFuture<Boolean>`	`expireAsync(long timeToLive, TimeUnit timeUnit)` Set a timeout for object in async mode.
`protected RFuture<Boolean>`	`expireAsync(long timeToLive, TimeUnit timeUnit, String... keys)`
`boolean`	`expireAt(Date timestamp)` Use `RExpirable.expire(Instant)` instead
`boolean`	`expireAt(long timestamp)` Use `RExpirable.expire(Instant)` instead
`RFuture<Boolean>`	`expireAtAsync(Date timestamp)` Use `RExpirableAsync.expireAsync(Instant)` instead
`RFuture<Boolean>`	`expireAtAsync(long timestamp)` Use `RExpirableAsync.expireAsync(Instant)` instead
`protected RFuture<Boolean>`	`expireAtAsync(long timestamp, String... keys)`
`V`	`first()` Returns the head element or `null` if this sorted set is empty.
`RFuture<V>`	`firstAsync()` Returns the head element or `null` if this sorted set is empty.
`Double`	`firstScore()` Returns score of the tail element or returns `null` if this sorted set is empty.
`RFuture<Double>`	`firstScoreAsync()` Returns score of the head element or returns `null` if this sorted set is empty.
`List<Double>`	`getScore(List<V> keys)` Returns scores of elements.
`Double`	`getScore(V o)` Returns score of element or `null` if it doesn't exist.
`RFuture<List<Double>>`	`getScoreAsync(Collection<V> elements)` Returns scores of elements.
`RFuture<Double>`	`getScoreAsync(V o)` Returns score of element or `null` if it doesn't exist.
`int`	`intersection(Map<String,Double> nameWithWeight)` Intersect provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
`int`	`intersection(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)` Intersect provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
`int`	`intersection(RScoredSortedSet.Aggregate aggregate, String... names)` Intersect provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
`int`	`intersection(String... names)` Intersect provided ScoredSortedSets and store result to current ScoredSortedSet
`RFuture<Integer>`	`intersectionAsync(Map<String,Double> nameWithWeight)` Intersect provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
`RFuture<Integer>`	`intersectionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)` Intersect provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
`RFuture<Integer>`	`intersectionAsync(RScoredSortedSet.Aggregate aggregate, String... names)` Intersect provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
`RFuture<Integer>`	`intersectionAsync(String... names)` Intersect provided ScoredSortedSets and store result to current ScoredSortedSet
`boolean`	`isEmpty()` Returns `true` if this set is empty
`Iterator<V>`	`iterator()`
`Iterator<V>`	`iterator(int count)` Returns an iterator over elements in this set.
`Iterator<V>`	`iterator(String pattern)` Returns an iterator over elements in this set.
`Iterator<V>`	`iterator(String pattern, int count)` Returns an iterator over elements in this set.
`V`	`last()` Returns the tail element or `null` if this sorted set is empty.
`RFuture<V>`	`lastAsync()` Returns the tail element or `null` if this sorted set is empty.
`Double`	`lastScore()` Returns score of the head element or returns `null` if this sorted set is empty.
`RFuture<Double>`	`lastScoreAsync()` Returns score of the tail element or returns `null` if this sorted set is empty.
`<KOut,VOut> RCollectionMapReduce<V,KOut,VOut>`	`mapReduce()` Returns `RMapReduce` object associated with this object
`V`	`pollFirst()` Removes and returns the head element or `null` if this sorted set is empty.
`Collection<V>`	`pollFirst(int count)` Removes and returns the head elements of this sorted set.
`V`	`pollFirst(long timeout, TimeUnit unit)` Removes and returns the head element or `null` if this sorted set is empty.
`RFuture<V>`	`pollFirstAsync()` Removes and returns the head element or `null` if this sorted set is empty.
`RFuture<Collection<V>>`	`pollFirstAsync(int count)` Removes and returns the head elements of this sorted set.
`RFuture<V>`	`pollFirstAsync(long timeout, TimeUnit unit)` Removes and returns the head element or `null` if this sorted set is empty.
`V`	`pollFirstFromAny(long timeout, TimeUnit unit, String... queueNames)` Removes and returns first available head element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
`RFuture<V>`	`pollFirstFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)` Removes and returns first available head element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
`V`	`pollLast()` Removes and returns the tail element or `null` if this sorted set is empty.
`Collection<V>`	`pollLast(int count)` Removes and returns the tail elements of this sorted set.
`V`	`pollLast(long timeout, TimeUnit unit)` Removes and returns the tail element or `null` if this sorted set is empty.
`RFuture<V>`	`pollLastAsync()` Removes and returns the tail element or `null` if this sorted set is empty.
`RFuture<Collection<V>>`	`pollLastAsync(int count)` Removes and returns the tail elements of this sorted set.
`RFuture<V>`	`pollLastAsync(long timeout, TimeUnit unit)` Removes and returns the tail element or `null` if this sorted set is empty.
`V`	`pollLastFromAny(long timeout, TimeUnit unit, String... queueNames)` Removes and returns first available tail element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
`RFuture<V>`	`pollLastFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)` Removes and returns first available tail element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
`V`	`random()` Returns random element from this sorted set Requires Redis 6.2.0 and higher.
`Collection<V>`	`random(int count)` Returns random elements from this sorted set limited by `count` Requires Redis 6.2.0 and higher.
`RFuture<V>`	`randomAsync()` Returns random element from this sorted set Requires Redis 6.2.0 and higher.
`RFuture<Collection<V>>`	`randomAsync(int count)` Returns random elements from this sorted set limited by `count` Requires Redis 6.2.0 and higher.
`Map<V,Double>`	`randomEntries(int count)` Returns random entries from this sorted set limited by `count`.
`RFuture<Map<V,Double>>`	`randomEntriesAsync(int count)` Returns random entries from this sorted set limited by `count`.
`int`	`rangeTo(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Stores to defined ScoredSortedSet values between `startScore` and `endScore`.
`int`	`rangeTo(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Stores to defined ScoredSortedSet values between `startScore` and `endScore`.
`int`	`rangeTo(String destName, int startIndex, int endIndex)` Stores to defined ScoredSortedSet values by rank range.
`RFuture<Integer>`	`rangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Stores to defined ScoredSortedSet values between `startScore` and `endScore`.
`RFuture<Integer>`	`rangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Stores to defined ScoredSortedSet values between `startScore` and `endScore`.
`RFuture<Integer>`	`rangeToAsync(String destName, int startIndex, int endIndex)` Stores to defined ScoredSortedSet values by rank range.
`Integer`	`rank(V o)` Returns rank of value, with the scores ordered from low to high.
`RFuture<Integer>`	`rankAsync(V o)` Returns rank of value, with the scores ordered from low to high.
`Collection<V>`	`readAll()` Read all values at once.
`RFuture<Collection<V>>`	`readAllAsync()` Read all values at once.
`Collection<V>`	`readDiff(String... names)` Diff ScoredSortedSets specified by name with current ScoredSortedSet without state change.
`RFuture<Collection<V>>`	`readDiffAsync(String... names)` Diff ScoredSortedSets specified by name with current ScoredSortedSet without state change.
`Collection<V>`	`readIntersection(Map<String,Double> nameWithWeight)` Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet without state change Requires Redis 6.2.0 and higher.
`Collection<V>`	`readIntersection(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)` Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet using defined aggregation method without state change Requires Redis 6.2.0 and higher.
`Collection<V>`	`readIntersection(RScoredSortedSet.Aggregate aggregate, String... names)` Intersect provided ScoredSortedSets with current ScoredSortedSet using defined aggregation method without state change Requires Redis 6.2.0 and higher.
`Collection<V>`	`readIntersection(String... names)` Intersect provided ScoredSortedSets with current ScoredSortedSet without state change Requires Redis 6.2.0 and higher.
`RFuture<Collection<V>>`	`readIntersectionAsync(Map<String,Double> nameWithWeight)` Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet without state change Requires Redis 6.2.0 and higher.
`RFuture<Collection<V>>`	`readIntersectionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)` Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet using defined aggregation method without state change Requires Redis 6.2.0 and higher.
`RFuture<Collection<V>>`	`readIntersectionAsync(RScoredSortedSet.Aggregate aggregate, String... names)` Intersect provided ScoredSortedSets with current ScoredSortedSet using defined aggregation method without state change Requires Redis 6.2.0 and higher.
`RFuture<Collection<V>>`	`readIntersectionAsync(String... names)` Intersect provided ScoredSortedSets with current ScoredSortedSet without state change Requires Redis 6.2.0 and higher.
`Set<V>`	`readSort(SortOrder order)` Read data in sorted view
`Set<V>`	`readSort(SortOrder order, int offset, int count)` Read data in sorted view
`<T> Collection<T>`	`readSort(String byPattern, List<String> getPatterns, SortOrder order)` Read data in sorted view
`<T> Collection<T>`	`readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)` Read data in sorted view
`Set<V>`	`readSort(String byPattern, SortOrder order)` Read data in sorted view
`Set<V>`	`readSort(String byPattern, SortOrder order, int offset, int count)` Read data in sorted view
`Set<V>`	`readSortAlpha(SortOrder order)` Read data in sorted view lexicographically
`Set<V>`	`readSortAlpha(SortOrder order, int offset, int count)` Read data in sorted view lexicographically
`<T> Collection<T>`	`readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order)` Read data in sorted view lexicographically
`<T> Collection<T>`	`readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)` Read data in sorted view lexicographically
`Set<V>`	`readSortAlpha(String byPattern, SortOrder order)` Read data in sorted view lexicographically
`Set<V>`	`readSortAlpha(String byPattern, SortOrder order, int offset, int count)` Read data in sorted view lexicographically
`RFuture<Set<V>>`	`readSortAlphaAsync(SortOrder order)` Read data in sorted view lexicographically
`RFuture<Set<V>>`	`readSortAlphaAsync(SortOrder order, int offset, int count)` Read data in sorted view lexicographically
`<T> RFuture<Collection<T>>`	`readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order)` Read data in sorted view lexicographically
`<T> RFuture<Collection<T>>`	`readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)` Read data in sorted view lexicographically
`RFuture<Set<V>>`	`readSortAlphaAsync(String byPattern, SortOrder order)` Read data in sorted view lexicographically
`RFuture<Set<V>>`	`readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count)` Read data in sorted view lexicographically
`RFuture<Set<V>>`	`readSortAsync(SortOrder order)` Read data in sorted view
`RFuture<Set<V>>`	`readSortAsync(SortOrder order, int offset, int count)` Read data in sorted view
`<T> RFuture<Collection<T>>`	`readSortAsync(String byPattern, List<String> getPatterns, SortOrder order)` Read data in sorted view
`<T> RFuture<Collection<T>>`	`readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)` Read data in sorted view
`RFuture<Set<V>>`	`readSortAsync(String byPattern, SortOrder order)` Read data in sorted view
`RFuture<Set<V>>`	`readSortAsync(String byPattern, SortOrder order, int offset, int count)` Read data in sorted view
`Collection<V>`	`readUnion(Map<String,Double> nameWithWeight)` Union provided ScoredSortedSets mapped to weight multiplier and current ScoredSortedSet without state change.
`Collection<V>`	`readUnion(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)` Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and current ScoredSortedSet without state change Requires Redis 6.2.0 and higher.
`Collection<V>`	`readUnion(RScoredSortedSet.Aggregate aggregate, String... names)` Union ScoredSortedSets specified by name with defined aggregation method and current ScoredSortedSet without state change.
`Collection<V>`	`readUnion(String... names)` Union ScoredSortedSets specified by name with current ScoredSortedSet without state change.
`RFuture<Collection<V>>`	`readUnionAsync(Map<String,Double> nameWithWeight)` Union provided ScoredSortedSets mapped to weight multiplier and current ScoredSortedSet without state change.
`RFuture<Collection<V>>`	`readUnionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)` Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and current ScoredSortedSet without state change Requires Redis 6.2.0 and higher.
`RFuture<Collection<V>>`	`readUnionAsync(RScoredSortedSet.Aggregate aggregate, String... names)` Union ScoredSortedSets specified by name with defined aggregation method and current ScoredSortedSet without state change.
`RFuture<Collection<V>>`	`readUnionAsync(String... names)` Union ScoredSortedSets specified by name with current ScoredSortedSet without state change.
`long`	`remainTimeToLive()` Remaining time to live of Redisson object that has a timeout
`RFuture<Long>`	`remainTimeToLiveAsync()` Remaining time to live of Redisson object that has a timeout
`boolean`	`remove(Object object)` Removes a single instance of the specified element from this sorted set, if it is present.
`boolean`	`removeAll(Collection<?> c)` Removes all of this sorted set's elements that are also contained in the specified collection.
`RFuture<Boolean>`	`removeAllAsync(Collection<?> c)` Removes all of this sorted set's elements that are also contained in the specified collection.
`RFuture<Boolean>`	`removeAsync(Object object)` Removes a single instance of the specified element from this sorted set, if it is present.
`void`	`removeListener(int listenerId)` Removes object event listener
`RFuture<Void>`	`removeListenerAsync(int listenerId)` Removes object event listener
`int`	`removeRangeByRank(int startIndex, int endIndex)` Removes values by rank range.
`RFuture<Integer>`	`removeRangeByRankAsync(int startIndex, int endIndex)` Removes values by rank range.
`int`	`removeRangeByScore(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Removes values by score range.
`RFuture<Integer>`	`removeRangeByScoreAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Removes values by score range.
`boolean`	`retainAll(Collection<?> c)` Retains only the elements in this sorted set that are contained in the specified collection.
`RFuture<Boolean>`	`retainAllAsync(Collection<?> c)` Retains only the elements in this sorted set that are contained in the specified collection.
`int`	`revRangeTo(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Stores to defined ScoredSortedSet values in reversed order between `startScore` and `endScore`.
`int`	`revRangeTo(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Stores to defined ScoredSortedSet values in reversed order between `startScore` and `endScore`.
`int`	`revRangeTo(String destName, int startIndex, int endIndex)` Stores to defined ScoredSortedSet values in reversed order by rank range.
`RFuture<Integer>`	`revRangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Stores to defined ScoredSortedSet values in reversed order between `startScore` and `endScore`.
`RFuture<Integer>`	`revRangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Stores to defined ScoredSortedSet values in reversed order between `startScore` and `endScore`.
`RFuture<Integer>`	`revRangeToAsync(String destName, int startIndex, int endIndex)` Stores to defined ScoredSortedSet values in reversed order by rank range.
`List<Integer>`	`revRank(Collection<V> elements)` Returns ranks of elements, with the scores ordered from high to low.
`Integer`	`revRank(V o)` Returns rank of value, with the scores ordered from high to low.
`RFuture<List<Integer>>`	`revRankAsync(Collection<V> elements)` Returns ranks of elements, with the scores ordered from high to low.
`RFuture<Integer>`	`revRankAsync(V o)` Returns rank of value, with the scores ordered from high to low.
`RFuture<ListScanResult<Object>>`	`scanIteratorAsync(RedisClient client, long startPos, String pattern, int count)`
`int`	`size()` Returns size of this set.
`RFuture<Integer>`	`sizeAsync()` Returns size of this set.
`int`	`sortTo(String destName, SortOrder order)` Sort data and store to `destName` list
`int`	`sortTo(String destName, SortOrder order, int offset, int count)` Sort data and store to `destName` list
`int`	`sortTo(String destName, String byPattern, List<String> getPatterns, SortOrder order)` Sort data and store to `destName` list
`int`	`sortTo(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)` Sort data and store to `destName` list
`int`	`sortTo(String destName, String byPattern, SortOrder order)` Sort data and store to `destName` list
`int`	`sortTo(String destName, String byPattern, SortOrder order, int offset, int count)` Sort data and store to `destName` list
`RFuture<Integer>`	`sortToAsync(String destName, SortOrder order)` Sort data and store to `destName` list
`RFuture<Integer>`	`sortToAsync(String destName, SortOrder order, int offset, int count)` Sort data and store to `destName` list
`RFuture<Integer>`	`sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order)` Sort data and store to `destName` list
`RFuture<Integer>`	`sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)` Sort data and store to `destName` list
`RFuture<Integer>`	`sortToAsync(String destName, String byPattern, SortOrder order)` Sort data and store to `destName` list
`RFuture<Integer>`	`sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count)` Sort data and store to `destName` list
`Stream<V>`	`stream()` Returns stream of elements in this set.
`Stream<V>`	`stream(int count)` Returns stream of elements in this set.
`Stream<V>`	`stream(String pattern)` Returns stream of elements in this set.
`Stream<V>`	`stream(String pattern, int count)` Returns stream of elements in this set.
`int`	`subscribeOnFirstElements(Consumer<V> consumer)` Subscribes on first elements appeared in this set.
`int`	`subscribeOnLastElements(Consumer<V> consumer)` Subscribes on last elements appeared in this set.
`V`	`takeFirst()` Removes and returns the head element waiting if necessary for an element to become available.
`RFuture<V>`	`takeFirstAsync()` Removes and returns the head element waiting if necessary for an element to become available.
`V`	`takeLast()` Removes and returns the tail element waiting if necessary for an element to become available.
`RFuture<V>`	`takeLastAsync()` Removes and returns the tail element waiting if necessary for an element to become available.
`Object[]`	`toArray()` Returns this sorted set in array of Object type.
`<T> T[]`	`toArray(T[] a)` Returns this sorted set in array of defined type.
`boolean`	`tryAdd(double score, V object)` Adds element to this set only if has not been added before.
`RFuture<Boolean>`	`tryAddAsync(double score, V object)` Adds element to this set only if has not been added before.
`int`	`union(Map<String,Double> nameWithWeight)` Union provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
`int`	`union(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)` Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
`int`	`union(RScoredSortedSet.Aggregate aggregate, String... names)` Union provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
`int`	`union(String... names)` Union provided ScoredSortedSets and store result to current ScoredSortedSet
`RFuture<Integer>`	`unionAsync(Map<String,Double> nameWithWeight)` Union provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
`RFuture<Integer>`	`unionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)` Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
`RFuture<Integer>`	`unionAsync(RScoredSortedSet.Aggregate aggregate, String... names)` Union provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
`RFuture<Integer>`	`unionAsync(String... names)` Union provided ScoredSortedSets and store result to current ScoredSortedSet
`void`	`unsubscribe(int listenerId)` Un-subscribes defined listener.
`Collection<V>`	`valueRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Returns all values between `startScore` and `endScore`.
`Collection<V>`	`valueRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Returns all values between `startScore` and `endScore`.
`Collection<V>`	`valueRange(int startIndex, int endIndex)` Returns values by rank range.
`RFuture<Collection<V>>`	`valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Returns all values between `startScore` and `endScore`.
`RFuture<Collection<V>>`	`valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Returns all values between `startScore` and `endScore`.
`RFuture<Collection<V>>`	`valueRangeAsync(int startIndex, int endIndex)` Returns values by rank range.
`Collection<V>`	`valueRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Returns all values between `startScore` and `endScore` in reversed order.
`Collection<V>`	`valueRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Returns all values between `startScore` and `endScore` in reversed order.
`Collection<V>`	`valueRangeReversed(int startIndex, int endIndex)` Returns values by rank range in reverse order.
`RFuture<Collection<V>>`	`valueRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)` Returns all values between `startScore` and `endScore` in reversed order.
`RFuture<Collection<V>>`	`valueRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)` Returns all values between `startScore` and `endScore` in reversed order.
`RFuture<Collection<V>>`	`valueRangeReversedAsync(int startIndex, int endIndex)` Returns values by rank range in reverse order.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface org.redisson.api.RExpirable
clearExpire, expire, expire, expireAt, expireAt, remainTimeToLive

Methods inherited from interface org.redisson.api.RObject
copy, delete, dump, getCodec, getIdleTime, getName, isExists, migrate, move, rename, renamenx, restore, restore, restoreAndReplace, restoreAndReplace, sizeInMemory, touch, unlink

Methods inherited from interface org.redisson.api.RExpirableAsync
clearExpireAsync, expireAsync, expireAsync, expireAtAsync, expireAtAsync, remainTimeToLiveAsync

Methods inherited from interface org.redisson.api.RObjectAsync
copyAsync, deleteAsync, dumpAsync, getIdleTimeAsync, isExistsAsync, migrateAsync, moveAsync, renameAsync, renamenxAsync, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, sizeInMemoryAsync, touchAsync, unlinkAsync

- Constructor Detail
  - RedissonScoredSortedSet
```
public RedissonScoredSortedSet(CommandAsyncExecutor commandExecutor,
                               String name,
                               RedissonClient redisson)
```
  - RedissonScoredSortedSet
```
public RedissonScoredSortedSet(Codec codec,
                               CommandAsyncExecutor commandExecutor,
                               String name,
                               RedissonClient redisson)
```
- Method Detail
  - mapReduce
```
public <KOut,VOut> RCollectionMapReduce<V,KOut,VOut> mapReduce()
```
    Description copied from interface: RScoredSortedSet
    
    Returns RMapReduce object associated with this object
    
    Specified by:
    
    mapReduce in interface RScoredSortedSet<V>
    
    Type Parameters:
    
    KOut - output key
    
    VOut - output value
    
    Returns:
    
    MapReduce instance
  - readAll
```
public Collection<V> readAll()
```
    Description copied from interface: RScoredSortedSet
    
    Read all values at once.
    
    Specified by:
    
    readAll in interface RScoredSortedSet<V>
    
    Returns:
    
    values
  - readAllAsync
```
public RFuture<Collection<V>> readAllAsync()
```
    Description copied from interface: RScoredSortedSetAsync
    
    Read all values at once.
    
    Specified by:
    
    readAllAsync in interface RScoredSortedSetAsync<V>
    
    Returns:
    
    values
  - pollFirst
```
public V pollFirst()
```
    Description copied from interface: RScoredSortedSet
    
    Removes and returns the head element or null if this sorted set is empty.
    
    Specified by:
    
    pollFirst in interface RScoredSortedSet<V>
    
    Returns:
    
    the head element, or null if this sorted set is empty
  - pollLast
```
public V pollLast()
```
    Description copied from interface: RScoredSortedSet
    
    Removes and returns the tail element or null if this sorted set is empty.
    
    Specified by:
    
    pollLast in interface RScoredSortedSet<V>
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - pollFirst
```
public Collection<V> pollFirst(int count)
```
    Description copied from interface: RScoredSortedSet
    
    Removes and returns the head elements of this sorted set.
    
    Specified by:
    
    pollFirst in interface RScoredSortedSet<V>
    
    Parameters:
    
    count - - elements amount
    
    Returns:
    
    the head elements of this sorted set
  - pollLast
```
public Collection<V> pollLast(int count)
```
    Description copied from interface: RScoredSortedSet
    
    Removes and returns the tail elements of this sorted set.
    
    Specified by:
    
    pollLast in interface RScoredSortedSet<V>
    
    Parameters:
    
    count - - elements amount
    
    Returns:
    
    the tail elements of this sorted set
  - pollFirstAsync
```
public RFuture<Collection<V>> pollFirstAsync(int count)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes and returns the head elements of this sorted set.
    
    Specified by:
    
    pollFirstAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    count - - elements amount
    
    Returns:
    
    the head elements of this sorted set
  - pollLastAsync
```
public RFuture<Collection<V>> pollLastAsync(int count)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes and returns the tail elements of this sorted set.
    
    Specified by:
    
    pollLastAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    count - - elements amount
    
    Returns:
    
    the tail elements of this sorted set
  - pollFirstAsync
```
public RFuture<V> pollFirstAsync()
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes and returns the head element or null if this sorted set is empty.
    
    Specified by:
    
    pollFirstAsync in interface RScoredSortedSetAsync<V>
    
    Returns:
    
    the head element, or null if this sorted set is empty
  - pollLastAsync
```
public RFuture<V> pollLastAsync()
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes and returns the tail element or null if this sorted set is empty.
    
    Specified by:
    
    pollLastAsync in interface RScoredSortedSetAsync<V>
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - pollFirst
```
public V pollFirst(long timeout,
                   TimeUnit unit)
```
    Description copied from interface: RScoredSortedSet
    
    Removes and returns the head element or null if this sorted set is empty.
    
    Specified by:
    
    pollFirst in interface RScoredSortedSet<V>
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    the head element, or null if this sorted set is empty
  - pollFirstAsync
```
public RFuture<V> pollFirstAsync(long timeout,
                                 TimeUnit unit)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes and returns the head element or null if this sorted set is empty.
    Requires Redis 5.0.0 and higher.
    
    Specified by:
    
    pollFirstAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    the head element, or null if this sorted set is empty
  - pollFirstFromAny
```
public V pollFirstFromAny(long timeout,
                          TimeUnit unit,
                          String... queueNames)
```
    Description copied from interface: RScoredSortedSet
    
    Removes and returns first available head element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
    Requires Redis 5.0.0 and higher.
    
    Specified by:
    
    pollFirstFromAny in interface RScoredSortedSet<V>
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    queueNames - - names of queue
    
    Returns:
    
    the head element, or null if all sorted sets are empty
  - pollFirstFromAnyAsync
```
public RFuture<V> pollFirstFromAnyAsync(long timeout,
                                        TimeUnit unit,
                                        String... queueNames)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes and returns first available head element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
    Requires Redis 5.0.0 and higher.
    
    Specified by:
    
    pollFirstFromAnyAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    queueNames - - names of queue
    
    Returns:
    
    the head element, or null if all sorted sets are empty
  - pollLastFromAny
```
public V pollLastFromAny(long timeout,
                         TimeUnit unit,
                         String... queueNames)
```
    Description copied from interface: RScoredSortedSet
    
    Removes and returns first available tail element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
    Requires Redis 5.0.0 and higher.
    
    Specified by:
    
    pollLastFromAny in interface RScoredSortedSet<V>
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    queueNames - - names of queue
    
    Returns:
    
    the tail element, or null if all sorted sets are empty
  - pollLastFromAnyAsync
```
public RFuture<V> pollLastFromAnyAsync(long timeout,
                                       TimeUnit unit,
                                       String... queueNames)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes and returns first available tail element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
    Requires Redis 5.0.0 and higher.
    
    Specified by:
    
    pollLastFromAnyAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    queueNames - - names of queue
    
    Returns:
    
    the tail element, or null if all sorted sets are empty
  - pollLast
```
public V pollLast(long timeout,
                  TimeUnit unit)
```
    Description copied from interface: RScoredSortedSet
    
    Removes and returns the tail element or null if this sorted set is empty.
    
    Specified by:
    
    pollLast in interface RScoredSortedSet<V>
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - pollLastAsync
```
public RFuture<V> pollLastAsync(long timeout,
                                TimeUnit unit)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes and returns the tail element or null if this sorted set is empty.
    Requires Redis 5.0.0 and higher.
    
    Specified by:
    
    pollLastAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - random
```
public V random()
```
    Description copied from interface: RScoredSortedSet
    
    Returns random element from this sorted set
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    random in interface RScoredSortedSet<V>
    
    Returns:
    
    random element
  - random
```
public Collection<V> random(int count)
```
    Description copied from interface: RScoredSortedSet
    
    Returns random elements from this sorted set limited by count
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    random in interface RScoredSortedSet<V>
    
    Parameters:
    
    count - - values amount to return
    
    Returns:
    
    random elements
  - randomAsync
```
public RFuture<V> randomAsync()
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns random element from this sorted set
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    randomAsync in interface RScoredSortedSetAsync<V>
    
    Returns:
    
    value
  - randomAsync
```
public RFuture<Collection<V>> randomAsync(int count)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns random elements from this sorted set limited by count
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    randomAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    count - - values amount to return
    
    Returns:
    
    value
  - randomEntries
```
public Map<V,Double> randomEntries(int count)
```
    Description copied from interface: RScoredSortedSet
    
    Returns random entries from this sorted set limited by count. Each map entry uses element as key and score as value.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    randomEntries in interface RScoredSortedSet<V>
    
    Parameters:
    
    count - - entries amount to return
    
    Returns:
    
    random entries
  - randomEntriesAsync
```
public RFuture<Map<V,Double>> randomEntriesAsync(int count)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns random entries from this sorted set limited by count. Each map entry uses element as key and score as value.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    randomEntriesAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    count - - entries amount to return
    
    Returns:
    
    random entries
  - add
```
public boolean add(double score,
                   V object)
```
    Description copied from interface: RScoredSortedSet
    
    Adds element to this set, overrides previous score if it has been already added.
    
    Specified by:
    
    add in interface RScoredSortedSet<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element has added and false if not.
  - addAndGetRank
```
public Integer addAndGetRank(double score,
                             V object)
```
    Description copied from interface: RScoredSortedSet
    
    Adds element to this set, overrides previous score if it has been already added. Finally return the rank of the item
    
    Specified by:
    
    addAndGetRank in interface RScoredSortedSet<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    rank
  - addAndGetRankAsync
```
public RFuture<Integer> addAndGetRankAsync(double score,
                                           V object)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Adds element to this set, overrides previous score if it has been already added. Finally return the rank of the item
    
    Specified by:
    
    addAndGetRankAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    rank
  - addAndGetRevRank
```
public Integer addAndGetRevRank(double score,
                                V object)
```
    Description copied from interface: RScoredSortedSet
    
    Adds element to this set, overrides previous score if it has been already added. Finally return the reverse rank of the item
    
    Specified by:
    
    addAndGetRevRank in interface RScoredSortedSet<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    reverse rank
  - addAndGetRevRank
```
public List<Integer> addAndGetRevRank(Map<? extends V,Double> map)
```
    Description copied from interface: RScoredSortedSet
    
    Adds elements to this set, overrides previous score if it has been already added. Finally returns reverse rank list of the items
    
    Specified by:
    
    addAndGetRevRank in interface RScoredSortedSet<V>
    
    Parameters:
    
    map - - map of object and scores, make sure to use an ordered map
    
    Returns:
    
    collection of reverse ranks
  - addAndGetRevRankAsync
```
public RFuture<Integer> addAndGetRevRankAsync(double score,
                                              V object)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Adds element to this set, overrides previous score if it has been already added. Finally return the reverse rank of the item
    
    Specified by:
    
    addAndGetRevRankAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    reverse rank
  - addAndGetRevRankAsync
```
public RFuture<List<Integer>> addAndGetRevRankAsync(Map<? extends V,Double> map)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Adds elements to this set, overrides previous score if it has been already added. Finally returns reverse rank list of the items
    
    Specified by:
    
    addAndGetRevRankAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    map - - map of object and scores, make sure to use an ordered map
    
    Returns:
    
    collection of reverse ranks
  - tryAdd
```
public boolean tryAdd(double score,
                      V object)
```
    Description copied from interface: RScoredSortedSet
    
    Adds element to this set only if has not been added before.
    Requires Redis 3.0.2 and higher.
    
    Specified by:
    
    tryAdd in interface RScoredSortedSet<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element added and false if not.
  - addIfExists
```
public boolean addIfExists(double score,
                           V object)
```
    Description copied from interface: RScoredSortedSet
    
    Adds element to this set only if it's already exists.
    Requires Redis 3.0.2 and higher.
    
    Specified by:
    
    addIfExists in interface RScoredSortedSet<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element added and false if not.
  - addIfExistsAsync
```
public RFuture<Boolean> addIfExistsAsync(double score,
                                         V object)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Adds element to this set only if it's already exists.
    Requires Redis 3.0.2 and higher.
    
    Specified by:
    
    addIfExistsAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element added and false if not.
  - addIfLess
```
public boolean addIfLess(double score,
                         V object)
```
    Description copied from interface: RScoredSortedSet
    
    Adds element to this set only if new score less than current score of existed element.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    addIfLess in interface RScoredSortedSet<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element added and false if not.
  - addIfGreater
```
public boolean addIfGreater(double score,
                            V object)
```
    Description copied from interface: RScoredSortedSet
    
    Adds element to this set only if new score greater than current score of existed element.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    addIfGreater in interface RScoredSortedSet<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element added and false if not.
  - addIfLessAsync
```
public RFuture<Boolean> addIfLessAsync(double score,
                                       V object)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Adds element to this set only if new score less than current score of existed element.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    addIfLessAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element added and false if not.
  - addIfGreaterAsync
```
public RFuture<Boolean> addIfGreaterAsync(double score,
                                          V object)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Adds element to this set only if new score greater than current score of existed element.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    addIfGreaterAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element added and false if not.
  - first
```
public V first()
```
    Description copied from interface: RScoredSortedSet
    
    Returns the head element or null if this sorted set is empty.
    
    Specified by:
    
    first in interface RScoredSortedSet<V>
    
    Returns:
    
    the head element or null if this sorted set is empty
  - firstAsync
```
public RFuture<V> firstAsync()
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns the head element or null if this sorted set is empty.
    
    Specified by:
    
    firstAsync in interface RScoredSortedSetAsync<V>
    
    Returns:
    
    the head element or null if this sorted set is empty
  - last
```
public V last()
```
    Description copied from interface: RScoredSortedSet
    
    Returns the tail element or null if this sorted set is empty.
    
    Specified by:
    
    last in interface RScoredSortedSet<V>
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - lastAsync
```
public RFuture<V> lastAsync()
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns the tail element or null if this sorted set is empty.
    
    Specified by:
    
    lastAsync in interface RScoredSortedSetAsync<V>
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - firstScore
```
public Double firstScore()
```
    Description copied from interface: RScoredSortedSet
    
    Returns score of the tail element or returns null if this sorted set is empty.
    
    Specified by:
    
    firstScore in interface RScoredSortedSet<V>
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - firstScoreAsync
```
public RFuture<Double> firstScoreAsync()
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns score of the head element or returns null if this sorted set is empty.
    
    Specified by:
    
    firstScoreAsync in interface RScoredSortedSetAsync<V>
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - lastScore
```
public Double lastScore()
```
    Description copied from interface: RScoredSortedSet
    
    Returns score of the head element or returns null if this sorted set is empty.
    
    Specified by:
    
    lastScore in interface RScoredSortedSet<V>
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - lastScoreAsync
```
public RFuture<Double> lastScoreAsync()
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns score of the tail element or returns null if this sorted set is empty.
    
    Specified by:
    
    lastScoreAsync in interface RScoredSortedSetAsync<V>
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - addAsync
```
public RFuture<Boolean> addAsync(double score,
                                 V object)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Adds element to this set, overrides previous score if it has been already added.
    
    Specified by:
    
    addAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element has added and false if not.
  - addAll
```
public int addAll(Map<V,Double> objects)
```
    Description copied from interface: RScoredSortedSet
    
    Adds all elements contained in the specified map to this sorted set. Map contains of score mapped by object.
    
    Specified by:
    
    addAll in interface RScoredSortedSet<V>
    
    Parameters:
    
    objects - - map of elements to add
    
    Returns:
    
    amount of added elements, not including already existing in this sorted set
  - addAllAsync
```
public RFuture<Integer> addAllAsync(Map<V,Double> objects)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Adds all elements contained in the specified map to this sorted set. Map contains of score mapped by object.
    
    Specified by:
    
    addAllAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    objects - - map of elements to add
    
    Returns:
    
    amount of added elements, not including already existing in this sorted set
  - tryAddAsync
```
public RFuture<Boolean> tryAddAsync(double score,
                                    V object)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Adds element to this set only if has not been added before.
    Requires Redis 3.0.2 and higher.
    
    Specified by:
    
    tryAddAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element has added and false if not.
  - remove
```
public boolean remove(Object object)
```
    Description copied from interface: RScoredSortedSet
    
    Removes a single instance of the specified element from this sorted set, if it is present.
    
    Specified by:
    
    remove in interface RScoredSortedSet<V>
    
    Parameters:
    
    object - element to be removed from this sorted set, if present
    
    Returns:
    
    true if an element was removed as a result of this call
  - removeRangeByRank
```
public int removeRangeByRank(int startIndex,
                             int endIndex)
```
    Description copied from interface: RScoredSortedSet
    
    Removes values by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Specified by:
    
    removeRangeByRank in interface RScoredSortedSet<V>
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    number of elements removed
  - removeRangeByRankAsync
```
public RFuture<Integer> removeRangeByRankAsync(int startIndex,
                                               int endIndex)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes values by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Specified by:
    
    removeRangeByRankAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    number of elements removed
  - removeRangeByScore
```
public int removeRangeByScore(double startScore,
                              boolean startScoreInclusive,
                              double endScore,
                              boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSet
    
    Removes values by score range.
    
    Specified by:
    
    removeRangeByScore in interface RScoredSortedSet<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    number of elements removed
  - removeRangeByScoreAsync
```
public RFuture<Integer> removeRangeByScoreAsync(double startScore,
                                                boolean startScoreInclusive,
                                                double endScore,
                                                boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes values by score range.
    
    Specified by:
    
    removeRangeByScoreAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    number of elements removed
  - clear
```
public void clear()
```
    Description copied from interface: RScoredSortedSet
    
    Removes all elements of this sorted set.
    
    Specified by:
    
    clear in interface RScoredSortedSet<V>
  - removeAsync
```
public RFuture<Boolean> removeAsync(Object object)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes a single instance of the specified element from this sorted set, if it is present.
    
    Specified by:
    
    removeAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    object - element to be removed from this sorted set, if present
    
    Returns:
    
    true if an element was removed as a result of this call
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: RScoredSortedSet
    
    Returns true if this set is empty
    
    Specified by:
    
    isEmpty in interface RScoredSortedSet<V>
    
    Returns:
    
    true if empty
  - size
```
public int size()
```
    Description copied from interface: RScoredSortedSet
    
    Returns size of this set.
    
    Specified by:
    
    size in interface RScoredSortedSet<V>
    
    Returns:
    
    size
  - sizeAsync
```
public RFuture<Integer> sizeAsync()
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns size of this set.
    
    Specified by:
    
    sizeAsync in interface RScoredSortedSetAsync<V>
    
    Returns:
    
    size
  - contains
```
public boolean contains(Object object)
```
    Description copied from interface: RScoredSortedSet
    
    Returns true if this sorted set contains encoded state of the specified element.
    
    Specified by:
    
    contains in interface RScoredSortedSet<V>
    
    Parameters:
    
    object - element whose presence in this collection is to be tested
    
    Returns:
    
    true if this sorted set contains the specified element and false otherwise
  - containsAsync
```
public RFuture<Boolean> containsAsync(Object o)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns true if this sorted set contains encoded state of the specified element.
    
    Specified by:
    
    containsAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    o - element whose presence in this collection is to be tested
    
    Returns:
    
    true if this sorted set contains the specified element and false otherwise
  - getScore
```
public Double getScore(V o)
```
    Description copied from interface: RScoredSortedSet
    
    Returns score of element or null if it doesn't exist.
    
    Specified by:
    
    getScore in interface RScoredSortedSet<V>
    
    Parameters:
    
    o - - element
    
    Returns:
    
    score
  - getScore
```
public List<Double> getScore(List<V> keys)
```
    Description copied from interface: RScoredSortedSet
    
    Returns scores of elements.
    
    Specified by:
    
    getScore in interface RScoredSortedSet<V>
    
    Parameters:
    
    keys - - elements
    
    Returns:
    
    element scores
  - getScoreAsync
```
public RFuture<Double> getScoreAsync(V o)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns score of element or null if it doesn't exist.
    
    Specified by:
    
    getScoreAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    o - - element
    
    Returns:
    
    score
  - getScoreAsync
```
public RFuture<List<Double>> getScoreAsync(Collection<V> elements)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns scores of elements.
    
    Specified by:
    
    getScoreAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    elements - - elements
    
    Returns:
    
    element scores
  - rank
```
public Integer rank(V o)
```
    Description copied from interface: RScoredSortedSet
    
    Returns rank of value, with the scores ordered from low to high.
    
    Specified by:
    
    rank in interface RScoredSortedSet<V>
    
    Parameters:
    
    o - - object
    
    Returns:
    
    rank or null if value does not exist
  - rankAsync
```
public RFuture<Integer> rankAsync(V o)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns rank of value, with the scores ordered from low to high.
    
    Specified by:
    
    rankAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    o - - object
    
    Returns:
    
    rank or null if value does not exist
  - scanIteratorAsync
```
public RFuture<ListScanResult<Object>> scanIteratorAsync(RedisClient client,
                                                         long startPos,
                                                         String pattern,
                                                         int count)
```
  - iterator
```
public Iterator<V> iterator()
```
    Specified by:
    
    iterator in interface Iterable<V>
  - iterator
```
public Iterator<V> iterator(String pattern)
```
    Description copied from interface: RScoredSortedSet
    
    Returns an iterator over elements in this set. If pattern is not null then only elements match this pattern are loaded.
    
    Specified by:
    
    iterator in interface RScoredSortedSet<V>
    
    Parameters:
    
    pattern - - search pattern
    
    Returns:
    
    iterator
  - iterator
```
public Iterator<V> iterator(int count)
```
    Description copied from interface: RScoredSortedSet
    
    Returns an iterator over elements in this set. Elements are loaded in batch. Batch size is defined by count param.
    
    Specified by:
    
    iterator in interface RScoredSortedSet<V>
    
    Parameters:
    
    count - - size of elements batch
    
    Returns:
    
    iterator
  - iterator
```
public Iterator<V> iterator(String pattern,
                            int count)
```
    Description copied from interface: RScoredSortedSet
    
    Returns an iterator over elements in this set. Elements are loaded in batch. Batch size is defined by count param. If pattern is not null then only elements match this pattern are loaded.
    
    Specified by:
    
    iterator in interface RScoredSortedSet<V>
    
    Parameters:
    
    pattern - - search pattern
    
    count - - size of elements batch
    
    Returns:
    
    iterator
  - toArray
```
public Object[] toArray()
```
    Description copied from interface: RScoredSortedSet
    
    Returns this sorted set in array of Object type.
    
    Specified by:
    
    toArray in interface RScoredSortedSet<V>
    
    Returns:
    
    array of values
  - toArray
```
public <T> T[] toArray(T[] a)
```
    Description copied from interface: RScoredSortedSet
    
    Returns this sorted set in array of defined type.
    
    Specified by:
    
    toArray in interface RScoredSortedSet<V>
    
    Type Parameters:
    
    T - type of element
    
    Parameters:
    
    a - - instance of array
    
    Returns:
    
    array of values
  - containsAll
```
public boolean containsAll(Collection<?> c)
```
    Description copied from interface: RScoredSortedSet
    
    Returns true if this sorted set contains all of the elements in encoded state in the specified collection.
    
    Specified by:
    
    containsAll in interface RScoredSortedSet<V>
    
    Parameters:
    
    c - collection to be checked for containment in this sorted set
    
    Returns:
    
    true if this sorted set contains all of the elements in the specified collection
  - containsAllAsync
```
public RFuture<Boolean> containsAllAsync(Collection<?> c)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns true if this sorted set contains all of the elements in encoded state in the specified collection.
    
    Specified by:
    
    containsAllAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    c - collection to be checked for containment in this sorted set
    
    Returns:
    
    true if this sorted set contains all of the elements in the specified collection
  - removeAllAsync
```
public RFuture<Boolean> removeAllAsync(Collection<?> c)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes all of this sorted set's elements that are also contained in the specified collection.
    
    Specified by:
    
    removeAllAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    c - sorted set containing elements to be removed from this collection
    
    Returns:
    
    true if this sorted set changed as a result of the call
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    Description copied from interface: RScoredSortedSet
    
    Removes all of this sorted set's elements that are also contained in the specified collection.
    
    Specified by:
    
    removeAll in interface RScoredSortedSet<V>
    
    Parameters:
    
    c - collection containing elements to be removed from this collection
    
    Returns:
    
    true if this sorted set changed as a result of the call
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    Description copied from interface: RScoredSortedSet
    
    Retains only the elements in this sorted set that are contained in the specified collection.
    
    Specified by:
    
    retainAll in interface RScoredSortedSet<V>
    
    Parameters:
    
    c - collection containing elements to be retained in this collection
    
    Returns:
    
    true if this sorted set changed as a result of the call
  - retainAllAsync
```
public RFuture<Boolean> retainAllAsync(Collection<?> c)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Retains only the elements in this sorted set that are contained in the specified collection.
    
    Specified by:
    
    retainAllAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    c - collection containing elements to be retained in this collection
    
    Returns:
    
    true if this sorted set changed as a result of the call
  - addScore
```
public Double addScore(V object,
                       Number value)
```
    Description copied from interface: RScoredSortedSet
    
    Increases score of specified element by value.
    
    Specified by:
    
    addScore in interface RScoredSortedSet<V>
    
    Parameters:
    
    object - - element whose score needs to be increased
    
    value - - value
    
    Returns:
    
    updated score of element
  - addScoreAsync
```
public RFuture<Double> addScoreAsync(V object,
                                     Number value)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Increases score of specified element by value.
    
    Specified by:
    
    addScoreAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    object - - element whose score needs to be increased
    
    value - - value
    
    Returns:
    
    updated score of element
  - addScoreAndGetRank
```
public Integer addScoreAndGetRank(V object,
                                  Number value)
```
    Description copied from interface: RScoredSortedSet
    
    Adds score to element and returns its rank
    
    Specified by:
    
    addScoreAndGetRank in interface RScoredSortedSet<V>
    
    Parameters:
    
    object - - object itself
    
    value - - object score
    
    Returns:
    
    rank
  - addScoreAndGetRankAsync
```
public RFuture<Integer> addScoreAndGetRankAsync(V object,
                                                Number value)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Adds score to element and returns its rank
    
    Specified by:
    
    addScoreAndGetRankAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    object - - object itself
    
    value - - object score
    
    Returns:
    
    rank
  - addScoreAndGetRevRank
```
public Integer addScoreAndGetRevRank(V object,
                                     Number value)
```
    Description copied from interface: RScoredSortedSet
    
    Adds score to element and returns its reverse rank
    
    Specified by:
    
    addScoreAndGetRevRank in interface RScoredSortedSet<V>
    
    Parameters:
    
    object - - object itself
    
    value - - object score
    
    Returns:
    
    reverse rank
  - addScoreAndGetRevRankAsync
```
public RFuture<Integer> addScoreAndGetRevRankAsync(V object,
                                                   Number value)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Adds score to element and returns its reverse rank
    
    Specified by:
    
    addScoreAndGetRevRankAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    object - - object itself
    
    value - - object score
    
    Returns:
    
    reverse rank
  - valueRange
```
public Collection<V> valueRange(int startIndex,
                                int endIndex)
```
    Description copied from interface: RScoredSortedSet
    
    Returns values by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Specified by:
    
    valueRange in interface RScoredSortedSet<V>
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - valueRangeAsync
```
public RFuture<Collection<V>> valueRangeAsync(int startIndex,
                                              int endIndex)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns values by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    valueRangeAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - valueRangeReversed
```
public Collection<V> valueRangeReversed(int startIndex,
                                        int endIndex)
```
    Description copied from interface: RScoredSortedSet
    
    Returns values by rank range in reverse order. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Specified by:
    
    valueRangeReversed in interface RScoredSortedSet<V>
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - valueRangeReversedAsync
```
public RFuture<Collection<V>> valueRangeReversedAsync(int startIndex,
                                                      int endIndex)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns values by rank range in reverse order. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Specified by:
    
    valueRangeReversedAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - entryRange
```
public Collection<ScoredEntry<V>> entryRange(int startIndex,
                                             int endIndex)
```
    Description copied from interface: RScoredSortedSet
    
    Returns entries (value and its score) by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Specified by:
    
    entryRange in interface RScoredSortedSet<V>
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    entries
  - entryRangeAsync
```
public RFuture<Collection<ScoredEntry<V>>> entryRangeAsync(int startIndex,
                                                           int endIndex)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns entries (value and its score) by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Specified by:
    
    entryRangeAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    entries
  - entryRangeReversed
```
public Collection<ScoredEntry<V>> entryRangeReversed(int startIndex,
                                                     int endIndex)
```
    Description copied from interface: RScoredSortedSet
    
    Returns entries (value and its score) by rank range in reverse order. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Specified by:
    
    entryRangeReversed in interface RScoredSortedSet<V>
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    entries
  - entryRangeReversedAsync
```
public RFuture<Collection<ScoredEntry<V>>> entryRangeReversedAsync(int startIndex,
                                                                   int endIndex)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns entries (value and its score) by rank range in reverse order. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Specified by:
    
    entryRangeReversedAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    entries
  - valueRange
```
public Collection<V> valueRange(double startScore,
                                boolean startScoreInclusive,
                                double endScore,
                                boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSet
    
    Returns all values between startScore and endScore.
    
    Specified by:
    
    valueRange in interface RScoredSortedSet<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    values
  - valueRangeAsync
```
public RFuture<Collection<V>> valueRangeAsync(double startScore,
                                              boolean startScoreInclusive,
                                              double endScore,
                                              boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns all values between startScore and endScore.
    
    Specified by:
    
    valueRangeAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    values
  - valueRangeReversed
```
public Collection<V> valueRangeReversed(double startScore,
                                        boolean startScoreInclusive,
                                        double endScore,
                                        boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSet
    
    Returns all values between startScore and endScore in reversed order.
    
    Specified by:
    
    valueRangeReversed in interface RScoredSortedSet<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    values
  - valueRangeReversedAsync
```
public RFuture<Collection<V>> valueRangeReversedAsync(double startScore,
                                                      boolean startScoreInclusive,
                                                      double endScore,
                                                      boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns all values between startScore and endScore in reversed order.
    
    Specified by:
    
    valueRangeReversedAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    values
  - entryRange
```
public Collection<ScoredEntry<V>> entryRange(double startScore,
                                             boolean startScoreInclusive,
                                             double endScore,
                                             boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSet
    
    Returns all entries (value and its score) between startScore and endScore.
    
    Specified by:
    
    entryRange in interface RScoredSortedSet<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    entries
  - entryRangeAsync
```
public RFuture<Collection<ScoredEntry<V>>> entryRangeAsync(double startScore,
                                                           boolean startScoreInclusive,
                                                           double endScore,
                                                           boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns all entries (value and its score) between startScore and endScore.
    
    Specified by:
    
    entryRangeAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    entries
  - valueRange
```
public Collection<V> valueRange(double startScore,
                                boolean startScoreInclusive,
                                double endScore,
                                boolean endScoreInclusive,
                                int offset,
                                int count)
```
    Description copied from interface: RScoredSortedSet
    
    Returns all values between startScore and endScore.
    
    Specified by:
    
    valueRange in interface RScoredSortedSet<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    values
  - valueRangeAsync
```
public RFuture<Collection<V>> valueRangeAsync(double startScore,
                                              boolean startScoreInclusive,
                                              double endScore,
                                              boolean endScoreInclusive,
                                              int offset,
                                              int count)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns all values between startScore and endScore.
    
    Specified by:
    
    valueRangeAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    values
  - valueRangeReversed
```
public Collection<V> valueRangeReversed(double startScore,
                                        boolean startScoreInclusive,
                                        double endScore,
                                        boolean endScoreInclusive,
                                        int offset,
                                        int count)
```
    Description copied from interface: RScoredSortedSet
    
    Returns all values between startScore and endScore in reversed order.
    
    Specified by:
    
    valueRangeReversed in interface RScoredSortedSet<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    values
  - valueRangeReversedAsync
```
public RFuture<Collection<V>> valueRangeReversedAsync(double startScore,
                                                      boolean startScoreInclusive,
                                                      double endScore,
                                                      boolean endScoreInclusive,
                                                      int offset,
                                                      int count)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns all values between startScore and endScore in reversed order.
    
    Specified by:
    
    valueRangeReversedAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    values
  - entryRange
```
public Collection<ScoredEntry<V>> entryRange(double startScore,
                                             boolean startScoreInclusive,
                                             double endScore,
                                             boolean endScoreInclusive,
                                             int offset,
                                             int count)
```
    Description copied from interface: RScoredSortedSet
    
    Returns all entries (value and its score) between startScore and endScore.
    
    Specified by:
    
    entryRange in interface RScoredSortedSet<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    entries
  - entryRangeReversed
```
public Collection<ScoredEntry<V>> entryRangeReversed(double startScore,
                                                     boolean startScoreInclusive,
                                                     double endScore,
                                                     boolean endScoreInclusive,
                                                     int offset,
                                                     int count)
```
    Description copied from interface: RScoredSortedSet
    
    Returns all entries (value and its score) between startScore and endScore in reversed order.
    
    Specified by:
    
    entryRangeReversed in interface RScoredSortedSet<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    entries
  - entryRangeAsync
```
public RFuture<Collection<ScoredEntry<V>>> entryRangeAsync(double startScore,
                                                           boolean startScoreInclusive,
                                                           double endScore,
                                                           boolean endScoreInclusive,
                                                           int offset,
                                                           int count)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns all entries (value and its score) between startScore and endScore.
    
    Specified by:
    
    entryRangeAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    entries
  - entryRangeReversed
```
public Collection<ScoredEntry<V>> entryRangeReversed(double startScore,
                                                     boolean startScoreInclusive,
                                                     double endScore,
                                                     boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSet
    
    Returns all entries (value and its score) between startScore and endScore in reversed order.
    
    Specified by:
    
    entryRangeReversed in interface RScoredSortedSet<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    entries
  - entryRangeReversedAsync
```
public RFuture<Collection<ScoredEntry<V>>> entryRangeReversedAsync(double startScore,
                                                                   boolean startScoreInclusive,
                                                                   double endScore,
                                                                   boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns all entries (value and its score) between startScore and endScore in reversed order.
    
    Specified by:
    
    entryRangeReversedAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    entries
  - entryRangeReversedAsync
```
public RFuture<Collection<ScoredEntry<V>>> entryRangeReversedAsync(double startScore,
                                                                   boolean startScoreInclusive,
                                                                   double endScore,
                                                                   boolean endScoreInclusive,
                                                                   int offset,
                                                                   int count)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns all entries (value and its score) between startScore and endScore in reversed order.
    
    Specified by:
    
    entryRangeReversedAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    entries
  - revRankAsync
```
public RFuture<Integer> revRankAsync(V o)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns rank of value, with the scores ordered from high to low.
    
    Specified by:
    
    revRankAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    o - - object
    
    Returns:
    
    rank or null if value does not exist
  - revRank
```
public Integer revRank(V o)
```
    Description copied from interface: RScoredSortedSet
    
    Returns rank of value, with the scores ordered from high to low.
    
    Specified by:
    
    revRank in interface RScoredSortedSet<V>
    
    Parameters:
    
    o - - object
    
    Returns:
    
    rank or null if value does not exist
  - revRankAsync
```
public RFuture<List<Integer>> revRankAsync(Collection<V> elements)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns ranks of elements, with the scores ordered from high to low.
    
    Specified by:
    
    revRankAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    elements - - elements
    
    Returns:
    
    ranks or null if value does not exist
  - revRank
```
public List<Integer> revRank(Collection<V> elements)
```
    Description copied from interface: RScoredSortedSet
    
    Returns ranks of elements, with the scores ordered from high to low.
    
    Specified by:
    
    revRank in interface RScoredSortedSet<V>
    
    Parameters:
    
    elements - - elements
    
    Returns:
    
    ranks or null if value does not exist
  - count
```
public int count(double startScore,
                 boolean startScoreInclusive,
                 double endScore,
                 boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSet
    
    Returns the number of elements with a score between startScore and endScore.
    
    Specified by:
    
    count in interface RScoredSortedSet<V>
    
    Parameters:
    
    startScore - - start score
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    count of elements
  - countAsync
```
public RFuture<Integer> countAsync(double startScore,
                                   boolean startScoreInclusive,
                                   double endScore,
                                   boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Returns the number of elements with a score between startScore and endScore.
    
    Specified by:
    
    countAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    startScore - - start score
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    count
  - intersection
```
public int intersection(String... names)
```
    Description copied from interface: RScoredSortedSet
    
    Intersect provided ScoredSortedSets and store result to current ScoredSortedSet
    
    Specified by:
    
    intersection in interface RScoredSortedSet<V>
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of intersection
  - intersectionAsync
```
public RFuture<Integer> intersectionAsync(String... names)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Intersect provided ScoredSortedSets and store result to current ScoredSortedSet
    
    Specified by:
    
    intersectionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of intersection
  - intersection
```
public int intersection(RScoredSortedSet.Aggregate aggregate,
                        String... names)
```
    Description copied from interface: RScoredSortedSet
    
    Intersect provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
    
    Specified by:
    
    intersection in interface RScoredSortedSet<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of intersection
  - intersectionAsync
```
public RFuture<Integer> intersectionAsync(RScoredSortedSet.Aggregate aggregate,
                                          String... names)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Intersect provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
    
    Specified by:
    
    intersectionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of intersection
  - intersection
```
public int intersection(Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSet
    
    Intersect provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
    
    Specified by:
    
    intersection in interface RScoredSortedSet<V>
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of intersection
  - intersectionAsync
```
public RFuture<Integer> intersectionAsync(Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Intersect provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
    
    Specified by:
    
    intersectionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of intersection
  - intersection
```
public int intersection(RScoredSortedSet.Aggregate aggregate,
                        Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSet
    
    Intersect provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
    
    Specified by:
    
    intersection in interface RScoredSortedSet<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of intersection
  - intersectionAsync
```
public RFuture<Integer> intersectionAsync(RScoredSortedSet.Aggregate aggregate,
                                          Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Intersect provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
    
    Specified by:
    
    intersectionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of intersection
  - readIntersection
```
public Collection<V> readIntersection(String... names)
```
    Description copied from interface: RScoredSortedSet
    
    Intersect provided ScoredSortedSets with current ScoredSortedSet without state change
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readIntersection in interface RScoredSortedSet<V>
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of intersection
  - readIntersectionAsync
```
public RFuture<Collection<V>> readIntersectionAsync(String... names)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Intersect provided ScoredSortedSets with current ScoredSortedSet without state change
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readIntersectionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of intersection
  - readIntersection
```
public Collection<V> readIntersection(RScoredSortedSet.Aggregate aggregate,
                                      String... names)
```
    Description copied from interface: RScoredSortedSet
    
    Intersect provided ScoredSortedSets with current ScoredSortedSet using defined aggregation method without state change
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readIntersection in interface RScoredSortedSet<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of intersection
  - readIntersectionAsync
```
public RFuture<Collection<V>> readIntersectionAsync(RScoredSortedSet.Aggregate aggregate,
                                                    String... names)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Intersect provided ScoredSortedSets with current ScoredSortedSet using defined aggregation method without state change
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readIntersectionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of intersection
  - readIntersection
```
public Collection<V> readIntersection(Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSet
    
    Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet without state change
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readIntersection in interface RScoredSortedSet<V>
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of intersection
  - readIntersectionAsync
```
public RFuture<Collection<V>> readIntersectionAsync(Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet without state change
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readIntersectionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of intersection
  - readIntersection
```
public Collection<V> readIntersection(RScoredSortedSet.Aggregate aggregate,
                                      Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSet
    
    Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet using defined aggregation method without state change
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readIntersection in interface RScoredSortedSet<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of intersection
  - readIntersectionAsync
```
public RFuture<Collection<V>> readIntersectionAsync(RScoredSortedSet.Aggregate aggregate,
                                                    Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet using defined aggregation method without state change
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readIntersectionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of intersection
  - union
```
public int union(String... names)
```
    Description copied from interface: RScoredSortedSet
    
    Union provided ScoredSortedSets and store result to current ScoredSortedSet
    
    Specified by:
    
    union in interface RScoredSortedSet<V>
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of union
  - unionAsync
```
public RFuture<Integer> unionAsync(String... names)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Union provided ScoredSortedSets and store result to current ScoredSortedSet
    
    Specified by:
    
    unionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of union
  - union
```
public int union(RScoredSortedSet.Aggregate aggregate,
                 String... names)
```
    Description copied from interface: RScoredSortedSet
    
    Union provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
    
    Specified by:
    
    union in interface RScoredSortedSet<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of union
  - unionAsync
```
public RFuture<Integer> unionAsync(RScoredSortedSet.Aggregate aggregate,
                                   String... names)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Union provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
    
    Specified by:
    
    unionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of union
  - union
```
public int union(Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSet
    
    Union provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
    
    Specified by:
    
    union in interface RScoredSortedSet<V>
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of union
  - unionAsync
```
public RFuture<Integer> unionAsync(Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Union provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
    
    Specified by:
    
    unionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of union
  - union
```
public int union(RScoredSortedSet.Aggregate aggregate,
                 Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSet
    
    Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
    
    Specified by:
    
    union in interface RScoredSortedSet<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of union
  - unionAsync
```
public RFuture<Integer> unionAsync(RScoredSortedSet.Aggregate aggregate,
                                   Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
    
    Specified by:
    
    unionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of union
  - readUnion
```
public Collection<V> readUnion(String... names)
```
    Description copied from interface: RScoredSortedSet
    
    Union ScoredSortedSets specified by name with current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readUnion in interface RScoredSortedSet<V>
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of union
  - readUnionAsync
```
public RFuture<Collection<V>> readUnionAsync(String... names)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Union ScoredSortedSets specified by name with current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readUnionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of union
  - readUnion
```
public Collection<V> readUnion(RScoredSortedSet.Aggregate aggregate,
                               String... names)
```
    Description copied from interface: RScoredSortedSet
    
    Union ScoredSortedSets specified by name with defined aggregation method and current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readUnion in interface RScoredSortedSet<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of union
  - readUnionAsync
```
public RFuture<Collection<V>> readUnionAsync(RScoredSortedSet.Aggregate aggregate,
                                             String... names)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Union ScoredSortedSets specified by name with defined aggregation method and current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readUnionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of union
  - readUnion
```
public Collection<V> readUnion(Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSet
    
    Union provided ScoredSortedSets mapped to weight multiplier and current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readUnion in interface RScoredSortedSet<V>
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of union
  - readUnionAsync
```
public RFuture<Collection<V>> readUnionAsync(Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Union provided ScoredSortedSets mapped to weight multiplier and current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readUnionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of union
  - readUnion
```
public Collection<V> readUnion(RScoredSortedSet.Aggregate aggregate,
                               Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSet
    
    Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and current ScoredSortedSet without state change
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readUnion in interface RScoredSortedSet<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of union
  - readUnionAsync
```
public RFuture<Collection<V>> readUnionAsync(RScoredSortedSet.Aggregate aggregate,
                                             Map<String,Double> nameWithWeight)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and current ScoredSortedSet without state change
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readUnionAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of union
  - readSort
```
public Set<V> readSort(SortOrder order)
```
    Description copied from interface: RSortable
    
    Read data in sorted view
    
    Specified by:
    
    readSort in interface RSortable<Set<V>>
    
    Parameters:
    
    order - for sorted data
    
    Returns:
    
    sorted collection
  - readSortAsync
```
public RFuture<Set<V>> readSortAsync(SortOrder order)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view
    
    Specified by:
    
    readSortAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    order - for sorted data
    
    Returns:
    
    sorted collection
  - readSort
```
public Set<V> readSort(SortOrder order,
                       int offset,
                       int count)
```
    Description copied from interface: RSortable
    
    Read data in sorted view
    
    Specified by:
    
    readSort in interface RSortable<Set<V>>
    
    Parameters:
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection
  - readSortAsync
```
public RFuture<Set<V>> readSortAsync(SortOrder order,
                                     int offset,
                                     int count)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view
    
    Specified by:
    
    readSortAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection
  - readSort
```
public Set<V> readSort(String byPattern,
                       SortOrder order)
```
    Description copied from interface: RSortable
    
    Read data in sorted view
    
    Specified by:
    
    readSort in interface RSortable<Set<V>>
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    Returns:
    
    sorted collection
  - readSortAsync
```
public RFuture<Set<V>> readSortAsync(String byPattern,
                                     SortOrder order)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view
    
    Specified by:
    
    readSortAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    Returns:
    
    sorted collection
  - readSort
```
public Set<V> readSort(String byPattern,
                       SortOrder order,
                       int offset,
                       int count)
```
    Description copied from interface: RSortable
    
    Read data in sorted view
    
    Specified by:
    
    readSort in interface RSortable<Set<V>>
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection
  - readSortAsync
```
public RFuture<Set<V>> readSortAsync(String byPattern,
                                     SortOrder order,
                                     int offset,
                                     int count)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view
    
    Specified by:
    
    readSortAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection
  - readSort
```
public <T> Collection<T> readSort(String byPattern,
                                  List<String> getPatterns,
                                  SortOrder order)
```
    Description copied from interface: RSortable
    
    Read data in sorted view
    
    Specified by:
    
    readSort in interface RSortable<Set<V>>
    
    Type Parameters:
    
    T - object type
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    Returns:
    
    sorted collection
  - readSortAsync
```
public <T> RFuture<Collection<T>> readSortAsync(String byPattern,
                                                List<String> getPatterns,
                                                SortOrder order)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view
    
    Specified by:
    
    readSortAsync in interface RSortableAsync<Set<V>>
    
    Type Parameters:
    
    T - object type
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    Returns:
    
    sorted collection
  - readSort
```
public <T> Collection<T> readSort(String byPattern,
                                  List<String> getPatterns,
                                  SortOrder order,
                                  int offset,
                                  int count)
```
    Description copied from interface: RSortable
    
    Read data in sorted view
    
    Specified by:
    
    readSort in interface RSortable<Set<V>>
    
    Type Parameters:
    
    T - object type
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection
  - readSortAsync
```
public <T> RFuture<Collection<T>> readSortAsync(String byPattern,
                                                List<String> getPatterns,
                                                SortOrder order,
                                                int offset,
                                                int count)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view
    
    Specified by:
    
    readSortAsync in interface RSortableAsync<Set<V>>
    
    Type Parameters:
    
    T - object type
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection
  - readSortAlpha
```
public Set<V> readSortAlpha(SortOrder order)
```
    Description copied from interface: RSortable
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlpha in interface RSortable<Set<V>>
    
    Parameters:
    
    order - for sorted data
    
    Returns:
    
    sorted collection lexicographically
  - readSortAlpha
```
public Set<V> readSortAlpha(SortOrder order,
                            int offset,
                            int count)
```
    Description copied from interface: RSortable
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlpha in interface RSortable<Set<V>>
    
    Parameters:
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection lexicographically
  - readSortAlpha
```
public Set<V> readSortAlpha(String byPattern,
                            SortOrder order)
```
    Description copied from interface: RSortable
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlpha in interface RSortable<Set<V>>
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    Returns:
    
    sorted collection lexicographically
  - readSortAlpha
```
public Set<V> readSortAlpha(String byPattern,
                            SortOrder order,
                            int offset,
                            int count)
```
    Description copied from interface: RSortable
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlpha in interface RSortable<Set<V>>
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection lexicographically
  - readSortAlpha
```
public <T> Collection<T> readSortAlpha(String byPattern,
                                       List<String> getPatterns,
                                       SortOrder order)
```
    Description copied from interface: RSortable
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlpha in interface RSortable<Set<V>>
    
    Type Parameters:
    
    T - object type
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    Returns:
    
    sorted collection lexicographically
  - readSortAlpha
```
public <T> Collection<T> readSortAlpha(String byPattern,
                                       List<String> getPatterns,
                                       SortOrder order,
                                       int offset,
                                       int count)
```
    Description copied from interface: RSortable
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlpha in interface RSortable<Set<V>>
    
    Type Parameters:
    
    T - object type
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection lexicographically
  - readSortAlphaAsync
```
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlphaAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    order - for sorted data
    
    Returns:
    
    sorted collection lexicographically
  - readSortAlphaAsync
```
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order,
                                          int offset,
                                          int count)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlphaAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection lexicographically
  - readSortAlphaAsync
```
public RFuture<Set<V>> readSortAlphaAsync(String byPattern,
                                          SortOrder order)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlphaAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    Returns:
    
    sorted collection lexicographically
  - readSortAlphaAsync
```
public RFuture<Set<V>> readSortAlphaAsync(String byPattern,
                                          SortOrder order,
                                          int offset,
                                          int count)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlphaAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection lexicographically
  - readSortAlphaAsync
```
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern,
                                                     List<String> getPatterns,
                                                     SortOrder order)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlphaAsync in interface RSortableAsync<Set<V>>
    
    Type Parameters:
    
    T - object type
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    Returns:
    
    sorted collection lexicographically
  - readSortAlphaAsync
```
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern,
                                                     List<String> getPatterns,
                                                     SortOrder order,
                                                     int offset,
                                                     int count)
```
    Description copied from interface: RSortableAsync
    
    Read data in sorted view lexicographically
    
    Specified by:
    
    readSortAlphaAsync in interface RSortableAsync<Set<V>>
    
    Type Parameters:
    
    T - object type
    
    Parameters:
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    sorted collection lexicographically
  - sortTo
```
public int sortTo(String destName,
                  SortOrder order)
```
    Description copied from interface: RSortable
    
    Sort data and store to destName list
    
    Specified by:
    
    sortTo in interface RSortable<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    order - for sorted data
    
    Returns:
    
    length of sorted data
  - sortToAsync
```
public RFuture<Integer> sortToAsync(String destName,
                                    SortOrder order)
```
    Description copied from interface: RSortableAsync
    
    Sort data and store to destName list
    
    Specified by:
    
    sortToAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    order - for sorted data
    
    Returns:
    
    length of sorted data
  - sortTo
```
public int sortTo(String destName,
                  SortOrder order,
                  int offset,
                  int count)
```
    Description copied from interface: RSortable
    
    Sort data and store to destName list
    
    Specified by:
    
    sortTo in interface RSortable<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    length of sorted data
  - sortToAsync
```
public RFuture<Integer> sortToAsync(String destName,
                                    SortOrder order,
                                    int offset,
                                    int count)
```
    Description copied from interface: RSortableAsync
    
    Sort data and store to destName list
    
    Specified by:
    
    sortToAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    length of sorted data
  - sortTo
```
public int sortTo(String destName,
                  String byPattern,
                  SortOrder order,
                  int offset,
                  int count)
```
    Description copied from interface: RSortable
    
    Sort data and store to destName list
    
    Specified by:
    
    sortTo in interface RSortable<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    length of sorted data
  - sortTo
```
public int sortTo(String destName,
                  String byPattern,
                  SortOrder order)
```
    Description copied from interface: RSortable
    
    Sort data and store to destName list
    
    Specified by:
    
    sortTo in interface RSortable<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    Returns:
    
    length of sorted data
  - sortToAsync
```
public RFuture<Integer> sortToAsync(String destName,
                                    String byPattern,
                                    SortOrder order)
```
    Description copied from interface: RSortableAsync
    
    Sort data and store to destName list
    
    Specified by:
    
    sortToAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    Returns:
    
    length of sorted data
  - sortToAsync
```
public RFuture<Integer> sortToAsync(String destName,
                                    String byPattern,
                                    SortOrder order,
                                    int offset,
                                    int count)
```
    Description copied from interface: RSortableAsync
    
    Sort data and store to destName list
    
    Specified by:
    
    sortToAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    byPattern - that is used to generate the keys that are used for sorting
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    length of sorted data
  - sortTo
```
public int sortTo(String destName,
                  String byPattern,
                  List<String> getPatterns,
                  SortOrder order)
```
    Description copied from interface: RSortable
    
    Sort data and store to destName list
    
    Specified by:
    
    sortTo in interface RSortable<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    Returns:
    
    length of sorted data
  - sortToAsync
```
public RFuture<Integer> sortToAsync(String destName,
                                    String byPattern,
                                    List<String> getPatterns,
                                    SortOrder order)
```
    Description copied from interface: RSortableAsync
    
    Sort data and store to destName list
    
    Specified by:
    
    sortToAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    Returns:
    
    length of sorted data
  - sortTo
```
public int sortTo(String destName,
                  String byPattern,
                  List<String> getPatterns,
                  SortOrder order,
                  int offset,
                  int count)
```
    Description copied from interface: RSortable
    
    Sort data and store to destName list
    
    Specified by:
    
    sortTo in interface RSortable<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    length of sorted data
  - sortToAsync
```
public RFuture<Integer> sortToAsync(String destName,
                                    String byPattern,
                                    List<String> getPatterns,
                                    SortOrder order,
                                    int offset,
                                    int count)
```
    Description copied from interface: RSortableAsync
    
    Sort data and store to destName list
    
    Specified by:
    
    sortToAsync in interface RSortableAsync<Set<V>>
    
    Parameters:
    
    destName - list object destination
    
    byPattern - that is used to generate the keys that are used for sorting
    
    getPatterns - that is used to load values by keys in sorted view
    
    order - for sorted data
    
    offset - of sorted data
    
    count - of sorted data
    
    Returns:
    
    length of sorted data
  - readDiff
```
public Collection<V> readDiff(String... names)
```
    Description copied from interface: RScoredSortedSet
    
    Diff ScoredSortedSets specified by name with current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readDiff in interface RScoredSortedSet<V>
    
    Parameters:
    
    names - - name of sets
    
    Returns:
    
    result of diff
  - readDiffAsync
```
public RFuture<Collection<V>> readDiffAsync(String... names)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Diff ScoredSortedSets specified by name with current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    readDiffAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    names - - name of sets
    
    Returns:
    
    result of diff
  - diff
```
public int diff(String... names)
```
    Description copied from interface: RScoredSortedSet
    
    Diff provided ScoredSortedSets and store result to current ScoredSortedSet
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    diff in interface RScoredSortedSet<V>
    
    Parameters:
    
    names - - name of sets
    
    Returns:
    
    length of diff
  - diffAsync
```
public RFuture<Integer> diffAsync(String... names)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Diff provided ScoredSortedSets and store result to current ScoredSortedSet
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    diffAsync in interface RScoredSortedSetAsync<V>
    
    Parameters:
    
    names - - name of sets
    
    Returns:
    
    length of diff
  - rangeTo
```
public int rangeTo(String destName,
                   int startIndex,
                   int endIndex)
```
    Description copied from interface: RScoredSortedSet
    
    Stores to defined ScoredSortedSet values by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    rangeTo in interface RScoredSortedSet<V>
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - rangeTo
```
public int rangeTo(String destName,
                   double startScore,
                   boolean startScoreInclusive,
                   double endScore,
                   boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSet
    
    Stores to defined ScoredSortedSet values between startScore and endScore.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    rangeTo in interface RScoredSortedSet<V>
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    values
  - rangeTo
```
public int rangeTo(String destName,
                   double startScore,
                   boolean startScoreInclusive,
                   double endScore,
                   boolean endScoreInclusive,
                   int offset,
                   int count)
```
    Description copied from interface: RScoredSortedSet
    
    Stores to defined ScoredSortedSet values between startScore and endScore.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    rangeTo in interface RScoredSortedSet<V>
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    values
  - revRangeTo
```
public int revRangeTo(String destName,
                      int startIndex,
                      int endIndex)
```
    Description copied from interface: RScoredSortedSet
    
    Stores to defined ScoredSortedSet values in reversed order by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    revRangeTo in interface RScoredSortedSet<V>
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - revRangeTo
```
public int revRangeTo(String destName,
                      double startScore,
                      boolean startScoreInclusive,
                      double endScore,
                      boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSet
    
    Stores to defined ScoredSortedSet values in reversed order between startScore and endScore.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    revRangeTo in interface RScoredSortedSet<V>
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    values
  - revRangeTo
```
public int revRangeTo(String destName,
                      double startScore,
                      boolean startScoreInclusive,
                      double endScore,
                      boolean endScoreInclusive,
                      int offset,
                      int count)
```
    Description copied from interface: RScoredSortedSet
    
    Stores to defined ScoredSortedSet values in reversed order between startScore and endScore.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    revRangeTo in interface RScoredSortedSet<V>
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    values
  - revRangeToAsync
```
public RFuture<Integer> revRangeToAsync(String destName,
                                        int startIndex,
                                        int endIndex)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Stores to defined ScoredSortedSet values in reversed order by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Specified by:
    
    revRangeToAsync in interface RScoredSortedSetAsync<V>
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - revRangeToAsync
```
public RFuture<Integer> revRangeToAsync(String destName,
                                        double startScore,
                                        boolean startScoreInclusive,
                                        double endScore,
                                        boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Stores to defined ScoredSortedSet values in reversed order between startScore and endScore.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    revRangeToAsync in interface RScoredSortedSetAsync<V>
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    values
  - revRangeToAsync
```
public RFuture<Integer> revRangeToAsync(String destName,
                                        double startScore,
                                        boolean startScoreInclusive,
                                        double endScore,
                                        boolean endScoreInclusive,
                                        int offset,
                                        int count)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Stores to defined ScoredSortedSet values in reversed order between startScore and endScore.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    revRangeToAsync in interface RScoredSortedSetAsync<V>
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    values
  - rangeToAsync
```
public RFuture<Integer> rangeToAsync(String destName,
                                     int startIndex,
                                     int endIndex)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Stores to defined ScoredSortedSet values by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Specified by:
    
    rangeToAsync in interface RScoredSortedSetAsync<V>
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - rangeToAsync
```
public RFuture<Integer> rangeToAsync(String destName,
                                     double startScore,
                                     boolean startScoreInclusive,
                                     double endScore,
                                     boolean endScoreInclusive)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Stores to defined ScoredSortedSet values between startScore and endScore.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    rangeToAsync in interface RScoredSortedSetAsync<V>
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    values
  - rangeToAsync
```
public RFuture<Integer> rangeToAsync(String destName,
                                     double startScore,
                                     boolean startScoreInclusive,
                                     double endScore,
                                     boolean endScoreInclusive,
                                     int offset,
                                     int count)
```
    Description copied from interface: RScoredSortedSetAsync
    
    Stores to defined ScoredSortedSet values between startScore and endScore.
    Requires Redis 6.2.0 and higher.
    
    Specified by:
    
    rangeToAsync in interface RScoredSortedSetAsync<V>
    
    startScore - - start score. Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score Use Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY to define infinity numbers
    
    endScoreInclusive - - end score inclusive
    
    offset - - offset of sorted data
    
    count - - amount of sorted data
    
    Returns:
    
    values
  - takeFirstAsync
```
public RFuture<V> takeFirstAsync()
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes and returns the head element waiting if necessary for an element to become available.
    
    Specified by:
    
    takeFirstAsync in interface RScoredSortedSetAsync<V>
    
    Returns:
    
    the head element
  - takeLastAsync
```
public RFuture<V> takeLastAsync()
```
    Description copied from interface: RScoredSortedSetAsync
    
    Removes and returns the tail element waiting if necessary for an element to become available.
    
    Specified by:
    
    takeLastAsync in interface RScoredSortedSetAsync<V>
    
    Returns:
    
    the tail element
  - takeFirst
```
public V takeFirst()
```
    Description copied from interface: RScoredSortedSet
    
    Removes and returns the head element waiting if necessary for an element to become available.
    
    Specified by:
    
    takeFirst in interface RScoredSortedSet<V>
    
    Returns:
    
    the head element
  - takeLast
```
public V takeLast()
```
    Description copied from interface: RScoredSortedSet
    
    Removes and returns the tail element waiting if necessary for an element to become available.
    
    Specified by:
    
    takeLast in interface RScoredSortedSet<V>
    
    Returns:
    
    the tail element
  - subscribeOnFirstElements
```
public int subscribeOnFirstElements(Consumer<V> consumer)
```
    Description copied from interface: RScoredSortedSet
    
    Subscribes on first elements appeared in this set. Continuously invokes RScoredSortedSetAsync.takeFirstAsync() method to get a new element.
    
    Specified by:
    
    subscribeOnFirstElements in interface RScoredSortedSet<V>
    
    Parameters:
    
    consumer - - queue elements listener
    
    Returns:
    
    listenerId - id of listener
  - subscribeOnLastElements
```
public int subscribeOnLastElements(Consumer<V> consumer)
```
    Description copied from interface: RScoredSortedSet
    
    Subscribes on last elements appeared in this set. Continuously invokes RScoredSortedSetAsync.takeLastAsync() method to get a new element.
    
    Specified by:
    
    subscribeOnLastElements in interface RScoredSortedSet<V>
    
    Parameters:
    
    consumer - - queue elements listener
    
    Returns:
    
    listenerId - id of listener
  - unsubscribe
```
public void unsubscribe(int listenerId)
```
    Description copied from interface: RScoredSortedSet
    
    Un-subscribes defined listener.
    
    Specified by:
    
    unsubscribe in interface RScoredSortedSet<V>
    
    Parameters:
    
    listenerId - - id of listener
  - stream
```
public Stream<V> stream()
```
    Description copied from interface: RScoredSortedSet
    
    Returns stream of elements in this set. Elements are loaded in batch. Batch size is 10.
    
    Specified by:
    
    stream in interface RScoredSortedSet<V>
    
    Returns:
    
    stream of elements
  - stream
```
public Stream<V> stream(String pattern)
```
    Description copied from interface: RScoredSortedSet
    
    Returns stream of elements in this set. If pattern is not null then only elements match this pattern are loaded.
    
    Specified by:
    
    stream in interface RScoredSortedSet<V>
    
    Parameters:
    
    pattern - - search pattern
    
    Returns:
    
    stream of elements
  - stream
```
public Stream<V> stream(int count)
```
    Description copied from interface: RScoredSortedSet
    
    Returns stream of elements in this set. Elements are loaded in batch. Batch size is defined by count param.
    
    Specified by:
    
    stream in interface RScoredSortedSet<V>
    
    Parameters:
    
    count - - size of elements batch
    
    Returns:
    
    stream of elements
  - stream
```
public Stream<V> stream(String pattern,
                        int count)
```
    Description copied from interface: RScoredSortedSet
    
    Returns stream of elements in this set. Elements are loaded in batch. Batch size is defined by count param. If pattern is not null then only elements match this pattern are loaded.
    
    Specified by:
    
    stream in interface RScoredSortedSet<V>
    
    Parameters:
    
    pattern - - search pattern
    
    count - - size of elements batch
    
    Returns:
    
    stream of elements
  - addListener
```
public int addListener(ObjectListener listener)
```
    Description copied from interface: RObject
    
    Adds object event listener
    
    Specified by:
    
    addListener in interface RObject
    
    Overrides:
    
    addListener in class RedissonObject
    
    Parameters:
    
    listener - - object event listener
    
    Returns:
    
    listener id
    
    See Also:
    
    ExpiredObjectListener, DeletedObjectListener
  - addListenerAsync
```
public RFuture<Integer> addListenerAsync(ObjectListener listener)
```
    Description copied from interface: RObjectAsync
    
    Adds object event listener
    
    Specified by:
    
    addListenerAsync in interface RObjectAsync
    
    Overrides:
    
    addListenerAsync in class RedissonObject
    
    Parameters:
    
    listener - - object event listener
    
    Returns:
    
    listener id
    
    See Also:
    
    ExpiredObjectListener, DeletedObjectListener
  - removeListener
```
public void removeListener(int listenerId)
```
    Description copied from interface: RObject
    
    Removes object event listener
    
    Specified by:
    
    removeListener in interface RObject
    
    Overrides:
    
    removeListener in class RedissonObject
    
    Parameters:
    
    listenerId - - listener id
  - removeListenerAsync
```
public RFuture<Void> removeListenerAsync(int listenerId)
```
    Description copied from interface: RObjectAsync
    
    Removes object event listener
    
    Specified by:
    
    removeListenerAsync in interface RObjectAsync
    
    Overrides:
    
    removeListenerAsync in class RedissonObject
    
    Parameters:
    
    listenerId - - listener id
  - expire
```
public boolean expire(long timeToLive,
                      TimeUnit timeUnit)
```
    Description copied from interface: RExpirable
    
    Set a timeout for object. After the timeout has expired, the key will automatically be deleted.
    
    Specified by:
    
    expire in interface RExpirable
    
    Parameters:
    
    timeToLive - - timeout before object will be deleted
    
    timeUnit - - timeout time unit
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAsync
```
public RFuture<Boolean> expireAsync(long timeToLive,
                                    TimeUnit timeUnit)
```
    Description copied from interface: RExpirableAsync
    
    Set a timeout for object in async mode. After the timeout has expired, the key will automatically be deleted.
    
    Specified by:
    
    expireAsync in interface RExpirableAsync
    
    Parameters:
    
    timeToLive - - timeout before object will be deleted
    
    timeUnit - - timeout time unit
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAt
```
public boolean expireAt(long timestamp)
```
    Description copied from interface: RExpirable
    
    Use RExpirable.expire(Instant) instead
    
    Specified by:
    
    expireAt in interface RExpirable
    
    Parameters:
    
    timestamp - - expire date in milliseconds (Unix timestamp)
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAtAsync
```
public RFuture<Boolean> expireAtAsync(long timestamp)
```
    Description copied from interface: RExpirableAsync
    
    Use RExpirableAsync.expireAsync(Instant) instead
    
    Specified by:
    
    expireAtAsync in interface RExpirableAsync
    
    Parameters:
    
    timestamp - - expire date in milliseconds (Unix timestamp)
    
    Returns:
    
    true if the timeout was set and false if not
  - expire
```
public boolean expire(Instant instant)
```
    Description copied from interface: RExpirable
    
    Set an expire date for object. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expire in interface RExpirable
    
    Parameters:
    
    instant - - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAsync
```
public RFuture<Boolean> expireAsync(Instant instant)
```
    Description copied from interface: RExpirableAsync
    
    Set an expire date for object. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAsync in interface RExpirableAsync
    
    Parameters:
    
    instant - - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAt
```
public boolean expireAt(Date timestamp)
```
    Description copied from interface: RExpirable
    
    Use RExpirable.expire(Instant) instead
    
    Specified by:
    
    expireAt in interface RExpirable
    
    Parameters:
    
    timestamp - - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAtAsync
```
public RFuture<Boolean> expireAtAsync(Date timestamp)
```
    Description copied from interface: RExpirableAsync
    
    Use RExpirableAsync.expireAsync(Instant) instead
    
    Specified by:
    
    expireAtAsync in interface RExpirableAsync
    
    Parameters:
    
    timestamp - - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - clearExpire
```
public boolean clearExpire()
```
    Description copied from interface: RExpirable
    
    Clear an expire timeout or expire date for object.
    
    Specified by:
    
    clearExpire in interface RExpirable
    
    Returns:
    
    true if timeout was removed false if object does not exist or does not have an associated timeout
  - clearExpireAsync
```
public RFuture<Boolean> clearExpireAsync()
```
    Description copied from interface: RExpirableAsync
    
    Clear an expire timeout or expire date for object in async mode. Object will not be deleted.
    
    Specified by:
    
    clearExpireAsync in interface RExpirableAsync
    
    Returns:
    
    true if the timeout was cleared and false if not
  - remainTimeToLive
```
public long remainTimeToLive()
```
    Description copied from interface: RExpirable
    
    Remaining time to live of Redisson object that has a timeout
    
    Specified by:
    
    remainTimeToLive in interface RExpirable
    
    Returns:
    
    time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expire.
  - remainTimeToLiveAsync
```
public RFuture<Long> remainTimeToLiveAsync()
```
    Description copied from interface: RExpirableAsync
    
    Remaining time to live of Redisson object that has a timeout
    
    Specified by:
    
    remainTimeToLiveAsync in interface RExpirableAsync
    
    Returns:
    
    time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expire.
  - expireAsync
```
protected RFuture<Boolean> expireAsync(long timeToLive,
                                       TimeUnit timeUnit,
                                       String... keys)
```
  - expireAtAsync
```
protected RFuture<Boolean> expireAtAsync(long timestamp,
                                         String... keys)
```
  - clearExpireAsync
```
protected RFuture<Boolean> clearExpireAsync(String... keys)
```

Class RedissonScoredSortedSet<V>

Nested Class Summary

Nested classes/interfaces inherited from interface org.redisson.api.RScoredSortedSet

Field Summary

Fields inherited from class org.redisson.RedissonObject

Constructor Summary

Method Summary

Methods inherited from class org.redisson.RedissonObject

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Methods inherited from interface org.redisson.api.RExpirable

Methods inherited from interface org.redisson.api.RObject

Methods inherited from interface org.redisson.api.RExpirableAsync

Methods inherited from interface org.redisson.api.RObjectAsync

Constructor Detail

RedissonScoredSortedSet

RedissonScoredSortedSet

Method Detail

mapReduce

readAll

readAllAsync

pollFirst

pollLast

pollFirst

pollLast

pollFirstAsync

pollLastAsync

pollFirstAsync

pollLastAsync

pollFirst

pollFirstAsync

pollFirstFromAny

pollFirstFromAnyAsync

pollLastFromAny

pollLastFromAnyAsync

pollLast

pollLastAsync

random

random

randomAsync

randomAsync

randomEntries

randomEntriesAsync

add

addAndGetRank

addAndGetRankAsync

addAndGetRevRank

addAndGetRevRank

addAndGetRevRankAsync

addAndGetRevRankAsync

tryAdd

addIfExists

addIfExistsAsync

addIfLess

addIfGreater

addIfLessAsync

addIfGreaterAsync

first

firstAsync

last

lastAsync

firstScore

firstScoreAsync

lastScore

lastScoreAsync

addAsync

addAll

addAllAsync

tryAddAsync

remove

removeRangeByRank

removeRangeByRankAsync

removeRangeByScore

removeRangeByScoreAsync

clear

removeAsync

isEmpty

size

sizeAsync

contains