@Override public Flux<TypedTuple<V>> rangeByScoreWithScores(K key, Range<Double> range, Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); Assert.notNull(limit, "Limit must not be null!"); return createFlux( connection -> connection.zRangeByScoreWithScores(rawKey(key), range, limit).map(this::readTypedTuple)); }
@Override public Flux<TypedTuple<V>> reverseRangeByScoreWithScores(K key, Range<Double> range, Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); Assert.notNull(limit, "Limit must not be null!"); return createFlux( connection -> connection.zRevRangeByScoreWithScores(rawKey(key), range, limit).map(this::readTypedTuple)); }
@Override public Flux<V> reverseRangeByLex(K key, Range<String> range, Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); Assert.notNull(limit, "Limit must not be null!"); return createFlux(connection -> connection.zRevRangeByLex(rawKey(key), range, limit).map(this::readValue)); }
@Override public Flux<TypedTuple<V>> rangeByScoreWithScores(K key, Range<Double> range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); return createFlux(connection -> connection.zRangeByScoreWithScores(rawKey(key), range).map(this::readTypedTuple)); }
@Override public Flux<V> rangeByScore(K key, Range<Double> range, Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); return createFlux(connection -> connection.zRangeByScore(rawKey(key), range, limit).map(this::readValue)); }
@Override public Flux<V> reverseRange(K key, Range<Long> range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); return createFlux(connection -> connection.zRevRange(rawKey(key), range).map(this::readValue)); }
@Override public Flux<TypedTuple<V>> reverseRangeWithScores(K key, Range<Long> range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); return createFlux(connection -> connection.zRevRangeWithScores(rawKey(key), range).map(this::readTypedTuple)); }
@Override public Flux<TypedTuple<V>> rangeWithScores(K key, Range<Long> range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); return createFlux(connection -> connection.zRangeWithScores(rawKey(key), range).map(this::readTypedTuple)); }
@Override public Flux<V> rangeByScore(K key, Range<Double> range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); return createFlux(connection -> connection.zRangeByScore(rawKey(key), range).map(this::readValue)); }
@Override public Flux<V> reverseRangeByScore(K key, Range<Double> range, Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); return createFlux(connection -> connection.zRevRangeByScore(rawKey(key), range, limit).map(this::readValue)); }
@Override public Flux<V> reverseRangeByScore(K key, Range<Double> range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); return createFlux(connection -> connection.zRevRangeByScore(rawKey(key), range).map(this::readValue)); }
@Override public Mono<Long> removeRange(K key, Range<Long> range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); return createMono(connection -> connection.zRemRangeByRank(rawKey(key), range)); }
@Override public Mono<Long> count(K key, Range<Double> range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); return createMono(connection -> connection.zCount(rawKey(key), range)); }
@Override public Mono<Long> size(K key) { Assert.notNull(key, "Key must not be null!"); return createMono(connection -> connection.zCard(rawKey(key))); }
@Override public Mono<Long> intersectAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate, Weights weights) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(otherKeys, "Other keys must not be null!"); Assert.notNull(destKey, "Destination key must not be null!"); Assert.notNull(aggregate, "Aggregate must not be null!"); Assert.notNull(weights, "Weights must not be null!"); return createMono(connection -> Flux.fromIterable(getKeys(key, otherKeys)) // .map(this::rawKey) // .collectList() // .flatMap(serialized -> connection.zInterStore(rawKey(destKey), serialized, weights, aggregate))); }
@Override public Mono<Double> incrementScore(K key, V value, double delta) { Assert.notNull(key, "Key must not be null!"); return createMono(connection -> connection.zIncrBy(rawKey(key), delta, rawValue(value))); }
@Override @SuppressWarnings("unchecked") public Mono<Long> reverseRank(K key, Object o) { Assert.notNull(key, "Key must not be null!"); return createMono(connection -> connection.zRevRank(rawKey(key), rawValue((V) o))); }
@Override @SuppressWarnings("unchecked") public Mono<Double> score(K key, Object o) { Assert.notNull(key, "Key must not be null!"); return createMono(connection -> connection.zScore(rawKey(key), rawValue((V) o))); }
@Override @SuppressWarnings("unchecked") public Mono<Long> rank(K key, Object o) { Assert.notNull(key, "Key must not be null!"); return createMono(connection -> connection.zRank(rawKey(key), rawValue((V) o))); }
@Override public Mono<Long> addAll(K key, Collection<? extends TypedTuple<V>> tuples) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(tuples, "Key must not be null!"); return createMono(connection -> Flux.fromIterable(tuples) // .map(t -> new DefaultTuple(ByteUtils.getBytes(rawValue(t.getValue())), t.getScore())) // .collectList() // .flatMap(serialized -> connection.zAdd(rawKey(key), serialized))); }