Type Parameters:

V - value

All Superinterfaces:

RExpirableAsync, RObjectAsync, RSortableAsync<Set<V>>

All Known Subinterfaces:

RGeo<V>, RGeoAsync<V>, RScoredSortedSet<V>

All Known Implementing Classes:

RedissonGeo, RedissonLexSortedSet, RedissonScoredSortedSet
```
public interface RScoredSortedSetAsync<V>
extends RExpirableAsync, RSortableAsync<Set<V>>
```
Author:

Nikita Koksharov

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`RFuture<Integer>`	`addAllAsync(Map<V,Double> objects)`	Adds all elements contained in the specified map to this sorted set.
`RFuture<Integer>`	`addAndGetRankAsync(double score, V object)`	Adds element 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.
`RFuture<Boolean>`	`addIfExistsAsync(double score, V object)`	Adds element to this set only if it's already exists.
`RFuture<Boolean>`	`addIfGreaterAsync(double score, V object)`	Adds element to this set only if new score greater 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.
`RFuture<Integer>`	`addScoreAndGetRankAsync(V object, Number value)`	Adds score to element and returns its rank
`RFuture<Integer>`	`addScoreAndGetRevRankAsync(V object, Number value)`	Adds score to element and returns its reverse rank
`RFuture<Double>`	`addScoreAsync(V element, Number value)`	Increases score of specified element by value.
`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.
`RFuture<Integer>`	`countAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)`	Returns the number of elements with a score between `startScore` and `endScore`.
`RFuture<Integer>`	`diffAsync(String... names)`	Diff provided ScoredSortedSets and store result to current ScoredSortedSet
`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.
`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.
`RFuture<V>`	`firstAsync()`	Returns the head element or `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.
`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.
`RFuture<Integer>`	`intersectionAsync(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, String... names)`	Intersect provided ScoredSortedSets with defined aggregation method 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<V>`	`lastAsync()`	Returns the tail element or `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.
`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.
`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.
`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.
`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.
`RFuture<V>`	`randomAsync()`	Returns random element from this sorted set
`RFuture<Collection<V>>`	`randomAsync(int count)`	Returns random elements from this sorted set limited by `count`
`RFuture<Map<V,Double>>`	`randomEntriesAsync(int count)`	Returns random entries from this sorted set limited by `count`.
`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.
`RFuture<Integer>`	`rankAsync(V o)`	Returns rank of value, with the scores ordered from low to high.
`RFuture<Collection<V>>`	`readAllAsync()`	Read all values at once.
`RFuture<Collection<V>>`	`readDiffAsync(String... names)`	Diff ScoredSortedSets specified by name with current ScoredSortedSet without state change.
`RFuture<Collection<V>>`	`readIntersectionAsync(String... names)`	Intersect provided ScoredSortedSets with current ScoredSortedSet without state change
`RFuture<Collection<V>>`	`readIntersectionAsync(Map<String,Double> nameWithWeight)`	Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet without state change
`RFuture<Collection<V>>`	`readIntersectionAsync(RScoredSortedSet.Aggregate aggregate, String... names)`	Intersect provided ScoredSortedSets with current ScoredSortedSet using defined aggregation method without state change
`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
`RFuture<Collection<V>>`	`readUnionAsync(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, String... names)`	Union ScoredSortedSets specified by name with defined aggregation method 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
`RFuture<Boolean>`	`removeAllAsync(Collection<?> c)`	Removes all of this sorted set's elements that are also contained in the specified collection.
`RFuture<Boolean>`	`removeAsync(V o)`	Removes a single instance of the specified element from this sorted set, if it is present.
`RFuture<Integer>`	`removeRangeByRankAsync(int startIndex, int endIndex)`	Removes values by rank range.
`RFuture<Integer>`	`removeRangeByScoreAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)`	Removes values by score range.
`RFuture<Boolean>`	`retainAllAsync(Collection<?> c)`	Retains only the elements in this sorted set that are contained in the specified collection.
`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.
`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<Integer>`	`sizeAsync()`	Returns size of this set.
`RFuture<V>`	`takeFirstAsync()`	Removes and returns the head 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.
`RFuture<Boolean>`	`tryAddAsync(double score, V object)`	Adds element to this set only if has not been added before.
`RFuture<Integer>`	`unionAsync(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, String... names)`	Union provided ScoredSortedSets with defined aggregation method 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<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.
`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 interface org.redisson.api.RExpirableAsync
clearExpireAsync, expireAsync, expireAsync, expireAtAsync, expireAtAsync, remainTimeToLiveAsync

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

Methods inherited from interface org.redisson.api.RSortableAsync
readSortAlphaAsync, readSortAlphaAsync, readSortAlphaAsync, readSortAlphaAsync, readSortAlphaAsync, readSortAlphaAsync, readSortAsync, readSortAsync, readSortAsync, readSortAsync, readSortAsync, readSortAsync, sortToAsync, sortToAsync, sortToAsync, sortToAsync, sortToAsync, sortToAsync

- Method Detail
  - pollLastFromAnyAsync
```
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.
    Requires Redis 5.0.0 and higher.
    
    Parameters:
    
    queueNames - - names of queue
    
    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 all sorted sets are empty
  - pollFirstFromAnyAsync
```
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.
    Requires Redis 5.0.0 and higher.
    
    Parameters:
    
    queueNames - - names of queue
    
    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 all sorted sets are empty
  - pollFirstAsync
```
RFuture<V> pollFirstAsync(long timeout,
                          TimeUnit unit)
```
    Removes and returns the head element or null if this sorted set is empty.
    Requires Redis 5.0.0 and higher.
    
    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
  - takeFirstAsync
```
RFuture<V> takeFirstAsync()
```
    Removes and returns the head element waiting if necessary for an element to become available.
    
    Returns:
    
    the head element
  - takeLastAsync
```
RFuture<V> takeLastAsync()
```
    Removes and returns the tail element waiting if necessary for an element to become available.
    
    Returns:
    
    the tail element
  - pollLastAsync
```
RFuture<V> pollLastAsync(long timeout,
                         TimeUnit unit)
```
    Removes and returns the tail element or null if this sorted set is empty.
    Requires Redis 5.0.0 and higher.
    
    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
  - pollFirstAsync
```
RFuture<Collection<V>> pollFirstAsync(int count)
```
    Removes and returns the head elements of this sorted set.
    
    Parameters:
    
    count - - elements amount
    
    Returns:
    
    the head elements of this sorted set
  - pollLastAsync
```
RFuture<Collection<V>> pollLastAsync(int count)
```
    Removes and returns the tail elements of this sorted set.
    
    Parameters:
    
    count - - elements amount
    
    Returns:
    
    the tail elements of this sorted set
  - pollFirstAsync
```
RFuture<V> pollFirstAsync()
```
    Removes and returns the head element or null if this sorted set is empty.
    
    Returns:
    
    the head element, or null if this sorted set is empty
  - pollLastAsync
```
RFuture<V> pollLastAsync()
```
    Removes and returns the tail element or null if this sorted set is empty.
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - firstAsync
```
RFuture<V> firstAsync()
```
    Returns the head element or null if this sorted set is empty.
    
    Returns:
    
    the head element or null if this sorted set is empty
  - lastAsync
```
RFuture<V> lastAsync()
```
    Returns the tail element or null if this sorted set is empty.
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - firstScoreAsync
```
RFuture<Double> firstScoreAsync()
```
    Returns score of the head element or returns null if this sorted set is empty.
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - lastScoreAsync
```
RFuture<Double> lastScoreAsync()
```
    Returns score of the tail element or returns null if this sorted set is empty.
    
    Returns:
    
    the tail element or null if this sorted set is empty
  - randomAsync
```
RFuture<V> randomAsync()
```
    Returns random element from this sorted set
    Requires Redis 6.2.0 and higher.
    
    Returns:
    
    value
  - randomAsync
```
RFuture<Collection<V>> randomAsync(int count)
```
    Returns random elements from this sorted set limited by count
    Requires Redis 6.2.0 and higher.
    
    Parameters:
    
    count - - values amount to return
    
    Returns:
    
    value
  - randomEntriesAsync
```
RFuture<Map<V,Double>> randomEntriesAsync(int count)
```
    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.
    
    Parameters:
    
    count - - entries amount to return
    
    Returns:
    
    random entries
  - addAllAsync
```
RFuture<Integer> addAllAsync(Map<V,Double> objects)
```
    Adds all elements contained in the specified map to this sorted set. Map contains of score mapped by object.
    
    Parameters:
    
    objects - - map of elements to add
    
    Returns:
    
    amount of added elements, not including already existing in this sorted set
  - removeRangeByScoreAsync
```
RFuture<Integer> removeRangeByScoreAsync(double startScore,
                                         boolean startScoreInclusive,
                                         double endScore,
                                         boolean endScoreInclusive)
```
    Removes values by score range.
    
    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
  - removeRangeByRankAsync
```
RFuture<Integer> removeRangeByRankAsync(int startIndex,
                                        int endIndex)
```
    Removes values by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    number of elements removed
  - rankAsync
```
RFuture<Integer> rankAsync(V o)
```
    Returns rank of value, with the scores ordered from low to high.
    
    Parameters:
    
    o - - object
    
    Returns:
    
    rank or null if value does not exist
  - revRankAsync
```
RFuture<Integer> revRankAsync(V o)
```
    Returns rank of value, with the scores ordered from high to low.
    
    Parameters:
    
    o - - object
    
    Returns:
    
    rank or null if value does not exist
  - revRankAsync
```
RFuture<List<Integer>> revRankAsync(Collection<V> elements)
```
    Returns ranks of elements, with the scores ordered from high to low.
    
    Parameters:
    
    elements - - elements
    
    Returns:
    
    ranks or null if value does not exist
  - getScoreAsync
```
RFuture<Double> getScoreAsync(V o)
```
    Returns score of element or null if it doesn't exist.
    
    Parameters:
    
    o - - element
    
    Returns:
    
    score
  - getScoreAsync
```
RFuture<List<Double>> getScoreAsync(Collection<V> elements)
```
    Returns scores of elements.
    
    Parameters:
    
    elements - - elements
    
    Returns:
    
    element scores
  - addAsync
```
RFuture<Boolean> addAsync(double score,
                          V object)
```
    Adds element to this set, overrides previous score if it has been already added.
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element has added and false if not.
  - addAndGetRankAsync
```
RFuture<Integer> addAndGetRankAsync(double score,
                                    V object)
```
    Adds element to this set, overrides previous score if it has been already added. Finally return the rank of the item
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    rank
  - addAndGetRevRankAsync
```
RFuture<Integer> addAndGetRevRankAsync(double score,
                                       V object)
```
    Adds element to this set, overrides previous score if it has been already added. Finally return the reverse rank of the item
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    reverse rank
  - addAndGetRevRankAsync
```
RFuture<List<Integer>> addAndGetRevRankAsync(Map<? extends V,Double> map)
```
    Adds elements to this set, overrides previous score if it has been already added. Finally returns reverse rank list of the items
    
    Parameters:
    
    map - - map of object and scores, make sure to use an ordered map
    
    Returns:
    
    collection of reverse ranks
  - tryAddAsync
```
RFuture<Boolean> tryAddAsync(double score,
                             V object)
```
    Adds element to this set only if has not been added before.
    Requires Redis 3.0.2 and higher.
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element has added and false if not.
  - addIfExistsAsync
```
RFuture<Boolean> addIfExistsAsync(double score,
                                  V object)
```
    Adds element to this set only if it's already exists.
    Requires Redis 3.0.2 and higher.
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element added and false if not.
  - addIfLessAsync
```
RFuture<Boolean> addIfLessAsync(double score,
                                V object)
```
    Adds element to this set only if new score less than current score of existed element.
    Requires Redis 6.2.0 and higher.
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element added and false if not.
  - addIfGreaterAsync
```
RFuture<Boolean> addIfGreaterAsync(double score,
                                   V object)
```
    Adds element to this set only if new score greater than current score of existed element.
    Requires Redis 6.2.0 and higher.
    
    Parameters:
    
    score - - object score
    
    object - - object itself
    
    Returns:
    
    true if element added and false if not.
  - removeAsync
```
RFuture<Boolean> removeAsync(V o)
```
    Removes a single instance of the specified element from this sorted set, if it is present.
    
    Parameters:
    
    o - element to be removed from this sorted set, if present
    
    Returns:
    
    true if an element was removed as a result of this call
  - sizeAsync
```
RFuture<Integer> sizeAsync()
```
    Returns size of this set.
    
    Returns:
    
    size
  - containsAsync
```
RFuture<Boolean> containsAsync(Object o)
```
    Returns true if this sorted set contains encoded state of the specified element.
    
    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
  - containsAllAsync
```
RFuture<Boolean> containsAllAsync(Collection<?> c)
```
    Returns true if this sorted set contains all of the elements in encoded state in the specified collection.
    
    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
```
RFuture<Boolean> removeAllAsync(Collection<?> c)
```
    Removes all of this sorted set's elements that are also contained in the specified collection.
    
    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
  - retainAllAsync
```
RFuture<Boolean> retainAllAsync(Collection<?> c)
```
    Retains only the elements in this sorted set that are contained in the specified collection.
    
    Parameters:
    
    c - collection containing elements to be retained in this collection
    
    Returns:
    
    true if this sorted set changed as a result of the call
  - addScoreAsync
```
RFuture<Double> addScoreAsync(V element,
                              Number value)
```
    Increases score of specified element by value.
    
    Parameters:
    
    element - - element whose score needs to be increased
    
    value - - value
    
    Returns:
    
    updated score of element
  - addScoreAndGetRevRankAsync
```
RFuture<Integer> addScoreAndGetRevRankAsync(V object,
                                            Number value)
```
    Adds score to element and returns its reverse rank
    
    Parameters:
    
    object - - object itself
    
    value - - object score
    
    Returns:
    
    reverse rank
  - addScoreAndGetRankAsync
```
RFuture<Integer> addScoreAndGetRankAsync(V object,
                                         Number value)
```
    Adds score to element and returns its rank
    
    Parameters:
    
    object - - object itself
    
    value - - object score
    
    Returns:
    
    rank
  - rangeToAsync
```
RFuture<Integer> rangeToAsync(String destName,
                              int startIndex,
                              int endIndex)
```
    Stores to defined ScoredSortedSet values by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - rangeToAsync
```
RFuture<Integer> rangeToAsync(String destName,
                              double startScore,
                              boolean startScoreInclusive,
                              double endScore,
                              boolean endScoreInclusive)
```
    Stores to defined ScoredSortedSet values between startScore and endScore.
    Requires Redis 6.2.0 and higher.
    
    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
  - rangeToAsync
```
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.
    Requires Redis 6.2.0 and higher.
    
    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
  - revRangeToAsync
```
RFuture<Integer> revRangeToAsync(String destName,
                                 int startIndex,
                                 int endIndex)
```
    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.
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - revRangeToAsync
```
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.
    Requires Redis 6.2.0 and higher.
    
    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
  - revRangeToAsync
```
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.
    Requires Redis 6.2.0 and higher.
    
    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
```
RFuture<Collection<V>> valueRangeAsync(int startIndex,
                                       int endIndex)
```
    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.
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - valueRangeReversedAsync
```
RFuture<Collection<V>> valueRangeReversedAsync(int startIndex,
                                               int endIndex)
```
    Returns values by rank range in reverse order. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    elements
  - entryRangeAsync
```
RFuture<Collection<ScoredEntry<V>>> entryRangeAsync(int startIndex,
                                                    int endIndex)
```
    Returns entries (value and its score) by rank range. Indexes are zero based. -1 means the highest score, -2 means the second highest score.
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    entries
  - entryRangeReversedAsync
```
RFuture<Collection<ScoredEntry<V>>> entryRangeReversedAsync(int startIndex,
                                                            int endIndex)
```
    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.
    
    Parameters:
    
    startIndex - - start index
    
    endIndex - - end index
    
    Returns:
    
    entries
  - valueRangeAsync
```
RFuture<Collection<V>> valueRangeAsync(double startScore,
                                       boolean startScoreInclusive,
                                       double endScore,
                                       boolean endScoreInclusive)
```
    Returns all values between startScore and endScore.
    
    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
```
RFuture<Collection<V>> valueRangeReversedAsync(double startScore,
                                               boolean startScoreInclusive,
                                               double endScore,
                                               boolean endScoreInclusive)
```
    Returns all values between startScore and endScore in reversed order.
    
    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
  - entryRangeAsync
```
RFuture<Collection<ScoredEntry<V>>> entryRangeAsync(double startScore,
                                                    boolean startScoreInclusive,
                                                    double endScore,
                                                    boolean endScoreInclusive)
```
    Returns all entries (value and its score) between startScore and endScore.
    
    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
  - valueRangeAsync
```
RFuture<Collection<V>> valueRangeAsync(double startScore,
                                       boolean startScoreInclusive,
                                       double endScore,
                                       boolean endScoreInclusive,
                                       int offset,
                                       int count)
```
    Returns all values between startScore and endScore.
    
    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
```
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.
    
    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
  - entryRangeAsync
```
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.
    
    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
  - entryRangeReversedAsync
```
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.
    
    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
```
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.
    
    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
  - countAsync
```
RFuture<Integer> countAsync(double startScore,
                            boolean startScoreInclusive,
                            double endScore,
                            boolean endScoreInclusive)
```
    Returns the number of elements with a score between startScore and endScore.
    
    Parameters:
    
    startScore - - start score
    
    startScoreInclusive - - start score inclusive
    
    endScore - - end score
    
    endScoreInclusive - - end score inclusive
    
    Returns:
    
    count
  - readAllAsync
```
RFuture<Collection<V>> readAllAsync()
```
    Read all values at once.
    
    Returns:
    
    values
  - intersectionAsync
```
RFuture<Integer> intersectionAsync(String... names)
```
    Intersect provided ScoredSortedSets and store result to current ScoredSortedSet
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of intersection
  - intersectionAsync
```
RFuture<Integer> intersectionAsync(RScoredSortedSet.Aggregate aggregate,
                                   String... names)
```
    Intersect provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of intersection
  - intersectionAsync
```
RFuture<Integer> intersectionAsync(Map<String,Double> nameWithWeight)
```
    Intersect provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of intersection
  - intersectionAsync
```
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
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of intersection
  - readIntersectionAsync
```
RFuture<Collection<V>> readIntersectionAsync(String... names)
```
    Intersect provided ScoredSortedSets with current ScoredSortedSet without state change
    Requires Redis 6.2.0 and higher.
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of intersection
  - readIntersectionAsync
```
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.
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of intersection
  - readIntersectionAsync
```
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.
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of intersection
  - readIntersectionAsync
```
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.
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of intersection
  - unionAsync
```
RFuture<Integer> unionAsync(String... names)
```
    Union provided ScoredSortedSets and store result to current ScoredSortedSet
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of union
  - unionAsync
```
RFuture<Integer> unionAsync(RScoredSortedSet.Aggregate aggregate,
                            String... names)
```
    Union provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    length of union
  - unionAsync
```
RFuture<Integer> unionAsync(Map<String,Double> nameWithWeight)
```
    Union provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of union
  - unionAsync
```
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
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    length of union
  - readUnionAsync
```
RFuture<Collection<V>> readUnionAsync(String... names)
```
    Union ScoredSortedSets specified by name with current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Parameters:
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of union
  - readUnionAsync
```
RFuture<Collection<V>> readUnionAsync(RScoredSortedSet.Aggregate aggregate,
                                      String... names)
```
    Union ScoredSortedSets specified by name with defined aggregation method and current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    names - - names of ScoredSortedSet
    
    Returns:
    
    result of union
  - readUnionAsync
```
RFuture<Collection<V>> readUnionAsync(Map<String,Double> nameWithWeight)
```
    Union provided ScoredSortedSets mapped to weight multiplier and current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Parameters:
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of union
  - readUnionAsync
```
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.
    
    Parameters:
    
    aggregate - - score aggregation mode
    
    nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
    
    Returns:
    
    result of union
  - readDiffAsync
```
RFuture<Collection<V>> readDiffAsync(String... names)
```
    Diff ScoredSortedSets specified by name with current ScoredSortedSet without state change.
    Requires Redis 6.2.0 and higher.
    
    Parameters:
    
    names - - name of sets
    
    Returns:
    
    result of diff
  - diffAsync
```
RFuture<Integer> diffAsync(String... names)
```
    Diff provided ScoredSortedSets and store result to current ScoredSortedSet
    Requires Redis 6.2.0 and higher.
    
    Parameters:
    
    names - - name of sets
    
    Returns:
    
    length of diff

Interface RScoredSortedSetAsync<V>

Method Summary

Methods inherited from interface org.redisson.api.RExpirableAsync

Methods inherited from interface org.redisson.api.RObjectAsync

Methods inherited from interface org.redisson.api.RSortableAsync

Method Detail

pollLastFromAnyAsync

pollFirstFromAnyAsync

pollFirstAsync

takeFirstAsync

takeLastAsync

pollLastAsync

pollFirstAsync

pollLastAsync

pollFirstAsync

pollLastAsync

firstAsync

lastAsync

firstScoreAsync

lastScoreAsync

randomAsync

randomAsync

randomEntriesAsync

addAllAsync

removeRangeByScoreAsync

removeRangeByRankAsync

rankAsync

revRankAsync

revRankAsync

getScoreAsync

getScoreAsync

addAsync

addAndGetRankAsync

addAndGetRevRankAsync

addAndGetRevRankAsync

tryAddAsync

addIfExistsAsync

addIfLessAsync

addIfGreaterAsync

removeAsync

sizeAsync

containsAsync

containsAllAsync

removeAllAsync

retainAllAsync

addScoreAsync

addScoreAndGetRevRankAsync

addScoreAndGetRankAsync

rangeToAsync

rangeToAsync

rangeToAsync

revRangeToAsync

revRangeToAsync

revRangeToAsync

valueRangeAsync

valueRangeReversedAsync

entryRangeAsync

entryRangeReversedAsync

valueRangeAsync

valueRangeReversedAsync

entryRangeAsync

valueRangeAsync

valueRangeReversedAsync

entryRangeAsync

entryRangeReversedAsync

entryRangeReversedAsync

countAsync

readAllAsync

intersectionAsync

intersectionAsync

intersectionAsync

intersectionAsync

readIntersectionAsync

readIntersectionAsync

readIntersectionAsync

readIntersectionAsync

unionAsync

unionAsync

unionAsync

unionAsync