Please wait. This can take some minutes ...
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.redisson.RedissonSet Maven / Gradle / Ivy
Go to download
Easy Redis Java client and Real-Time Data Platform. Valkey compatible. Sync/Async/RxJava3/Reactive API. Client side caching. Over 50 Redis based Java objects and services: JCache API, Apache Tomcat, Hibernate, Spring, Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Bloom filter, Scheduler, RPC
/**
* Copyright (c) 2013-2024 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson;
import org.redisson.api.*;
import org.redisson.api.listener.*;
import org.redisson.api.mapreduce.RCollectionMapReduce;
import org.redisson.client.RedisClient;
import org.redisson.client.codec.Codec;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.command.CommandAsyncExecutor;
import org.redisson.iterator.RedissonBaseIterator;
import org.redisson.mapreduce.RedissonCollectionMapReduce;
import org.redisson.misc.CompletableFutureWrapper;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.stream.Stream;
/**
* Distributed and concurrent implementation of {@link java.util.Set}
*
* @author Nikita Koksharov
*
* @param value
*/
public class RedissonSet extends RedissonExpirable implements RSet, ScanIterator {
RedissonClient redisson;
public RedissonSet(CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson) {
super(commandExecutor, name);
this.redisson = redisson;
}
public RedissonSet(Codec codec, CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson) {
super(codec, commandExecutor, name);
this.redisson = redisson;
}
@Override
public RCollectionMapReduce mapReduce() {
return new RedissonCollectionMapReduce(this, redisson, commandExecutor);
}
@Override
public int size() {
return get(sizeAsync());
}
@Override
public RFuture sizeAsync() {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SCARD_INT, getRawName());
}
@Override
public boolean isEmpty() {
return size() == 0;
}
@Override
public boolean contains(Object o) {
return get(containsAsync(o));
}
@Override
public RFuture containsAsync(Object o) {
String name = getRawName(o);
return commandExecutor.readAsync(name, codec, RedisCommands.SISMEMBER, name, encode(o));
}
@Override
public ScanResult scanIterator(String name, RedisClient client, String startPos, String pattern, int count) {
return get(scanIteratorAsync(name, client, startPos, pattern, count));
}
@Override
public Iterator iterator(int count) {
return iterator(null, count);
}
@Override
public Iterator iterator(String pattern) {
return iterator(pattern, 10);
}
@Override
public Iterator iterator(String pattern, int count) {
return new RedissonBaseIterator() {
@Override
protected ScanResult iterator(RedisClient client, String nextIterPos) {
return scanIterator(getRawName(), client, nextIterPos, pattern, count);
}
@Override
protected void remove(Object value) {
RedissonSet.this.remove((V) value);
}
};
}
@Override
public Iterator distributedIterator(final String pattern) {
String iteratorName = "__redisson_set_cursor_{" + getRawName() + "}";
return distributedIterator(iteratorName, pattern, 10);
}
@Override
public Iterator distributedIterator(final int count) {
String iteratorName = "__redisson_set_cursor_{" + getRawName() + "}";
return distributedIterator(iteratorName, null, count);
}
@Override
public Iterator distributedIterator(final String iteratorName, final String pattern, final int count) {
return new RedissonBaseIterator() {
@Override
protected ScanResult iterator(RedisClient client, String nextIterPos) {
return distributedScanIterator(iteratorName, pattern, count);
}
@Override
protected void remove(Object value) {
RedissonSet.this.remove((V) value);
}
};
}
private ScanResult distributedScanIterator(String iteratorName, String pattern, int count) {
return get(distributedScanIteratorAsync(iteratorName, pattern, count));
}
private RFuture> distributedScanIteratorAsync(String iteratorName, String pattern, int count) {
List args = new ArrayList<>(2);
if (pattern != null) {
args.add(pattern);
}
args.add(count);
return commandExecutor.evalWriteAsync(getRawName(), codec, RedisCommands.EVAL_SCAN,
"local cursor = redis.call('get', KEYS[2]); "
+ "if cursor ~= false then "
+ "cursor = tonumber(cursor); "
+ "else "
+ "cursor = 0;"
+ "end;"
+ "if cursor == -1 then "
+ "return {'0', {}}; "
+ "end;"
+ "local result; "
+ "if (#ARGV == 2) then "
+ "result = redis.call('sscan', KEYS[1], cursor, 'match', ARGV[1], 'count', ARGV[2]); "
+ "else "
+ "result = redis.call('sscan', KEYS[1], cursor, 'count', ARGV[1]); "
+ "end;"
+ "local next_cursor = result[1]"
+ "if next_cursor ~= \"0\" then "
+ "redis.call('setex', KEYS[2], 3600, next_cursor);"
+ "else "
+ "redis.call('setex', KEYS[2], 3600, -1);"
+ "end; "
+ "return result;",
Arrays.asList(getRawName(), iteratorName), args.toArray());
}
@Override
public Iterator iterator() {
return iterator(null);
}
@Override
public RFuture> readAllAsync() {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SMEMBERS, getRawName());
}
@Override
public Set readAll() {
return get(readAllAsync());
}
@Override
public Object[] toArray() {
Set res = (Set) get(readAllAsync());
return res.toArray();
}
@Override
public T[] toArray(T[] a) {
Set res = (Set) get(readAllAsync());
return res.toArray(a);
}
@Override
public boolean add(V e) {
return get(addAsync(e));
}
@Override
public RFuture addAsync(V e) {
String name = getRawName(e);
return commandExecutor.writeAsync(name, codec, RedisCommands.SADD_SINGLE, name, encode(e));
}
@Override
public V removeRandom() {
return get(removeRandomAsync());
}
@Override
public RFuture removeRandomAsync() {
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.SPOP_SINGLE, getRawName());
}
@Override
public Set removeRandom(int amount) {
return get(removeRandomAsync(amount));
}
@Override
public RFuture> removeRandomAsync(int amount) {
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.SPOP, getRawName(), amount);
}
@Override
public V random() {
return get(randomAsync());
}
@Override
public RFuture randomAsync() {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SRANDMEMBER_SINGLE, getRawName());
}
@Override
public Set random(int count) {
return get(randomAsync(count));
}
@Override
public RFuture> randomAsync(int count) {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SRANDMEMBER, getRawName(), count);
}
@Override
public RFuture removeAsync(Object o) {
String name = getRawName(o);
return commandExecutor.writeAsync(name, codec, RedisCommands.SREM_SINGLE, name, encode(o));
}
@Override
public boolean remove(Object value) {
return get(removeAsync((V) value));
}
@Override
public RFuture moveAsync(String destination, V member) {
String name = getRawName(member);
return commandExecutor.writeAsync(name, codec, RedisCommands.SMOVE, name, destination, encode(member));
}
@Override
public boolean move(String destination, V member) {
return get(moveAsync(destination, member));
}
@Override
public boolean containsAll(Collection> c) {
return get(containsAllAsync(c));
}
@Override
public RFuture containsAllAsync(Collection> c) {
if (c.isEmpty()) {
return new CompletableFutureWrapper<>(true);
}
String tempName = suffixName(getRawName(), "redisson_temp");
return commandExecutor.evalWriteAsync(getRawName(), codec, RedisCommands.EVAL_BOOLEAN,
"for i=1, #ARGV, 5000 do " +
"redis.call('sadd', KEYS[2], unpack(ARGV, i, math.min(i+4999, #ARGV))); " +
"end; " +
"local size = redis.call('sdiff', KEYS[2], KEYS[1]);"
+ "redis.call('del', KEYS[2]); "
+ "return #size == 0 and 1 or 0; ",
Arrays.asList(getRawName(), tempName), encode(c).toArray());
}
@Override
public boolean addAll(Collection extends V> c) {
return get(addAllAsync(c));
}
@Override
public RFuture addAllAsync(Collection extends V> c) {
if (c.isEmpty()) {
return new CompletableFutureWrapper<>(false);
}
List args = new ArrayList(c.size() + 1);
args.add(getRawName());
encode(args, c);
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.SADD_BOOL, args.toArray());
}
@Override
public RFuture addAllCountedAsync(Collection extends V> c) {
if (c.isEmpty()) {
return new CompletableFutureWrapper<>(0);
}
List args = new ArrayList<>(c.size() + 1);
args.add(getRawName());
encode(args, c);
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.SADD, args.toArray());
}
@Override
public int addAllCounted(Collection extends V> c) {
return get(addAllCountedAsync(c));
}
@Override
public boolean retainAll(Collection> c) {
return get(retainAllAsync(c));
}
@Override
public RFuture retainAllAsync(Collection> c) {
if (c.isEmpty()) {
return deleteAsync();
}
String tempName = suffixName(getRawName(), "redisson_temp");
return commandExecutor.evalWriteAsync(getRawName(), codec, RedisCommands.EVAL_BOOLEAN,
"for i=1, #ARGV, 5000 do " +
"redis.call('sadd', KEYS[2], unpack(ARGV, i, math.min(i+4999, #ARGV))); " +
"end; " +
"local prevSize = redis.call('scard', KEYS[1]); "
+ "local size = redis.call('sinterstore', KEYS[1], KEYS[1], KEYS[2]);"
+ "redis.call('del', KEYS[2]); "
+ "return size ~= prevSize and 1 or 0; ",
Arrays.asList(getRawName(), tempName),
encode(c).toArray());
}
@Override
public RFuture removeAllAsync(Collection> c) {
if (c.isEmpty()) {
return new CompletableFutureWrapper<>(false);
}
List args = new ArrayList(c.size() + 1);
args.add(getRawName());
encode(args, c);
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.SREM_SINGLE, args.toArray());
}
@Override
public int removeAllCounted(Collection extends V> c) {
return get(removeAllCountedAsync(c));
}
@Override
public RFuture removeAllCountedAsync(Collection extends V> c) {
if (c.isEmpty()) {
return new CompletableFutureWrapper<>(0);
}
List args = new ArrayList<>(c.size() + 1);
args.add(getRawName());
encode(args, c);
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.SREM, args.toArray());
}
@Override
public RFuture> containsEachAsync(Collection c) {
if (c.isEmpty()) {
return new CompletableFutureWrapper<>(Collections.emptyList());
}
List args = new ArrayList<>(c.size() + 1);
args.add(getRawName());
encode(args, c);
RFuture> future = commandExecutor.readAsync(getRawName(), codec, RedisCommands.SMISMEMBER, args.toArray());
List keysToCheck = new ArrayList<>(c);
CompletionStage> f = future.thenApply(res -> {
List containedKeys = new ArrayList<>();
for (int i = 0; i < res.size(); i++) {
if (res.get(i) == 1) {
containedKeys.add(keysToCheck.get(i));
}
}
return containedKeys;
});
return new CompletableFutureWrapper<>(f);
}
@Override
public boolean removeAll(Collection> c) {
return get(removeAllAsync(c));
}
@Override
public int union(String... names) {
return get(unionAsync(names));
}
@Override
public RFuture unionAsync(String... names) {
List args = new ArrayList<>(names.length + 1);
args.add(getRawName());
args.addAll(map(names));
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.SUNIONSTORE_INT, args.toArray());
}
@Override
public Set readUnion(String... names) {
return get(readUnionAsync(names));
}
@Override
public RFuture> readUnionAsync(String... names) {
List args = new ArrayList<>(names.length + 1);
args.add(getRawName());
args.addAll(map(names));
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SUNION, args.toArray());
}
@Override
public int diff(String... names) {
return get(diffAsync(names));
}
@Override
public RFuture diffAsync(String... names) {
List args = new ArrayList<>(names.length + 1);
args.add(getRawName());
args.addAll(map(names));
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.SDIFFSTORE_INT, args.toArray());
}
@Override
public Set readDiff(String... names) {
return get(readDiffAsync(names));
}
@Override
public RFuture> readDiffAsync(String... names) {
List args = new ArrayList<>(names.length + 1);
args.add(getRawName());
args.addAll(map(names));
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SDIFF, args.toArray());
}
@Override
public int intersection(String... names) {
return get(intersectionAsync(names));
}
@Override
public RFuture intersectionAsync(String... names) {
List args = new ArrayList<>(names.length + 1);
args.add(getRawName());
args.addAll(map(names));
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.SINTERSTORE_INT, args.toArray());
}
@Override
public Set readIntersection(String... names) {
return get(readIntersectionAsync(names));
}
@Override
public RFuture> readIntersectionAsync(String... names) {
List args = new ArrayList<>(names.length + 1);
args.add(getRawName());
args.addAll(map(names));
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SINTER, args.toArray());
}
@Override
public Integer countIntersection(String... names) {
return get(countIntersectionAsync(names));
}
@Override
public RFuture countIntersectionAsync(String... names) {
return countIntersectionAsync(0, names);
}
@Override
public Integer countIntersection(int limit, String... names) {
return get(countIntersectionAsync(limit, names));
}
@Override
public RFuture countIntersectionAsync(int limit, String... names) {
List args = new ArrayList<>(names.length + 1);
args.add(names.length + 1);
args.add(getRawName());
args.addAll(map(names));
if (limit > 0) {
args.add("LIMIT");
args.add(limit);
}
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.SINTERCARD_INT, args.toArray());
}
@Override
public void clear() {
delete();
}
@Override
@SuppressWarnings("AvoidInlineConditionals")
public String toString() {
Iterator it = iterator();
if (! it.hasNext())
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
V e = it.next();
sb.append(e == this ? "(this Collection)" : e);
if (! it.hasNext())
return sb.append(']').toString();
sb.append(',').append(' ');
}
}
@Override
public Set readSort(SortOrder order) {
return get(readSortAsync(order));
}
@Override
public RFuture> readSortAsync(SortOrder order) {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SORT_SET, getRawName(), order);
}
@Override
public Set readSort(SortOrder order, int offset, int count) {
return get(readSortAsync(order, offset, count));
}
@Override
public RFuture> readSortAsync(SortOrder order, int offset, int count) {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SORT_SET, getRawName(), "LIMIT", offset, count, order);
}
@Override
public Set readSort(String byPattern, SortOrder order) {
return get(readSortAsync(byPattern, order));
}
@Override
public RFuture> readSortAsync(String byPattern, SortOrder order) {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SORT_SET, getRawName(), "BY", byPattern, order);
}
@Override
public Set readSort(String byPattern, SortOrder order, int offset, int count) {
return get(readSortAsync(byPattern, order, offset, count));
}
@Override
public RFuture> readSortAsync(String byPattern, SortOrder order, int offset, int count) {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SORT_SET, getRawName(), "BY", byPattern, "LIMIT", offset, count, order);
}
@Override
public Collection readSort(String byPattern, List getPatterns, SortOrder order) {
return (Collection) get(readSortAsync(byPattern, getPatterns, order));
}
@Override
public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order) {
return readSortAsync(byPattern, getPatterns, order, -1, -1);
}
@Override
public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count) {
return (Collection) get(readSortAsync(byPattern, getPatterns, order, offset, count));
}
@Override
public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) {
return readSortAsync(byPattern, getPatterns, order, offset, count, false);
}
@Override
public Set readSortAlpha(SortOrder order) {
return get(readSortAlphaAsync(order));
}
@Override
public Set readSortAlpha(SortOrder order, int offset, int count) {
return get(readSortAlphaAsync(order, offset, count));
}
@Override
public Set readSortAlpha(String byPattern, SortOrder order) {
return get(readSortAlphaAsync(byPattern, order));
}
@Override
public Set readSortAlpha(String byPattern, SortOrder order, int offset, int count) {
return get(readSortAlphaAsync(byPattern, order, offset, count));
}
@Override
public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order) {
return (Collection) get(readSortAlphaAsync(byPattern, getPatterns, order));
}
@Override
public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order, int offset, int count) {
return (Collection) get(readSortAlphaAsync(byPattern, getPatterns, order, offset, count));
}
@Override
public RFuture> readSortAlphaAsync(SortOrder order) {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SORT_SET, getRawName(), "ALPHA", order);
}
@Override
public RFuture> readSortAlphaAsync(SortOrder order, int offset, int count) {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SORT_SET, getRawName(), "LIMIT", offset, count, "ALPHA", order);
}
@Override
public RFuture> readSortAlphaAsync(String byPattern, SortOrder order) {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SORT_SET, getRawName(), "BY", byPattern, "ALPHA", order);
}
@Override
public RFuture> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SORT_SET, getRawName(), "BY", byPattern, "LIMIT", offset, count, "ALPHA", order);
}
@Override
public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order) {
return readSortAlphaAsync(byPattern, getPatterns, order, -1, -1);
}
@Override
public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) {
return readSortAsync(byPattern, getPatterns, order, offset, count, true);
}
@Override
public int sortTo(String destName, SortOrder order) {
return get(sortToAsync(destName, order));
}
@Override
public RFuture sortToAsync(String destName, SortOrder order) {
return sortToAsync(destName, null, Collections.emptyList(), order, -1, -1);
}
@Override
public int sortTo(String destName, SortOrder order, int offset, int count) {
return get(sortToAsync(destName, order, offset, count));
}
@Override
public RFuture sortToAsync(String destName, SortOrder order, int offset, int count) {
return sortToAsync(destName, null, Collections.emptyList(), order, offset, count);
}
@Override
public int sortTo(String destName, String byPattern, SortOrder order, int offset, int count) {
return get(sortToAsync(destName, byPattern, order, offset, count));
}
@Override
public int sortTo(String destName, String byPattern, SortOrder order) {
return get(sortToAsync(destName, byPattern, order));
}
@Override
public RFuture sortToAsync(String destName, String byPattern, SortOrder order) {
return sortToAsync(destName, byPattern, Collections.emptyList(), order, -1, -1);
}
@Override
public RFuture sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count) {
return sortToAsync(destName, byPattern, Collections.emptyList(), order, offset, count);
}
@Override
public int sortTo(String destName, String byPattern, List getPatterns, SortOrder order) {
return get(sortToAsync(destName, byPattern, getPatterns, order));
}
@Override
public RFuture sortToAsync(String destName, String byPattern, List getPatterns, SortOrder order) {
return sortToAsync(destName, byPattern, getPatterns, order, -1, -1);
}
@Override
public int sortTo(String destName, String byPattern, List getPatterns, SortOrder order, int offset, int count) {
return get(sortToAsync(destName, byPattern, getPatterns, order, offset, count));
}
@Override
public RFuture sortToAsync(String destName, String byPattern, List getPatterns, SortOrder order, int offset, int count) {
List params = new ArrayList();
params.add(getRawName());
if (byPattern != null) {
params.add("BY");
params.add(byPattern);
}
if (offset != -1 && count != -1) {
params.add("LIMIT");
}
if (offset != -1) {
params.add(offset);
}
if (count != -1) {
params.add(count);
}
for (String pattern : getPatterns) {
params.add("GET");
params.add(pattern);
}
params.add(order);
params.add("STORE");
params.add(destName);
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.SORT_TO, params.toArray());
}
@Override
public boolean tryAdd(V... values) {
return get(tryAddAsync(values));
}
@Override
public List containsEach(Collection c) {
return get(containsEachAsync(c));
}
@Override
public RFuture tryAddAsync(V... values) {
return commandExecutor.evalWriteAsync(getRawName(), codec, RedisCommands.EVAL_BOOLEAN,
"for i, v in ipairs(ARGV) do " +
"if redis.call('sismember', KEYS[1], v) == 1 then " +
"return 0; " +
"end; " +
"end; " +
"for i=1, #ARGV, 5000 do " +
"redis.call('sadd', KEYS[1], unpack(ARGV, i, math.min(i+4999, #ARGV))); " +
"end; " +
"return 1; ",
Arrays.asList(getRawName()), encode(Arrays.asList(values)).toArray());
}
@Override
public RPermitExpirableSemaphore getPermitExpirableSemaphore(V value) {
String lockName = getLockByValue(value, "permitexpirablesemaphore");
return new RedissonPermitExpirableSemaphore(commandExecutor, lockName);
}
@Override
public RSemaphore getSemaphore(V value) {
String lockName = getLockByValue(value, "semaphore");
return new RedissonSemaphore(commandExecutor, lockName);
}
@Override
public RCountDownLatch getCountDownLatch(V value) {
String lockName = getLockByValue(value, "countdownlatch");
return new RedissonCountDownLatch(commandExecutor, lockName);
}
@Override
public RLock getFairLock(V value) {
String lockName = getLockByValue(value, "fairlock");
return new RedissonFairLock(commandExecutor, lockName);
}
@Override
public RLock getLock(V value) {
String lockName = getLockByValue(value, "lock");
return new RedissonLock(commandExecutor, lockName);
}
@Override
public RReadWriteLock getReadWriteLock(V value) {
String lockName = getLockByValue(value, "rw_lock");
return new RedissonReadWriteLock(commandExecutor, lockName);
}
@Override
public RFuture> scanIteratorAsync(String name, RedisClient client, String startPos,
String pattern, int count) {
if (pattern == null) {
return commandExecutor.readAsync(client, name, codec, RedisCommands.SSCAN, name, startPos, "COUNT", count);
}
return commandExecutor.readAsync(client, name, codec, RedisCommands.SSCAN, name, startPos, "MATCH", pattern, "COUNT", count);
}
private RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) {
List params = new ArrayList();
params.add(getRawName());
if (byPattern != null) {
params.add("BY");
params.add(byPattern);
}
if (offset != -1 && count != -1) {
params.add("LIMIT");
}
if (offset != -1) {
params.add(offset);
}
if (count != -1) {
params.add(count);
}
if (getPatterns != null) {
for (String pattern : getPatterns) {
params.add("GET");
params.add(pattern);
}
}
if (alpha) {
params.add("ALPHA");
}
if (order != null) {
params.add(order);
}
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.SORT_SET, params.toArray());
}
@Override
public Stream stream(int count) {
return toStream(iterator(count));
}
@Override
public Stream stream(String pattern, int count) {
return toStream(iterator(pattern, count));
}
@Override
public Stream stream(String pattern) {
return toStream(iterator(pattern));
}
@Override
public int addListener(ObjectListener listener) {
if (listener instanceof SetAddListener) {
return addListener("__keyevent@*:sadd", (SetAddListener) listener, SetAddListener::onAdd);
}
if (listener instanceof SetRemoveListener) {
return addListener("__keyevent@*:srem", (SetRemoveListener) listener, SetRemoveListener::onRemove);
}
if (listener instanceof SetRemoveRandomListener) {
return addListener("__keyevent@*:spop", (SetRemoveRandomListener) listener, SetRemoveRandomListener::onRandomRemove);
}
if (listener instanceof TrackingListener) {
return addTrackingListener((TrackingListener) listener);
}
return super.addListener(listener);
}
@Override
public RFuture addListenerAsync(ObjectListener listener) {
if (listener instanceof SetAddListener) {
return addListenerAsync("__keyevent@*:sadd", (SetAddListener) listener, SetAddListener::onAdd);
}
if (listener instanceof SetRemoveListener) {
return addListenerAsync("__keyevent@*:srem", (SetRemoveListener) listener, SetRemoveListener::onRemove);
}
if (listener instanceof SetRemoveRandomListener) {
return addListenerAsync("__keyevent@*:spop", (SetRemoveRandomListener) listener, SetRemoveRandomListener::onRandomRemove);
}
if (listener instanceof TrackingListener) {
return addTrackingListenerAsync((TrackingListener) listener);
}
return super.addListenerAsync(listener);
}
@Override
public void removeListener(int listenerId) {
removeTrackingListener(listenerId);
removeListener(listenerId, "__keyevent@*:sadd", "__keyevent@*:srem", "__keyevent@*:spop");
super.removeListener(listenerId);
}
@Override
public RFuture removeListenerAsync(int listenerId) {
RFuture f1 = removeTrackingListenerAsync(listenerId);
RFuture f2 = removeListenerAsync(listenerId,
"__keyevent@*:sadd", "__keyevent@*:srem", "__keyevent@*:spop");
return new CompletableFutureWrapper<>(CompletableFuture.allOf(f1.toCompletableFuture(), f2.toCompletableFuture()));
}
}