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.
com.redis.lettucemod.RedisModulesReactiveCommandsImpl Maven / Gradle / Ivy
package com.redis.lettucemod;
import java.util.Map;
import com.redis.lettucemod.api.StatefulRedisModulesConnection;
import com.redis.lettucemod.api.reactive.RedisModulesReactiveCommands;
import com.redis.lettucemod.bloom.BloomCommandBuilder;
import com.redis.lettucemod.bloom.BloomFilterInfo;
import com.redis.lettucemod.bloom.BloomFilterInfoType;
import com.redis.lettucemod.bloom.BloomFilterInsertOptions;
import com.redis.lettucemod.bloom.BloomFilterReserveOptions;
import com.redis.lettucemod.bloom.CmsInfo;
import com.redis.lettucemod.bloom.CuckooFilter;
import com.redis.lettucemod.bloom.CuckooFilterInsertOptions;
import com.redis.lettucemod.bloom.CuckooFilterReserveOptions;
import com.redis.lettucemod.bloom.LongScoredValue;
import com.redis.lettucemod.bloom.TDigestInfo;
import com.redis.lettucemod.bloom.TDigestMergeOptions;
import com.redis.lettucemod.bloom.TopKInfo;
import com.redis.lettucemod.gears.Execution;
import com.redis.lettucemod.gears.ExecutionDetails;
import com.redis.lettucemod.gears.ExecutionMode;
import com.redis.lettucemod.gears.GearsCommandBuilder;
import com.redis.lettucemod.gears.Registration;
import com.redis.lettucemod.json.ArrpopOptions;
import com.redis.lettucemod.json.GetOptions;
import com.redis.lettucemod.json.JSONCommandBuilder;
import com.redis.lettucemod.json.SetMode;
import com.redis.lettucemod.json.Slice;
import com.redis.lettucemod.output.ExecutionResults;
import com.redis.lettucemod.search.AggregateOptions;
import com.redis.lettucemod.search.AggregateResults;
import com.redis.lettucemod.search.AggregateWithCursorResults;
import com.redis.lettucemod.search.CursorOptions;
import com.redis.lettucemod.search.Field;
import com.redis.lettucemod.search.SearchCommandBuilder;
import com.redis.lettucemod.search.SearchOptions;
import com.redis.lettucemod.search.SearchResults;
import com.redis.lettucemod.search.Suggestion;
import com.redis.lettucemod.search.SuggetOptions;
import com.redis.lettucemod.timeseries.AddOptions;
import com.redis.lettucemod.timeseries.AlterOptions;
import com.redis.lettucemod.timeseries.CreateOptions;
import com.redis.lettucemod.timeseries.CreateRuleOptions;
import com.redis.lettucemod.timeseries.GetResult;
import com.redis.lettucemod.timeseries.IncrbyOptions;
import com.redis.lettucemod.timeseries.KeySample;
import com.redis.lettucemod.timeseries.MGetOptions;
import com.redis.lettucemod.timeseries.MRangeOptions;
import com.redis.lettucemod.timeseries.RangeOptions;
import com.redis.lettucemod.timeseries.RangeResult;
import com.redis.lettucemod.timeseries.Sample;
import com.redis.lettucemod.timeseries.TimeRange;
import com.redis.lettucemod.timeseries.TimeSeriesCommandBuilder;
import io.lettuce.core.KeyValue;
import io.lettuce.core.RedisReactiveCommandsImpl;
import io.lettuce.core.Value;
import io.lettuce.core.codec.RedisCodec;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@SuppressWarnings("unchecked")
public class RedisModulesReactiveCommandsImpl extends RedisReactiveCommandsImpl
implements RedisModulesReactiveCommands {
private final StatefulRedisModulesConnection connection;
private final TimeSeriesCommandBuilder timeSeriesCommandBuilder;
private final GearsCommandBuilder gearsCommandBuilder;
private final SearchCommandBuilder searchCommandBuilder;
private final JSONCommandBuilder jsonCommandBuilder;
private final BloomCommandBuilder bloomCommandBuilder;
public RedisModulesReactiveCommandsImpl(StatefulRedisModulesConnection connection, RedisCodec codec) {
super(connection, codec);
this.connection = connection;
this.gearsCommandBuilder = new GearsCommandBuilder<>(codec);
this.timeSeriesCommandBuilder = new TimeSeriesCommandBuilder<>(codec);
this.searchCommandBuilder = new SearchCommandBuilder<>(codec);
this.jsonCommandBuilder = new JSONCommandBuilder<>(codec);
this.bloomCommandBuilder = new BloomCommandBuilder<>(codec);
}
@Override
public StatefulRedisModulesConnection getStatefulConnection() {
return connection;
}
@Override
public Mono rgPyexecute(String function, V... requirements) {
return createMono(() -> gearsCommandBuilder.pyExecute(function, requirements));
}
@Override
public Mono rgPyexecuteUnblocking(String function, V... requirements) {
return createMono(() -> gearsCommandBuilder.pyExecuteUnblocking(function, requirements));
}
@Override
public Flux rgTrigger(String trigger, V... args) {
return createDissolvingFlux(() -> gearsCommandBuilder.trigger(trigger, args));
}
@Override
public Mono rgUnregister(String id) {
return createMono(() -> gearsCommandBuilder.unregister(id));
}
@Override
public Mono rgAbortexecution(String id) {
return createMono(() -> gearsCommandBuilder.abortExecution(id));
}
@Override
public Flux rgConfigget(K... keys) {
return createDissolvingFlux(() -> gearsCommandBuilder.configGet(keys));
}
@Override
public Flux rgConfigset(Map map) {
return createDissolvingFlux(() -> gearsCommandBuilder.configSet(map));
}
@Override
public Mono rgDropexecution(String id) {
return createMono(() -> gearsCommandBuilder.dropExecution(id));
}
@Override
public Flux rgDumpexecutions() {
return createDissolvingFlux(gearsCommandBuilder::dumpExecutions);
}
@Override
public Flux rgDumpregistrations() {
return createDissolvingFlux(gearsCommandBuilder::dumpRegistrations);
}
@Override
public Mono rgGetexecution(String id) {
return createMono(() -> gearsCommandBuilder.getExecution(id));
}
@Override
public Mono rgGetexecution(String id, ExecutionMode mode) {
return createMono(() -> gearsCommandBuilder.getExecution(id, mode));
}
@Override
public Mono rgGetresults(String id) {
return createMono(() -> gearsCommandBuilder.getResults(id));
}
@Override
public Mono rgGetresultsblocking(String id) {
return createMono(() -> gearsCommandBuilder.getResultsBlocking(id));
}
@Override
public Mono tsCreate(K key, CreateOptions options) {
return createMono(() -> timeSeriesCommandBuilder.create(key, options));
}
@Override
public Mono tsAlter(K key, AlterOptions options) {
return createMono(() -> timeSeriesCommandBuilder.alter(key, options));
}
@Override
public Mono tsAdd(K key, Sample sample) {
return createMono(() -> timeSeriesCommandBuilder.add(key, sample));
}
@Override
public Mono tsAdd(K key, Sample sample, AddOptions options) {
return createMono(() -> timeSeriesCommandBuilder.add(key, sample, options));
}
@Override
public Mono tsIncrby(K key, double value) {
return createMono(() -> timeSeriesCommandBuilder.incrby(key, value, null));
}
@Override
public Mono tsIncrby(K key, double value, IncrbyOptions options) {
return createMono(() -> timeSeriesCommandBuilder.incrby(key, value, options));
}
@Override
public Mono tsDecrby(K key, double value) {
return createMono(() -> timeSeriesCommandBuilder.decrby(key, value, null));
}
@Override
public Mono tsDecrby(K key, double value, IncrbyOptions options) {
return createMono(() -> timeSeriesCommandBuilder.decrby(key, value, options));
}
@Override
public Flux tsMadd(KeySample... samples) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.madd(samples));
}
@Override
public Mono tsCreaterule(K sourceKey, K destKey, CreateRuleOptions options) {
return createMono(() -> timeSeriesCommandBuilder.createRule(sourceKey, destKey, options));
}
@Override
public Mono tsDeleterule(K sourceKey, K destKey) {
return createMono(() -> timeSeriesCommandBuilder.deleteRule(sourceKey, destKey));
}
@Override
public Flux tsRange(K key, TimeRange range) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.range(key, range));
}
@Override
public Flux tsRange(K key, TimeRange range, RangeOptions options) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.range(key, range, options));
}
@Override
public Flux tsRevrange(K key, TimeRange range) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.revrange(key, range));
}
@Override
public Flux tsRevrange(K key, TimeRange range, RangeOptions options) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.revrange(key, range, options));
}
@Override
public Flux> tsMrange(TimeRange range) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.mrange(range));
}
@Override
public Flux> tsMrange(TimeRange range, MRangeOptions options) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.mrange(range, options));
}
@Override
public Flux> tsMrevrange(TimeRange range) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.mrevrange(range));
}
@Override
public Flux> tsMrevrange(TimeRange range, MRangeOptions options) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.mrevrange(range, options));
}
@Override
public Mono tsGet(K key) {
return createMono(() -> timeSeriesCommandBuilder.get(key));
}
@Override
public Flux> tsMget(MGetOptions options) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.mget(options));
}
@Override
public Flux> tsMget(V... filters) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.mget(filters));
}
@Override
public Flux> tsMgetWithLabels(V... filters) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.mgetWithLabels(filters));
}
@Override
public Flux tsInfo(K key) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.info(key, false));
}
@Override
public Flux tsInfoDebug(K key) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.info(key, true));
}
@Override
public Flux tsQueryIndex(V... filters) {
return createDissolvingFlux(() -> timeSeriesCommandBuilder.queryIndex(filters));
}
@Override
public Mono tsDel(K key, TimeRange timeRange) {
return createMono(() -> timeSeriesCommandBuilder.tsDel(key, timeRange));
}
@Override
public Mono ftCreate(K index, Field... fields) {
return ftCreate(index, null, fields);
}
@Override
public Mono ftCreate(K index, com.redis.lettucemod.search.CreateOptions options, Field... fields) {
return createMono(() -> searchCommandBuilder.create(index, options, fields));
}
@Override
public Mono ftDropindex(K index) {
return createMono(() -> searchCommandBuilder.dropIndex(index, false));
}
@Override
public Mono ftDropindexDeleteDocs(K index) {
return createMono(() -> searchCommandBuilder.dropIndex(index, true));
}
@Override
public Flux ftInfo(K index) {
return createDissolvingFlux(() -> searchCommandBuilder.info(index));
}
@Override
public Mono> ftSearch(K index, V query) {
return createMono(() -> searchCommandBuilder.search(index, query, null));
}
@Override
public Mono> ftSearch(K index, V query, SearchOptions options) {
return createMono(() -> searchCommandBuilder.search(index, query, options));
}
@Override
public Mono> ftAggregate(K index, V query) {
return createMono(() -> searchCommandBuilder.aggregate(index, query, null));
}
@Override
public Mono> ftAggregate(K index, V query, AggregateOptions options) {
return createMono(() -> searchCommandBuilder.aggregate(index, query, options));
}
@Override
public Mono> ftAggregate(K index, V query, CursorOptions cursor) {
return createMono(() -> searchCommandBuilder.aggregate(index, query, cursor, null));
}
@Override
public Mono> ftAggregate(K index, V query, CursorOptions cursor,
AggregateOptions options) {
return createMono(() -> searchCommandBuilder.aggregate(index, query, cursor, options));
}
@Override
public Mono> ftCursorRead(K index, long cursor) {
return createMono(() -> searchCommandBuilder.cursorRead(index, cursor, null));
}
@Override
public Mono> ftCursorRead(K index, long cursor, long count) {
return createMono(() -> searchCommandBuilder.cursorRead(index, cursor, count));
}
@Override
public Mono ftCursorDelete(K index, long cursor) {
return createMono(() -> searchCommandBuilder.cursorDelete(index, cursor));
}
@Override
public Mono ftSugadd(K key, Suggestion suggestion) {
return createMono(() -> searchCommandBuilder.sugadd(key, suggestion));
}
@Override
public Mono ftSugaddIncr(K key, Suggestion suggestion) {
return createMono(() -> searchCommandBuilder.sugaddIncr(key, suggestion));
}
@Override
public Flux> ftSugget(K key, V prefix) {
return createDissolvingFlux(() -> searchCommandBuilder.sugget(key, prefix));
}
@Override
public Flux> ftSugget(K key, V prefix, SuggetOptions options) {
return createDissolvingFlux(() -> searchCommandBuilder.sugget(key, prefix, options));
}
@Override
public Mono ftSugdel(K key, V string) {
return createMono(() -> searchCommandBuilder.sugdel(key, string));
}
@Override
public Mono ftSuglen(K key) {
return createMono(() -> searchCommandBuilder.suglen(key));
}
@Override
public Mono ftAlter(K index, Field field) {
return createMono(() -> searchCommandBuilder.alter(index, field));
}
@Override
public Mono ftAliasadd(K name, K index) {
return createMono(() -> searchCommandBuilder.aliasAdd(name, index));
}
@Override
public Mono ftAliasupdate(K name, K index) {
return createMono(() -> searchCommandBuilder.aliasUpdate(name, index));
}
@Override
public Mono ftAliasdel(K name) {
return createMono(() -> searchCommandBuilder.aliasDel(name));
}
@Override
public Flux ftList() {
return createDissolvingFlux(searchCommandBuilder::list);
}
@Override
public Flux ftTagvals(K index, K field) {
return createDissolvingFlux(() -> searchCommandBuilder.tagVals(index, field));
}
@Override
public Mono ftDictadd(K dict, V... terms) {
return createMono(() -> searchCommandBuilder.dictadd(dict, terms));
}
@Override
public Mono ftDictdel(K dict, V... terms) {
return createMono(() -> searchCommandBuilder.dictdel(dict, terms));
}
@Override
public Flux ftDictdump(K dict) {
return createDissolvingFlux(() -> searchCommandBuilder.dictdump(dict));
}
@Override
public Flux> topKAdd(K key, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.topKAdd(key, items));
}
@Override
public Flux> topKIncrBy(K key, LongScoredValue... itemIncrements) {
return createDissolvingFlux(() -> bloomCommandBuilder.topKIncrBy(key, itemIncrements));
}
@Override
public Mono topKInfo(K key) {
return createMono(() -> bloomCommandBuilder.topKInfo(key));
}
@Override
public Flux topKList(K key) {
return createDissolvingFlux(() -> bloomCommandBuilder.topKList(key));
}
@Override
public Flux> topKListWithScores(K key) {
return createDissolvingFlux(() -> bloomCommandBuilder.topKListWithScores(key));
}
@Override
public Flux topKQuery(K key, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.topKQuery(key, items));
}
@Override
public Mono topKReserve(K key, long k) {
return createMono(() -> bloomCommandBuilder.topKReserve(key, k));
}
@Override
public Mono topKReserve(K key, long k, long width, long depth, double decay) {
return createMono(() -> bloomCommandBuilder.topKReserve(key, k, width, depth, decay));
}
@Override
public Mono tDigestAdd(K key, double... values) {
return createMono(() -> bloomCommandBuilder.tDigestAdd(key, values));
}
@Override
public Flux tDigestByRank(K key, long... ranks) {
return createDissolvingFlux(() -> bloomCommandBuilder.tDigestByRank(key, ranks));
}
@Override
public Flux tDigestByRevRank(K key, long... revRanks) {
return createDissolvingFlux(() -> bloomCommandBuilder.tDigestByRevRank(key, revRanks));
}
@Override
public Flux tDigestCdf(K key, double... values) {
return createDissolvingFlux(() -> bloomCommandBuilder.tDigestCdf(key, values));
}
@Override
public Mono tDigestCreate(K key) {
return createMono(() -> bloomCommandBuilder.tDigestCreate(key));
}
@Override
public Mono tDigestCreate(K key, long compression) {
return createMono(() -> bloomCommandBuilder.tDigestCreate(key, compression));
}
@Override
public Mono tDigestInfo(K key) {
return createMono(() -> bloomCommandBuilder.tDigestInfo(key));
}
@Override
public Mono tDigestMax(K key) {
return createMono(() -> bloomCommandBuilder.tDigestMax(key));
}
@Override
public Mono tDigestMerge(K destinationKey, K... sourceKeys) {
return createMono(() -> bloomCommandBuilder.tDigestMerge(destinationKey, sourceKeys));
}
@Override
public Mono tDigestMerge(K destinationKey, TDigestMergeOptions options, K... sourceKeys) {
return createMono(() -> bloomCommandBuilder.tDigestMerge(destinationKey, options, sourceKeys));
}
@Override
public Mono tDigestMin(K key) {
return createMono(() -> bloomCommandBuilder.tDigestMin(key));
}
@Override
public Flux tDigestQuantile(K key, double... quantiles) {
return createDissolvingFlux(() -> bloomCommandBuilder.tDigestQuantile(key, quantiles));
}
@Override
public Flux tDigestRank(K key, double... values) {
return createDissolvingFlux(() -> bloomCommandBuilder.tDigestRank(key, values));
}
@Override
public Mono tDigestReset(K key) {
return createMono(() -> bloomCommandBuilder.tDigestReset(key));
}
@Override
public Flux tDigestRevRank(K key, double... values) {
return createDissolvingFlux(() -> bloomCommandBuilder.tDigestRevRank(key, values));
}
@Override
public Mono tDigestTrimmedMean(K key, double lowCutQuantile, double highCutQuantile) {
return createMono(() -> bloomCommandBuilder.tDigestTrimmedMean(key, lowCutQuantile, highCutQuantile));
}
@Override
public Mono jsonDel(K key) {
return jsonDel(key, null);
}
@Override
public Mono jsonDel(K key, String path) {
return createMono(() -> jsonCommandBuilder.del(key, path));
}
@Override
public Mono jsonGet(K key, K... paths) {
return jsonGet(key, null, paths);
}
@Override
public Mono jsonGet(K key, GetOptions options, K... paths) {
return createMono(() -> jsonCommandBuilder.get(key, options, paths));
}
@Override
public Flux> jsonMget(String path, K... keys) {
return createDissolvingFlux(() -> jsonCommandBuilder.mgetKeyValue(path, keys));
}
public Flux> jsonMget(String path, Iterable keys) {
return createDissolvingFlux(() -> jsonCommandBuilder.mgetKeyValue(path, keys));
}
@Override
public Mono jsonSet(K key, String path, V json) {
return jsonSet(key, path, json, null);
}
@Override
public Mono jsonSet(K key, String path, V json, SetMode mode) {
return createMono(() -> jsonCommandBuilder.set(key, path, json, mode));
}
@Override
public Mono jsonMerge(K key, String path, V json) {
return createMono(() -> jsonCommandBuilder.merge(key, path, json));
}
@Override
public Mono jsonType(K key) {
return jsonType(key, null);
}
@Override
public Mono jsonType(K key, String path) {
return createMono(() -> jsonCommandBuilder.type(key, path));
}
@Override
public Mono jsonNumincrby(K key, String path, double number) {
return createMono(() -> jsonCommandBuilder.numIncrBy(key, path, number));
}
@Override
public Mono jsonNummultby(K key, String path, double number) {
return createMono(() -> jsonCommandBuilder.numMultBy(key, path, number));
}
@Override
public Mono jsonStrappend(K key, V json) {
return jsonStrappend(key, null, json);
}
@Override
public Mono jsonStrappend(K key, String path, V json) {
return createMono(() -> jsonCommandBuilder.strAppend(key, path, json));
}
@Override
public Mono jsonStrlen(K key, String path) {
return createMono(() -> jsonCommandBuilder.strLen(key, path));
}
@Override
public Mono jsonArrappend(K key, String path, V... jsons) {
return createMono(() -> jsonCommandBuilder.arrAppend(key, path, jsons));
}
@Override
public Mono jsonArrindex(K key, String path, V scalar) {
return jsonArrindex(key, path, scalar, null);
}
@Override
public Mono jsonArrindex(K key, String path, V scalar, Slice slice) {
return createMono(() -> jsonCommandBuilder.arrIndex(key, path, scalar, slice));
}
@Override
public Mono jsonArrinsert(K key, String path, long index, V... jsons) {
return createMono(() -> jsonCommandBuilder.arrInsert(key, path, index, jsons));
}
@Override
public Mono jsonArrlen(K key) {
return jsonArrlen(key, null);
}
@Override
public Mono jsonArrlen(K key, String path) {
return createMono(() -> jsonCommandBuilder.arrLen(key, path));
}
@Override
public Mono jsonArrpop(K key) {
return jsonArrpop(key, null);
}
@Override
public Mono jsonArrpop(K key, ArrpopOptions options) {
return createMono(() -> jsonCommandBuilder.arrPop(key, options));
}
@Override
public Mono jsonArrtrim(K key, String path, long start, long stop) {
return createMono(() -> jsonCommandBuilder.arrTrim(key, path, start, stop));
}
@Override
public Flux jsonObjkeys(K key) {
return jsonObjkeys(key, null);
}
@Override
public Flux jsonObjkeys(K key, String path) {
return createDissolvingFlux(() -> jsonCommandBuilder.objKeys(key, path));
}
@Override
public Mono jsonObjlen(K key) {
return jsonObjlen(key, null);
}
@Override
public Mono jsonObjlen(K key, String path) {
return createMono(() -> jsonCommandBuilder.objLen(key, path));
}
@Override
public Mono bfAdd(K key, V item) {
return createMono(() -> bloomCommandBuilder.bfAdd(key, item));
}
@Override
public Mono bfCard(K key) {
return createMono(() -> bloomCommandBuilder.bfCard(key));
}
@Override
public Mono bfExists(K key, V item) {
return createMono(() -> bloomCommandBuilder.bfExists(key, item));
}
@Override
public Mono bfInfo(K key) {
return createMono(() -> bloomCommandBuilder.bfInfo(key));
}
@Override
public Mono bfInfo(K key, BloomFilterInfoType infoType) {
return createMono(() -> bloomCommandBuilder.bfInfo(key, infoType));
}
@Override
public Flux bfInsert(K key, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.bfInsert(key, items));
}
@Override
public Flux bfInsert(K key, BloomFilterInsertOptions options, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.bfInsert(key, options, items));
}
@Override
public Flux bfMAdd(K key, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.bfMAdd(key, items));
}
@Override
public Flux bfMExists(K key, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.bfMExists(key, items));
}
@Override
public Mono bfReserve(K key, double errorRate, long capacity) {
return bfReserve(key, errorRate, capacity, null);
}
@Override
public Mono bfReserve(K key, double errorRate, long capacity, BloomFilterReserveOptions options) {
return createMono(() -> bloomCommandBuilder.bfReserve(key, errorRate, capacity, options));
}
@Override
public Mono cfAdd(K key, V item) {
return createMono(() -> bloomCommandBuilder.cfAdd(key, item));
}
@Override
public Mono cfAddNx(K key, V item) {
return createMono(() -> bloomCommandBuilder.cfAddNx(key, item));
}
@Override
public Mono cfCount(K key, V item) {
return createMono(() -> bloomCommandBuilder.cfCount(key, item));
}
@Override
public Mono cfDel(K key, V item) {
return createMono(() -> bloomCommandBuilder.cfDel(key, item));
}
@Override
public Mono cfExists(K key, V item) {
return createMono(() -> bloomCommandBuilder.cfExists(key, item));
}
@Override
public Mono cfInfo(K key) {
return createMono(() -> bloomCommandBuilder.cfInfo(key));
}
@Override
public Flux cfInsert(K key, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.cfInsert(key, items));
}
@Override
public Flux cfInsert(K key, CuckooFilterInsertOptions options, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.cfInsert(key, items, options));
}
@Override
public Flux cfInsertNx(K key, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.cfInsertNx(key, items));
}
@Override
public Flux cfInsertNx(K key, CuckooFilterInsertOptions options, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.cfInsertNx(key, items, options));
}
@Override
public Flux cfMExists(K key, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.cfMExists(key, items));
}
@Override
public Mono cfReserve(K key, long capacity) {
return cfReserve(key, capacity, null);
}
@Override
public Mono cfReserve(K key, long capacity, CuckooFilterReserveOptions options) {
return createMono(() -> bloomCommandBuilder.cfReserve(key, capacity, options));
}
@Override
public Mono cmsIncrBy(K key, V item, long increment) {
return createMono(() -> bloomCommandBuilder.cmsIncrBy(key, item, increment));
}
@Override
public Flux cmsIncrBy(K key, LongScoredValue... itemIncrements) {
return createDissolvingFlux(() -> bloomCommandBuilder.cmsIncrBy(key, itemIncrements));
}
@Override
public Mono cmsInitByProb(K key, double error, double probability) {
return createMono(() -> bloomCommandBuilder.cmsInitByProb(key, error, probability));
}
@Override
public Mono cmsInitByDim(K key, long width, long depth) {
return createMono(() -> bloomCommandBuilder.cmsInitByDim(key, width, depth));
}
@Override
public Flux cmsQuery(K key, V... items) {
return createDissolvingFlux(() -> bloomCommandBuilder.cmsQuery(key, items));
}
@Override
public Mono cmsMerge(K destKey, K... keys) {
return createMono(() -> bloomCommandBuilder.cmsMerge(destKey, keys));
}
@Override
public Mono cmsMerge(K destKey, LongScoredValue... sourceKeyWeights) {
return createMono(() -> bloomCommandBuilder.cmsMerge(destKey, sourceKeyWeights));
}
@Override
public Mono cmsInfo(K key) {
return createMono(() -> bloomCommandBuilder.cmsInfo(key));
}
}
