Package org.redisson.api

Interface RScoredSortedSetAsync<V>

    • Method Summary

      All Methods Instance Methods Abstract Methods 
      Modifier and Type Method Description
      > <> objects)
      Adds all elements contained in the specified map to this sorted set.
      > addAndGetRankAsync​(double score, V object)
      Adds element to this set, overrides previous score if it has been already added.
      > addAndGetRevRankAsync​(double score, V object)
      Adds element to this set, overrides previous score if it has been already added.
      <>> <? extends > map)
      Adds elements to this set, overrides previous score if it has been already added.
      > addAsync​(double score, V object)
      Adds element to this set, overrides previous score if it has been already added.
      > addIfExistsAsync​(double score, V object)
      Adds element to this set only if it's already exists.
      > addIfGreaterAsync​(double score, V object)
      Adds element to this set only if new score greater than current score of existed element.
      > addIfLessAsync​(double score, V object)
      Adds element to this set only if new score less than current score of existed element.
      > addScoreAndGetRankAsync​(V object,  value)
      Adds score to element and returns its rank
      > addScoreAndGetRevRankAsync​(V object,  value)
      Adds score to element and returns its reverse rank
      > addScoreAsync​(V element,  value)
      Increases score of specified element by value.
      > <?> c)
      Returns true if this sorted set contains all of the elements in encoded state in the specified collection.
      >  o)
      Returns true if this sorted set contains encoded state of the specified element.
      > countAsync​(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
      Returns the number of elements with a score between startScore and endScore.
      > ... names)
      Diff provided ScoredSortedSets and store result to current ScoredSortedSet
      <ScoredEntry<V>>> entryRangeAsync​(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
      Returns all entries (value and its score) between startScore and endScore.
      <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.
      <ScoredEntry<V>>> entryRangeAsync​(int startIndex, int endIndex)
      Returns entries (value and its score) by rank range.
      <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.
      <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.
      <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.
      > firstScoreAsync()
      Returns score of the head element or returns null if this sorted set is empty.
      <>> <V> elements)
      Returns scores of elements.
      > getScoreAsync​(V o)
      Returns score of element or null if it doesn't exist.
      > ... names)
      Intersect provided ScoredSortedSets and store result to current ScoredSortedSet
      > <,​> nameWithWeight)
      Intersect provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
      > intersectionAsync​(RScoredSortedSet.Aggregate aggregate, ... names)
      Intersect provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
      > intersectionAsync​(RScoredSortedSet.Aggregate aggregate, <,​> 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.
      > 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.
      <V>> pollFirstAsync​(int count)
      Removes and returns the head elements of this sorted set.
      RFuture<V> pollFirstAsync​(long timeout,  unit)
      Removes and returns the head element or null if this sorted set is empty.
      RFuture<V> pollFirstFromAnyAsync​(long timeout,  unit, ... 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.
      <V>> pollLastAsync​(int count)
      Removes and returns the tail elements of this sorted set.
      RFuture<V> pollLastAsync​(long timeout,  unit)
      Removes and returns the tail element or null if this sorted set is empty.
      RFuture<V> pollLastFromAnyAsync​(long timeout,  unit, ... 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
      <V>> randomAsync​(int count)
      Returns random elements from this sorted set limited by count
      <>> randomEntriesAsync​(int count)
      Returns random entries from this sorted set limited by count.
      >  destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
      Stores to defined ScoredSortedSet values between startScore and endScore.
      >  destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
      Stores to defined ScoredSortedSet values between startScore and endScore.
      >  destName, int startIndex, int endIndex)
      Stores to defined ScoredSortedSet values by rank range.
      > rankAsync​(V o)
      Returns rank of value, with the scores ordered from low to high.
      <V>> readAllAsync()
      Read all values at once.
      <V>> ... names)
      Diff ScoredSortedSets specified by name with current ScoredSortedSet without state change.
      <V>> ... names)
      Intersect provided ScoredSortedSets with current ScoredSortedSet without state change
      <V>> <,​> nameWithWeight)
      Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet without state change
      <V>> readIntersectionAsync​(RScoredSortedSet.Aggregate aggregate, ... names)
      Intersect provided ScoredSortedSets with current ScoredSortedSet using defined aggregation method without state change
      <V>> readIntersectionAsync​(RScoredSortedSet.Aggregate aggregate, <,​> nameWithWeight)
      Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet using defined aggregation method without state change
      <V>> ... names)
      Union ScoredSortedSets specified by name with current ScoredSortedSet without state change.
      <V>> <,​> nameWithWeight)
      Union provided ScoredSortedSets mapped to weight multiplier and current ScoredSortedSet without state change.
      <V>> readUnionAsync​(RScoredSortedSet.Aggregate aggregate, ... names)
      Union ScoredSortedSets specified by name with defined aggregation method and current ScoredSortedSet without state change.
      <V>> readUnionAsync​(RScoredSortedSet.Aggregate aggregate, <,​> nameWithWeight)
      Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and current ScoredSortedSet without state change
      > <?> c)
      Removes all of this sorted set's elements that are also contained in the specified collection.
      > removeAsync​(V o)
      Removes a single instance of the specified element from this sorted set, if it is present.
      > removeRangeByRankAsync​(int startIndex, int endIndex)
      Removes values by rank range.
      > removeRangeByScoreAsync​(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
      Removes values by score range.
      > <?> c)
      Retains only the elements in this sorted set that are contained in the specified collection.
      >  destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
      Stores to defined ScoredSortedSet values in reversed order between startScore and endScore.
      >  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.
      >  destName, int startIndex, int endIndex)
      Stores to defined ScoredSortedSet values in reversed order by rank range.
      <>> <V> elements)
      Returns ranks of elements, with the scores ordered from high to low.
      > revRankAsync​(V o)
      Returns rank of value, with the scores ordered from high to low.
      > 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.
      > tryAddAsync​(double score, V object)
      Adds element to this set only if has not been added before.
      > ... names)
      Union provided ScoredSortedSets and store result to current ScoredSortedSet
      > <,​> nameWithWeight)
      Union provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
      > unionAsync​(RScoredSortedSet.Aggregate aggregate, ... names)
      Union provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
      > unionAsync​(RScoredSortedSet.Aggregate aggregate, <,​> nameWithWeight)
      Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
      <V>> valueRangeAsync​(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
      Returns all values between startScore and endScore.
      <V>> valueRangeAsync​(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
      Returns all values between startScore and endScore.
      <V>> valueRangeAsync​(int startIndex, int endIndex)
      Returns values by rank range.
      <V>> valueRangeReversedAsync​(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
      Returns all values between startScore and endScore in reversed order.
      <V>> valueRangeReversedAsync​(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
      Returns all values between startScore and endScore in reversed order.
      <V>> valueRangeReversedAsync​(int startIndex, int endIndex)
      Returns values by rank range in reverse order.

    • Method Detail

      • pollLastFromAnyAsync

        RFuture<V> pollLastFromAnyAsync​(long timeout,
                                 unit,
                                ... 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,
                                  unit,
                                 ... 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,
                           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,
                          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

        <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

        <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

        > 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

        > 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

        <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

        <>> 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

        > addAllAsync​(<> 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

        > 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

        > 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

        > 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

        > 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

        <>> revRankAsync​(<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

        > getScoreAsync​(V o)
        Returns score of element or null if it doesn't exist.
        Parameters:
        o - - element
        Returns:
        score

      • getScoreAsync

        <>> getScoreAsync​(<V> elements)
        Returns scores of elements.
        Parameters:
        elements - - elements
        Returns:
        element scores

      • addAsync

        > 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

        > 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

        > 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

        <>> addAndGetRevRankAsync​(<? extends > 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

        > 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

        > 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

        > 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

        > 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

        > 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

        > sizeAsync()
        Returns size of this set.
        Returns:
        size

      • containsAsync

        > containsAsync​( 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

        > containsAllAsync​(<?> 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

        > removeAllAsync​(<?> 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

        > retainAllAsync​(<?> 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

        > addScoreAsync​(V element,
                               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

        > addScoreAndGetRevRankAsync​(V object,
                                             value)
        Adds score to element and returns its reverse rank
        Parameters:
        object - - object itself
        value - - object score
        Returns:
        reverse rank

      • addScoreAndGetRankAsync

        > addScoreAndGetRankAsync​(V object,
                                          value)
        Adds score to element and returns its rank
        Parameters:
        object - - object itself
        value - - object score
        Returns:
        rank

      • rangeToAsync

        > rangeToAsync​( 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

        > rangeToAsync​( 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

        > rangeToAsync​( 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

        > revRangeToAsync​( 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

        > revRangeToAsync​( 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

        > revRangeToAsync​( 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

        <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

        <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

        <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

        <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

        <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

        <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

        <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

        <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

        <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

        <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

        <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

        <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

        > 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

        <V>> readAllAsync()
        Read all values at once.
        Returns:
        values

      • intersectionAsync

        > intersectionAsync​(... names)
        Intersect provided ScoredSortedSets and store result to current ScoredSortedSet
        Parameters:
        names - - names of ScoredSortedSet
        Returns:
        length of intersection

      • intersectionAsync

        > intersectionAsync​(RScoredSortedSet.Aggregate aggregate,
                                   ... 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

        > intersectionAsync​(<,​> 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

        > intersectionAsync​(RScoredSortedSet.Aggregate aggregate,
                                   <,​> 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

        <... 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

        <V>> readIntersectionAsync​(RScoredSortedSet.Aggregate aggregate,
                                             ... 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

        <<,​> 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

        <V>> readIntersectionAsync​(RScoredSortedSet.Aggregate aggregate,
                                             <,​> 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

        > unionAsync​(... names)
        Union provided ScoredSortedSets and store result to current ScoredSortedSet
        Parameters:
        names - - names of ScoredSortedSet
        Returns:
        length of union

      • unionAsync

        > unionAsync​(RScoredSortedSet.Aggregate aggregate,
                            ... 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

        > unionAsync​(<,​> 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

        > unionAsync​(RScoredSortedSet.Aggregate aggregate,
                            <,​> 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

        <... 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

        <V>> readUnionAsync​(RScoredSortedSet.Aggregate aggregate,
                                      ... 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

        <<,​> 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

        <V>> readUnionAsync​(RScoredSortedSet.Aggregate aggregate,
                                      <,​> 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

        <... 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

        > diffAsync​(... 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