Package org.redisson.api

Interface RScoredSortedSetRx<V>

Type Parameters:
V - value type
All Superinterfaces:
RExpirableRx, RObjectRx, RSortableRx<Set<V>>
All Known Subinterfaces:
RGeoRx<V>, RLexSortedSetRx
public interface RScoredSortedSetRx<V> extends RExpirableRx, RSortableRx<Set<V>>
RxJava2 interface for scored sorted set data structure.
Author:
Nikita Koksharov

  • Method Summary

    Modifier and Type
    Method
    Description
    io.reactivex.rxjava3.core.Single<Boolean>
    add(double score, V object)
    Adds element to this set, overrides previous score if it has been already added.
    io.reactivex.rxjava3.core.Single<Integer>
    addAll(Map<V,Double> objects)
    Adds all elements contained in the specified map to this sorted set.
    io.reactivex.rxjava3.core.Single<Integer>
    addAllIfAbsent(Map<V,Double> objects)
    Adds elements to this set only if they haven't been added before.
    io.reactivex.rxjava3.core.Single<Integer>
    addAllIfExist(Map<V,Double> objects)
    Adds elements to this set only if they already exist.
    io.reactivex.rxjava3.core.Single<Integer>
    addAllIfGreater(Map<V,Double> objects)
    Adds elements to this set only if new scores greater than current score of existed elements.
    io.reactivex.rxjava3.core.Single<Integer>
    addAllIfLess(Map<V,Double> objects)
    Adds elements to this set only if new scores less than current score of existed elements.
    io.reactivex.rxjava3.core.Single<Integer>
    addAndGetRank(double score, V object)
    Adds element to this set, overrides previous score if it has been already added.
    io.reactivex.rxjava3.core.Single<Integer>
    addAndGetRevRank(double score, V object)
    Adds element to this set, overrides previous score if it has been already added.
    io.reactivex.rxjava3.core.Single<List<Integer>>
    addAndGetRevRank(Map<? extends V,Double> map)
    Adds elements to this set, overrides previous score if it has been already added.
    io.reactivex.rxjava3.core.Single<Boolean>
    addIfAbsent(double score, V object)
    Adds element to this set only if has not been added before.
    io.reactivex.rxjava3.core.Single<Boolean>
    addIfExists(double score, V object)
    Adds element to this set only if it's already exists.
    io.reactivex.rxjava3.core.Single<Boolean>
    addIfGreater(double score, V object)
    Adds element to this set only if new score greater than current score of existed element.
    io.reactivex.rxjava3.core.Single<Boolean>
    addIfLess(double score, V object)
    Adds element to this set only if new score less than current score of existed element.
    io.reactivex.rxjava3.core.Single<Double>
    addScore(V element, Number value)
    Increases score of specified element by value.
    io.reactivex.rxjava3.core.Single<Integer>
    addScoreAndGetRank(V object, Number value)
    Adds score to element and returns its rank
    io.reactivex.rxjava3.core.Single<Integer>
    addScoreAndGetRevRank(V object, Number value)
    Adds score to element and returns its reverse rank
    io.reactivex.rxjava3.core.Single<Boolean>
    contains(V o)
    Returns true if this sorted set contains encoded state of the specified element.
    io.reactivex.rxjava3.core.Single<Boolean>
    containsAll(Collection<?> c)
    Returns true if this sorted set contains all of the elements in encoded state in the specified collection.
    io.reactivex.rxjava3.core.Single<Integer>
    count(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
    Returns the number of elements with a score between startScore and endScore.
    io.reactivex.rxjava3.core.Single<Integer>
    countIntersection(int limit, String... names)
    Counts elements of set as a result of sets intersection with current set.
    io.reactivex.rxjava3.core.Single<Integer>
    countIntersection(String... names)
    Counts elements of set as a result of sets intersection with current set.
    io.reactivex.rxjava3.core.Single<Integer>
    diff(String... names)
    Diff provided ScoredSortedSets and store result to current ScoredSortedSet
    io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>>
    entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
    Returns all entries (value and its score) between startScore and endScore.
    io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>>
    entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
    Returns all entries (value and its score) between startScore and endScore.
    io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>>
    entryRange(int startIndex, int endIndex)
    Returns entries (value and its score) by rank range.
    io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>>
    entryRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
    Returns all entries (value and its score) between startScore and endScore in reversed order.
    io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>>
    entryRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
    Returns all entries (value and its score) between startScore and endScore in reversed order.
    io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>>
    entryRangeReversed(int startIndex, int endIndex)
    Returns entries (value and its score) by rank range in reverse order.
    io.reactivex.rxjava3.core.Maybe<V>
    first()
    Returns the head element or null if this sorted set is empty.
    io.reactivex.rxjava3.core.Maybe<Double>
    firstScore()
    Returns score of the head element or returns null if this sorted set is empty.
    io.reactivex.rxjava3.core.Single<List<Double>>
    getScore(Collection<V> elements)
    Returns scores of elements.
    io.reactivex.rxjava3.core.Maybe<Double>
    getScore(V o)
    Returns score of element or null if it doesn't exist.
    io.reactivex.rxjava3.core.Single<Integer>
    intersection(String... names)
    Intersect provided ScoredSortedSets and store result to current ScoredSortedSet
    io.reactivex.rxjava3.core.Single<Integer>
    intersection(Map<String,Double> nameWithWeight)
    Intersect provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
    io.reactivex.rxjava3.core.Single<Integer>
    intersection(RScoredSortedSet.Aggregate aggregate, String... names)
    Intersect provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
    io.reactivex.rxjava3.core.Single<Integer>
    intersection(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
    Intersect provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
    io.reactivex.rxjava3.core.Flowable<V>
    iterator()
     
    io.reactivex.rxjava3.core.Flowable<V>
    iterator(int count)
    Returns an iterator over elements in this set.
    io.reactivex.rxjava3.core.Flowable<V>
    iterator(String pattern)
    Returns an iterator over elements in this set.
    io.reactivex.rxjava3.core.Flowable<V>
    iterator(String pattern, int count)
    Returns an iterator over elements in this set.
    io.reactivex.rxjava3.core.Maybe<V>
    last()
    Returns the tail element or null if this sorted set is empty.
    io.reactivex.rxjava3.core.Maybe<Double>
    lastScore()
    Returns score of the tail element or returns null if this sorted set is empty.
    io.reactivex.rxjava3.core.Maybe<V>
    pollFirst()
    Removes and returns the head element or null if this sorted set is empty.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    pollFirst(int count)
    Removes and returns the head elements of this sorted set.
    io.reactivex.rxjava3.core.Maybe<V>
    pollFirst(long timeout, TimeUnit unit)
    Removes and returns the head element or null if this sorted set is empty.
    io.reactivex.rxjava3.core.Single<List<V>>
    pollFirst(Duration duration, int count)
    Removes and returns the head elements.
    io.reactivex.rxjava3.core.Single<Map<String,Map<V,Double>>>
    pollFirstEntriesFromAny(int count, String... queueNames)
    Removes and returns first available head entries of any sorted set including this one.
    io.reactivex.rxjava3.core.Single<Map<String,Map<V,Double>>>
    pollFirstEntriesFromAny(Duration duration, int count, String... queueNames)
    Removes and returns first available head entries of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.
    io.reactivex.rxjava3.core.Single<List<V>>
    pollFirstFromAny(int count, String... queueNames)
    Removes and returns first available head elements of any sorted set including this one.
    io.reactivex.rxjava3.core.Maybe<V>
    pollFirstFromAny(long timeout, TimeUnit unit, String... queueNames)
    Removes and returns first available head element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
    io.reactivex.rxjava3.core.Single<List<V>>
    pollFirstFromAny(Duration duration, int count, String... queueNames)
    Removes and returns first available head elements of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.
    io.reactivex.rxjava3.core.Maybe<V>
    pollLast()
    Removes and returns the tail element or null if this sorted set is empty.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    pollLast(int count)
    Removes and returns the tail elements of this sorted set.
    io.reactivex.rxjava3.core.Maybe<V>
    pollLast(long timeout, TimeUnit unit)
    Removes and returns the tail element or null if this sorted set is empty.
    io.reactivex.rxjava3.core.Single<List<V>>
    pollLast(Duration duration, int count)
    Removes and returns the tail elements.
    io.reactivex.rxjava3.core.Single<Map<String,Map<V,Double>>>
    pollLastEntriesFromAny(int count, String... queueNames)
    Removes and returns first available tail entries of any sorted set including this one.
    io.reactivex.rxjava3.core.Single<Map<String,Map<V,Double>>>
    pollLastEntriesFromAny(Duration duration, int count, String... queueNames)
    Removes and returns first available tail entries of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.
    io.reactivex.rxjava3.core.Single<List<V>>
    pollLastFromAny(int count, String... queueNames)
    Removes and returns first available tail elements of any sorted set including this one.
    io.reactivex.rxjava3.core.Maybe<V>
    pollLastFromAny(long timeout, TimeUnit unit, String... queueNames)
    Removes and returns first available tail element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
    io.reactivex.rxjava3.core.Single<List<V>>
    pollLastFromAny(Duration duration, int count, String... queueNames)
    Removes and returns first available tail elements of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.
    io.reactivex.rxjava3.core.Maybe<V>
    random()
    Returns random element from this sorted set
    io.reactivex.rxjava3.core.Single<Collection<V>>
    random(int count)
    Returns random elements from this sorted set limited by count
    io.reactivex.rxjava3.core.Single<Map<V,Double>>
    randomEntries(int count)
    Returns random entries from this sorted set limited by count.
    io.reactivex.rxjava3.core.Single<Integer>
    rangeTo(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
    Stores to defined ScoredSortedSet values between startScore and endScore.
    io.reactivex.rxjava3.core.Single<Integer>
    rangeTo(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
    Stores to defined ScoredSortedSet values between startScore and endScore.
    io.reactivex.rxjava3.core.Single<Integer>
    rangeTo(String destName, int startIndex, int endIndex)
    Stores to defined ScoredSortedSet values by rank range.
    io.reactivex.rxjava3.core.Maybe<Integer>
    rank(V o)
    Returns rank of value, with the scores ordered from low to high.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    readAll()
    Read all values at once.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    readDiff(String... names)
    Diff ScoredSortedSets specified by name with current ScoredSortedSet without state change.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    readIntersection(String... names)
    Intersect provided ScoredSortedSets with current ScoredSortedSet without state change
    io.reactivex.rxjava3.core.Single<Collection<V>>
    readIntersection(Map<String,Double> nameWithWeight)
    Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet without state change
    io.reactivex.rxjava3.core.Single<Collection<V>>
    readIntersection(RScoredSortedSet.Aggregate aggregate, String... names)
    Intersect provided ScoredSortedSets with current ScoredSortedSet using defined aggregation method without state change
    io.reactivex.rxjava3.core.Single<Collection<V>>
    readIntersection(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
    Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet using defined aggregation method without state change
    io.reactivex.rxjava3.core.Single<Collection<V>>
    readUnion(String... names)
    Union ScoredSortedSets specified by name with current ScoredSortedSet without state change.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    readUnion(Map<String,Double> nameWithWeight)
    Union provided ScoredSortedSets mapped to weight multiplier and current ScoredSortedSet without state change.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    readUnion(RScoredSortedSet.Aggregate aggregate, String... names)
    Union ScoredSortedSets specified by name with defined aggregation method and current ScoredSortedSet without state change.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    readUnion(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
    Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and current ScoredSortedSet without state change
    io.reactivex.rxjava3.core.Single<Boolean>
    remove(V object)
    Removes a single instance of the specified element from this sorted set, if it is present.
    io.reactivex.rxjava3.core.Single<Boolean>
    removeAll(Collection<?> c)
    Removes all of this sorted set's elements that are also contained in the specified collection.
    io.reactivex.rxjava3.core.Single<Integer>
    removeRangeByRank(int startIndex, int endIndex)
    Removes values by rank range.
    io.reactivex.rxjava3.core.Single<Integer>
    removeRangeByScore(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
    Removes values by score range.
    io.reactivex.rxjava3.core.Single<Boolean>
    replace(V oldObject, V newObject)
    Replaces a previous oldObject with a newObject.
    io.reactivex.rxjava3.core.Single<Boolean>
    retainAll(Collection<?> c)
    Retains only the elements in this sorted set that are contained in the specified collection.
    io.reactivex.rxjava3.core.Single<Integer>
    revRangeTo(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
    Stores to defined ScoredSortedSet values in reversed order between startScore and endScore.
    io.reactivex.rxjava3.core.Single<Integer>
    revRangeTo(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
    Stores to defined ScoredSortedSet values in reversed order between startScore and endScore.
    io.reactivex.rxjava3.core.Single<Integer>
    revRangeTo(String destName, int startIndex, int endIndex)
    Stores to defined ScoredSortedSet values in reversed order by rank range.
    io.reactivex.rxjava3.core.Single<List<Integer>>
    revRank(Collection<V> elements)
    Returns ranks of elements, with the scores ordered from high to low.
    io.reactivex.rxjava3.core.Maybe<Integer>
    revRank(V o)
    Returns rank of value, with the scores ordered from high to low.
    io.reactivex.rxjava3.core.Single<Integer>
    size()
    Returns size of this set.
    io.reactivex.rxjava3.core.Single<V>
    takeFirst()
    Removes and returns the head element waiting if necessary for an element to become available.
    io.reactivex.rxjava3.core.Flowable<V>
    takeFirstElements()
    Retrieves and removes continues stream of elements from the head.
    io.reactivex.rxjava3.core.Single<V>
    takeLast()
    Removes and returns the tail element waiting if necessary for an element to become available.
    io.reactivex.rxjava3.core.Flowable<V>
    takeLastElements()
    Retrieves and removes continues stream of elements from the tail.
    io.reactivex.rxjava3.core.Single<Boolean>
    tryAdd(double score, V object)
    Deprecated.
    io.reactivex.rxjava3.core.Single<Integer>
    union(String... names)
    Union provided ScoredSortedSets and store result to current ScoredSortedSet
    io.reactivex.rxjava3.core.Single<Integer>
    union(Map<String,Double> nameWithWeight)
    Union provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
    io.reactivex.rxjava3.core.Single<Integer>
    union(RScoredSortedSet.Aggregate aggregate, String... names)
    Union provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
    io.reactivex.rxjava3.core.Single<Integer>
    union(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
    Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
    io.reactivex.rxjava3.core.Single<Collection<V>>
    valueRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
    Returns all values between startScore and endScore.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    valueRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
    Returns all values between startScore and endScore.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    valueRange(int startIndex, int endIndex)
    Returns values by rank range.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    valueRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
    Returns all values between startScore and endScore in reversed order.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    valueRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
    Returns all values between startScore and endScore in reversed order.
    io.reactivex.rxjava3.core.Single<Collection<V>>
    valueRangeReversed(int startIndex, int endIndex)
    Returns values by rank range in reverse order.

    Methods inherited from interface org.redisson.api.RExpirableRx

    clearExpire, expire, expire, expire, expireAt, expireAt, expireIfGreater, expireIfGreater, expireIfLess, expireIfLess, expireIfNotSet, expireIfNotSet, expireIfSet, expireIfSet, getExpireTime, remainTimeToLive

    Methods inherited from interface org.redisson.api.RObjectRx

    addListener, copy, delete, dump, getCodec, getIdleTime, getName, isExists, migrate, move, removeListener, rename, renamenx, restore, restore, restoreAndReplace, restoreAndReplace, sizeInMemory, touch, unlink

    Methods inherited from interface org.redisson.api.RSortableRx

    readSorted, readSorted, readSorted, readSorted, readSorted, readSorted, sortTo, sortTo, sortTo, sortTo, sortTo, sortTo

  • Method Details

    • pollLastFromAny

      io.reactivex.rxjava3.core.Maybe<V> pollLastFromAny(long timeout, TimeUnit unit, String... queueNames)
      Removes and returns first available tail element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.

      Requires Redis 5.0.0 and higher.

      Parameters:
      queueNames - name of queues
      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

    • pollLastFromAny

      io.reactivex.rxjava3.core.Single<List<V>> pollLastFromAny(Duration duration, int count, String... queueNames)
      Removes and returns first available tail elements of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.

      Requires Redis 7.0.0 and higher.

      Parameters:
      duration - how long to wait before giving up
      count - elements amount
      queueNames - name of queues
      Returns:
      the tail elements

    • pollLastFromAny

      io.reactivex.rxjava3.core.Single<List<V>> pollLastFromAny(int count, String... queueNames)
      Removes and returns first available tail elements of any sorted set including this one.

      Requires Redis 7.0.0 and higher.

      Parameters:
      count - elements amount
      queueNames - name of queues
      Returns:
      the tail elements

    • pollLastEntriesFromAny

      io.reactivex.rxjava3.core.Single<Map<String,Map<V,Double>>> pollLastEntriesFromAny(int count, String... queueNames)
      Removes and returns first available tail entries of any sorted set including this one.

      Requires Redis 7.0.0 and higher.

      Parameters:
      count - entries amount
      queueNames - name of queues
      Returns:
      the head entries

    • pollLastEntriesFromAny

      io.reactivex.rxjava3.core.Single<Map<String,Map<V,Double>>> pollLastEntriesFromAny(Duration duration, int count, String... queueNames)
      Removes and returns first available tail entries of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.

      Requires Redis 7.0.0 and higher.

      Parameters:
      duration - how long to wait before giving up
      count - entries amount
      queueNames - name of queues
      Returns:
      the tail entries

    • pollFirstFromAny

      io.reactivex.rxjava3.core.Maybe<V> pollFirstFromAny(long timeout, TimeUnit unit, String... queueNames)
      Removes and returns first available head element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.

      Requires Redis 5.0.0 and higher.

      Parameters:
      queueNames - name of queues
      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

    • pollFirstFromAny

      io.reactivex.rxjava3.core.Single<List<V>> pollFirstFromAny(Duration duration, int count, String... queueNames)
      Removes and returns first available head elements of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.

      Requires Redis 7.0.0 and higher.

      Parameters:
      duration - how long to wait before giving up
      count - elements amount
      queueNames - name of queues
      Returns:
      the head elements

    • pollFirstFromAny

      io.reactivex.rxjava3.core.Single<List<V>> pollFirstFromAny(int count, String... queueNames)
      Removes and returns first available head elements of any sorted set including this one.

      Requires Redis 7.0.0 and higher.

      Parameters:
      count - elements amount
      queueNames - name of queues
      Returns:
      the head elements

    • pollFirstEntriesFromAny

      io.reactivex.rxjava3.core.Single<Map<String,Map<V,Double>>> pollFirstEntriesFromAny(int count, String... queueNames)
      Removes and returns first available head entries of any sorted set including this one.

      Requires Redis 7.0.0 and higher.

      Parameters:
      count - entries amount
      queueNames - name of queues
      Returns:
      the head elements

    • pollFirstEntriesFromAny

      io.reactivex.rxjava3.core.Single<Map<String,Map<V,Double>>> pollFirstEntriesFromAny(Duration duration, int count, String... queueNames)
      Removes and returns first available head entries of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.

      Requires Redis 7.0.0 and higher.

      Parameters:
      duration - how long to wait before giving up
      count - entries amount
      queueNames - name of queues
      Returns:
      the head entries

    • pollFirst

      io.reactivex.rxjava3.core.Maybe<V> pollFirst(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

    • pollFirst

      io.reactivex.rxjava3.core.Single<List<V>> pollFirst(Duration duration, int count)
      Removes and returns the head elements.

      Requires Redis 7.0.0 and higher.

      Parameters:
      duration - how long to wait before giving up
      count - elements amount
      Returns:
      the head element

    • pollLast

      io.reactivex.rxjava3.core.Maybe<V> pollLast(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

    • pollLast

      io.reactivex.rxjava3.core.Single<List<V>> pollLast(Duration duration, int count)
      Removes and returns the tail elements.

      Requires Redis 7.0.0 and higher.

      Parameters:
      duration - how long to wait before giving up
      Returns:
      the tail elements

    • pollFirst

      io.reactivex.rxjava3.core.Single<Collection<V>> pollFirst(int count)
      Removes and returns the head elements of this sorted set.
      Parameters:
      count - - elements amount
      Returns:
      the head elements of this sorted set

    • pollLast

      io.reactivex.rxjava3.core.Single<Collection<V>> pollLast(int count)
      Removes and returns the tail elements of this sorted set.
      Parameters:
      count - - elements amount
      Returns:
      the tail elements of this sorted set

    • pollFirst

      io.reactivex.rxjava3.core.Maybe<V> pollFirst()
      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

    • pollLast

      io.reactivex.rxjava3.core.Maybe<V> pollLast()
      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

    • first

      io.reactivex.rxjava3.core.Maybe<V> first()
      Returns the head element or null if this sorted set is empty.
      Returns:
      the head element or null if this sorted set is empty

    • last

      io.reactivex.rxjava3.core.Maybe<V> last()
      Returns the tail element or null if this sorted set is empty.
      Returns:
      the tail element or null if this sorted set is empty

    • firstScore

      io.reactivex.rxjava3.core.Maybe<Double> firstScore()
      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

    • lastScore

      io.reactivex.rxjava3.core.Maybe<Double> lastScore()
      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

    • random

      io.reactivex.rxjava3.core.Maybe<V> random()
      Returns random element from this sorted set

      Requires Redis 6.2.0 and higher.

      Returns:
      random element

    • random

      io.reactivex.rxjava3.core.Single<Collection<V>> random(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:
      random elements

    • randomEntries

      io.reactivex.rxjava3.core.Single<Map<V,Double>> randomEntries(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

    • iterator

      io.reactivex.rxjava3.core.Flowable<V> iterator(String pattern)
      Returns an iterator over elements in this set. If pattern is not null then only elements match this pattern are loaded.
      Parameters:
      pattern - - search pattern
      Returns:
      iterator

    • iterator

      io.reactivex.rxjava3.core.Flowable<V> iterator(int count)
      Returns an iterator over elements in this set. Elements are loaded in batch. Batch size is defined by count param.
      Parameters:
      count - - size of elements batch
      Returns:
      iterator

    • iterator

      io.reactivex.rxjava3.core.Flowable<V> iterator(String pattern, int count)
      Returns an iterator over elements in this set. Elements are loaded in batch. Batch size is defined by count param. If pattern is not null then only elements match this pattern are loaded.
      Parameters:
      pattern - - search pattern
      count - - size of elements batch
      Returns:
      iterator

    • iterator

      io.reactivex.rxjava3.core.Flowable<V> iterator()

    • removeRangeByScore

      io.reactivex.rxjava3.core.Single<Integer> removeRangeByScore(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

    • removeRangeByRank

      io.reactivex.rxjava3.core.Single<Integer> removeRangeByRank(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

    • rank

      io.reactivex.rxjava3.core.Maybe<Integer> rank(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

    • revRank

      io.reactivex.rxjava3.core.Maybe<Integer> revRank(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

    • revRank

      io.reactivex.rxjava3.core.Single<List<Integer>> revRank(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

    • getScore

      io.reactivex.rxjava3.core.Maybe<Double> getScore(V o)
      Returns score of element or null if it doesn't exist.
      Parameters:
      o - - element
      Returns:
      score

    • getScore

      io.reactivex.rxjava3.core.Single<List<Double>> getScore(Collection<V> elements)
      Returns scores of elements.
      Parameters:
      elements - - elements
      Returns:
      element scores

    • add

      io.reactivex.rxjava3.core.Single<Boolean> add(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.

    • addAll

      io.reactivex.rxjava3.core.Single<Integer> addAll(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

    • addAllIfAbsent

      io.reactivex.rxjava3.core.Single<Integer> addAllIfAbsent(Map<V,Double> objects)
      Adds elements to this set only if they haven't been added before.

      Requires Redis 3.0.2 and higher.

      Parameters:
      objects - map of elements to add
      Returns:
      amount of added elements

    • addAllIfExist

      io.reactivex.rxjava3.core.Single<Integer> addAllIfExist(Map<V,Double> objects)
      Adds elements to this set only if they already exist.

      Requires Redis 3.0.2 and higher.

      Parameters:
      objects - map of elements to add
      Returns:
      amount of added elements

    • addAllIfGreater

      io.reactivex.rxjava3.core.Single<Integer> addAllIfGreater(Map<V,Double> objects)
      Adds elements to this set only if new scores greater than current score of existed elements.

      Requires Redis 6.2.0 and higher.

      Parameters:
      objects - map of elements to add
      Returns:
      amount of added elements

    • addAllIfLess

      io.reactivex.rxjava3.core.Single<Integer> addAllIfLess(Map<V,Double> objects)
      Adds elements to this set only if new scores less than current score of existed elements.

      Requires Redis 6.2.0 and higher.

      Parameters:
      objects - map of elements to add
      Returns:
      amount of added elements

    • addAndGetRank

      io.reactivex.rxjava3.core.Single<Integer> addAndGetRank(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

    • addAndGetRevRank

      io.reactivex.rxjava3.core.Single<Integer> addAndGetRevRank(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

    • addAndGetRevRank

      io.reactivex.rxjava3.core.Single<List<Integer>> addAndGetRevRank(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

    • tryAdd

      @Deprecated io.reactivex.rxjava3.core.Single<Boolean> tryAdd(double score, V object)
      Deprecated.
      Use addIfAbsent(double, Object) instead
      Parameters:
      score - - object score
      object - - object itself
      Returns:
      true if element has added and false if not.

    • addIfAbsent

      io.reactivex.rxjava3.core.Single<Boolean> addIfAbsent(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 added and false if not.

    • addIfExists

      io.reactivex.rxjava3.core.Single<Boolean> addIfExists(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.

    • addIfLess

      io.reactivex.rxjava3.core.Single<Boolean> addIfLess(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.

    • addIfGreater

      io.reactivex.rxjava3.core.Single<Boolean> addIfGreater(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.

    • replace

      io.reactivex.rxjava3.core.Single<Boolean> replace(V oldObject, V newObject)
      Replaces a previous oldObject with a newObject. Returns false if previous object doesn't exist.
      Parameters:
      oldObject - old object
      newObject - new object
      Returns:
      true if object has been replaced otherwise false.

    • remove

      io.reactivex.rxjava3.core.Single<Boolean> remove(V object)
      Removes a single instance of the specified element from this sorted set, if it is present.
      Parameters:
      object - element to be removed from this sorted set, if present
      Returns:
      true if an element was removed as a result of this call

    • size

      io.reactivex.rxjava3.core.Single<Integer> size()
      Returns size of this set.
      Returns:
      size

    • contains

      io.reactivex.rxjava3.core.Single<Boolean> contains(V 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

    • containsAll

      io.reactivex.rxjava3.core.Single<Boolean> containsAll(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

    • removeAll

      io.reactivex.rxjava3.core.Single<Boolean> removeAll(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

    • retainAll

      io.reactivex.rxjava3.core.Single<Boolean> retainAll(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

    • addScore

      io.reactivex.rxjava3.core.Single<Double> addScore(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

    • addScoreAndGetRevRank

      io.reactivex.rxjava3.core.Single<Integer> addScoreAndGetRevRank(V object, Number value)
      Adds score to element and returns its reverse rank
      Parameters:
      object - - object itself
      value - - object score
      Returns:
      reverse rank

    • addScoreAndGetRank

      io.reactivex.rxjava3.core.Single<Integer> addScoreAndGetRank(V object, Number value)
      Adds score to element and returns its rank
      Parameters:
      object - - object itself
      value - - object score
      Returns:
      rank

    • rangeTo

      io.reactivex.rxjava3.core.Single<Integer> rangeTo(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.

      Requires Redis 6.2.0 and higher.

      Parameters:
      startIndex - - start index
      endIndex - - end index
      Returns:
      elements

    • rangeTo

      io.reactivex.rxjava3.core.Single<Integer> rangeTo(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

    • rangeTo

      io.reactivex.rxjava3.core.Single<Integer> rangeTo(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

    • revRangeTo

      io.reactivex.rxjava3.core.Single<Integer> revRangeTo(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.

      Requires Redis 6.2.0 and higher.

      Parameters:
      startIndex - - start index
      endIndex - - end index
      Returns:
      elements

    • revRangeTo

      io.reactivex.rxjava3.core.Single<Integer> revRangeTo(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

    • revRangeTo

      io.reactivex.rxjava3.core.Single<Integer> revRangeTo(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
      Stores to defined ScoredSortedSet values in reversed order between startScore and endScore.

      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

    • valueRange

      io.reactivex.rxjava3.core.Single<Collection<V>> valueRange(int startIndex, int endIndex)
      Returns 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

    • entryRange

      io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>> entryRange(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

    • valueRange

      io.reactivex.rxjava3.core.Single<Collection<V>> valueRange(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

    • entryRange

      io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>> entryRange(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

    • valueRange

      io.reactivex.rxjava3.core.Single<Collection<V>> valueRange(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

    • entryRange

      io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>> entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
      Returns all entries (value and its score) between startScore and endScore.
      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

    • valueRangeReversed

      io.reactivex.rxjava3.core.Single<Collection<V>> valueRangeReversed(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

    • valueRangeReversed

      io.reactivex.rxjava3.core.Single<Collection<V>> valueRangeReversed(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

    • valueRangeReversed

      io.reactivex.rxjava3.core.Single<Collection<V>> valueRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
      Returns all values between startScore and endScore in reversed order.
      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

    • entryRangeReversed

      io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>> entryRangeReversed(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

    • entryRangeReversed

      io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>> entryRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
      Returns all entries (value and its score) between startScore and endScore in reversed order.
      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

    • entryRangeReversed

      io.reactivex.rxjava3.core.Single<Collection<ScoredEntry<V>>> entryRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
      Returns all entries (value and its score) between startScore and endScore in reversed order.
      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

    • count

      io.reactivex.rxjava3.core.Single<Integer> count(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

    • readAll

      io.reactivex.rxjava3.core.Single<Collection<V>> readAll()
      Read all values at once.
      Returns:
      values

    • intersection

      io.reactivex.rxjava3.core.Single<Integer> intersection(String... names)
      Intersect provided ScoredSortedSets and store result to current ScoredSortedSet
      Parameters:
      names - - names of ScoredSortedSet
      Returns:
      length of intersection

    • intersection

      io.reactivex.rxjava3.core.Single<Integer> intersection(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

    • intersection

      io.reactivex.rxjava3.core.Single<Integer> intersection(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

    • intersection

      io.reactivex.rxjava3.core.Single<Integer> intersection(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
      Intersect provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
      Parameters:
      aggregate - - score aggregation mode
      nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
      Returns:
      length of intersection

    • readIntersection

      io.reactivex.rxjava3.core.Single<Collection<V>> readIntersection(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

    • readIntersection

      io.reactivex.rxjava3.core.Single<Collection<V>> readIntersection(RScoredSortedSet.Aggregate aggregate, String... names)
      Intersect provided ScoredSortedSets with current ScoredSortedSet using defined aggregation method without state change

      Requires Redis 6.2.0 and higher.

      Parameters:
      aggregate - - score aggregation mode
      names - - names of ScoredSortedSet
      Returns:
      result of intersection

    • readIntersection

      io.reactivex.rxjava3.core.Single<Collection<V>> readIntersection(Map<String,Double> nameWithWeight)
      Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet without state change

      Requires Redis 6.2.0 and higher.

      Parameters:
      nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
      Returns:
      result of intersection

    • readIntersection

      io.reactivex.rxjava3.core.Single<Collection<V>> readIntersection(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
      Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet using defined aggregation method without state change

      Requires Redis 6.2.0 and higher.

      Parameters:
      aggregate - - score aggregation mode
      nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
      Returns:
      result of intersection

    • countIntersection

      io.reactivex.rxjava3.core.Single<Integer> countIntersection(String... names)
      Counts elements of set as a result of sets intersection with current set.

      Requires Redis 7.0.0 and higher.

      Parameters:
      names - - name of sets
      Returns:
      amount of elements

    • countIntersection

      io.reactivex.rxjava3.core.Single<Integer> countIntersection(int limit, String... names)
      Counts elements of set as a result of sets intersection with current set.

      Requires Redis 7.0.0 and higher.

      Parameters:
      names - - name of sets
      limit - - sets intersection limit
      Returns:
      amount of elements

    • union

      io.reactivex.rxjava3.core.Single<Integer> union(String... names)
      Union provided ScoredSortedSets and store result to current ScoredSortedSet
      Parameters:
      names - - names of ScoredSortedSet
      Returns:
      length of union

    • union

      io.reactivex.rxjava3.core.Single<Integer> union(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

    • union

      io.reactivex.rxjava3.core.Single<Integer> union(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

    • union

      io.reactivex.rxjava3.core.Single<Integer> union(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
      Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
      Parameters:
      aggregate - - score aggregation mode
      nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
      Returns:
      length of union

    • readUnion

      io.reactivex.rxjava3.core.Single<Collection<V>> readUnion(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

    • readUnion

      io.reactivex.rxjava3.core.Single<Collection<V>> readUnion(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

    • readUnion

      io.reactivex.rxjava3.core.Single<Collection<V>> readUnion(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

    • readUnion

      io.reactivex.rxjava3.core.Single<Collection<V>> readUnion(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
      Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and current ScoredSortedSet without state change

      Requires Redis 6.2.0 and higher.

      Parameters:
      aggregate - - score aggregation mode
      nameWithWeight - - name of ScoredSortedSet mapped to weight multiplier
      Returns:
      result of union

    • readDiff

      io.reactivex.rxjava3.core.Single<Collection<V>> readDiff(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

    • diff

      io.reactivex.rxjava3.core.Single<Integer> diff(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

    • takeFirst

      io.reactivex.rxjava3.core.Single<V> takeFirst()
      Removes and returns the head element waiting if necessary for an element to become available.
      Returns:
      the head element

    • takeLast

      io.reactivex.rxjava3.core.Single<V> takeLast()
      Removes and returns the tail element waiting if necessary for an element to become available.
      Returns:
      the tail element

    • takeFirstElements

      io.reactivex.rxjava3.core.Flowable<V> takeFirstElements()
      Retrieves and removes continues stream of elements from the head. Waits for next element become available.
      Returns:
      stream of head elements

    • takeLastElements

      io.reactivex.rxjava3.core.Flowable<V> takeLastElements()
      Retrieves and removes continues stream of elements from the tail. Waits for next element become available.
      Returns:
      stream of tail elements