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>	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>	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>	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.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.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.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.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>	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)	Adds element to this set only if has not been added before.
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, expireAt, expireAt, expireAt, 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 Detail

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

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

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

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

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

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

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

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.

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

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