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.redislabs.mesclun.RedisModulesReactiveCommandsImpl Maven / Gradle / Ivy
package com.redislabs.mesclun;
import com.redislabs.mesclun.api.reactive.RedisModulesReactiveCommands;
import com.redislabs.mesclun.api.StatefulRedisModulesConnection;
import com.redislabs.mesclun.gears.*;
import com.redislabs.mesclun.gears.output.ExecutionResults;
import com.redislabs.mesclun.search.*;
import com.redislabs.mesclun.timeseries.Aggregation;
import com.redislabs.mesclun.timeseries.CreateOptions;
import com.redislabs.mesclun.timeseries.Label;
import com.redislabs.mesclun.timeseries.RedisTimeSeriesCommandBuilder;
import io.lettuce.core.RedisReactiveCommandsImpl;
import io.lettuce.core.codec.RedisCodec;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.Map;
@SuppressWarnings("unchecked")
public class RedisModulesReactiveCommandsImpl extends RedisReactiveCommandsImpl implements RedisModulesReactiveCommands {
private final StatefulRedisModulesConnection connection;
private final RedisTimeSeriesCommandBuilder timeSeriesCommandBuilder;
private final RedisGearsCommandBuilder gearsCommandBuilder;
private final RediSearchCommandBuilder searchCommandBuilder;
public RedisModulesReactiveCommandsImpl(StatefulRedisModulesConnection connection, RedisCodec codec) {
super(connection, codec);
this.connection = connection;
this.gearsCommandBuilder = new RedisGearsCommandBuilder<>(codec);
this.timeSeriesCommandBuilder = new RedisTimeSeriesCommandBuilder<>(codec);
this.searchCommandBuilder = new RediSearchCommandBuilder<>(codec);
}
@Override
public StatefulRedisModulesConnection getStatefulConnection() {
return connection;
}
@Override
public Mono pyExecute(String function, V... requirements) {
return createMono(() -> gearsCommandBuilder.pyExecute(function, requirements));
}
@Override
public Mono pyExecuteUnblocking(String function, V... requirements) {
return createMono(() -> gearsCommandBuilder.pyExecuteUnblocking(function, requirements));
}
@Override
public Flux trigger(String trigger, V... args) {
return createDissolvingFlux(() -> gearsCommandBuilder.trigger(trigger, args));
}
@Override
public Mono unregister(String id) {
return createMono(() -> gearsCommandBuilder.unregister(id));
}
@Override
public Mono abortExecution(String id) {
return createMono(() -> gearsCommandBuilder.abortExecution(id));
}
@Override
public Flux configGet(K... keys) {
return createDissolvingFlux(() -> gearsCommandBuilder.configGet(keys));
}
@Override
public Flux configSet(Map map) {
return createDissolvingFlux(() -> gearsCommandBuilder.configSet(map));
}
@Override
public Mono dropExecution(String id) {
return createMono(() -> gearsCommandBuilder.dropExecution(id));
}
@Override
public Flux dumpExecutions() {
return createDissolvingFlux(gearsCommandBuilder::dumpExecutions);
}
@Override
public Flux dumpRegistrations() {
return createDissolvingFlux(gearsCommandBuilder::dumpRegistrations);
}
@Override
public Mono getExecution(String id) {
return createMono(() -> gearsCommandBuilder.getExecution(id));
}
@Override
public Mono getExecution(String id, ExecutionMode mode) {
return createMono(() -> gearsCommandBuilder.getExecution(id, mode));
}
@Override
public Mono getResults(String id) {
return createMono(() -> gearsCommandBuilder.getResults(id));
}
@Override
public Mono getResultsBlocking(String id) {
return createMono(() -> gearsCommandBuilder.getResultsBlocking(id));
}
@SuppressWarnings("unchecked")
@Override
public Mono create(K key, CreateOptions options, Label... labels) {
return createMono(() -> timeSeriesCommandBuilder.create(key, options, labels));
}
@SuppressWarnings("unchecked")
@Override
public Mono create(K key, Label... labels) {
return createMono(() -> timeSeriesCommandBuilder.create(key, null, labels));
}
@SuppressWarnings("unchecked")
@Override
public Mono add(K key, long timestamp, double value, CreateOptions options, Label... labels) {
return createMono(() -> timeSeriesCommandBuilder.add(key, timestamp, value, options, labels));
}
@SuppressWarnings("unchecked")
@Override
public Mono add(K key, long timestamp, double value, Label... labels) {
return createMono(() -> timeSeriesCommandBuilder.add(key, timestamp, value, null, labels));
}
@Override
public Mono createRule(K sourceKey, K destKey, Aggregation aggregationType, long timeBucket) {
return createMono(() -> timeSeriesCommandBuilder.createRule(sourceKey, destKey, aggregationType, timeBucket));
}
@Override
public Mono deleteRule(K sourceKey, K destKey) {
return createMono(() -> timeSeriesCommandBuilder.deleteRule(sourceKey, destKey));
}
@Override
public Mono create(K index, Field... fields) {
return create(index, null, fields);
}
@Override
public Mono create(K index, com.redislabs.mesclun.search.CreateOptions options, Field... fields) {
return createMono(() -> searchCommandBuilder.create(index, options, fields));
}
@Override
public Mono dropIndex(K index) {
return createMono(() -> searchCommandBuilder.dropIndex(index, false));
}
@Override
public Mono dropIndexDeleteDocs(K index) {
return createMono(() -> searchCommandBuilder.dropIndex(index, true));
}
@Override
public Flux indexInfo(K index) {
return createDissolvingFlux(() -> searchCommandBuilder.info(index));
}
@Override
public Mono> search(K index, V query) {
return createMono(() -> searchCommandBuilder.search(index, query, null));
}
@Override
public Mono> search(K index, V query, SearchOptions options) {
return createMono(() -> searchCommandBuilder.search(index, query, options));
}
@Override
public Mono> aggregate(K index, V query) {
return createMono(() -> searchCommandBuilder.aggregate(index, query, null));
}
@Override
public Mono> aggregate(K index, V query, AggregateOptions options) {
return createMono(() -> searchCommandBuilder.aggregate(index, query, options));
}
@Override
public Mono> aggregate(K index, V query, Cursor cursor) {
return createMono(() -> searchCommandBuilder.aggregate(index, query, cursor, null));
}
@Override
public Mono> aggregate(K index, V query, Cursor cursor, AggregateOptions options) {
return createMono(() -> searchCommandBuilder.aggregate(index, query, cursor, options));
}
@Override
public Mono> cursorRead(K index, long cursor) {
return createMono(() -> searchCommandBuilder.cursorRead(index, cursor, null));
}
@Override
public Mono> cursorRead(K index, long cursor, long count) {
return createMono(() -> searchCommandBuilder.cursorRead(index, cursor, count));
}
@Override
public Mono cursorDelete(K index, long cursor) {
return createMono(() -> searchCommandBuilder.cursorDelete(index, cursor));
}
@Override
public Mono sugadd(K key, V string, double score) {
return createMono(() -> searchCommandBuilder.sugadd(key, string, score));
}
@Override
public Mono sugadd(K key, V string, double score, SugaddOptions options) {
return createMono(() -> searchCommandBuilder.sugadd(key, string, score, options));
}
@Override
public Flux> sugget(K key, V prefix) {
return createDissolvingFlux(() -> searchCommandBuilder.sugget(key, prefix));
}
@Override
public Flux> sugget(K key, V prefix, SuggetOptions options) {
return createDissolvingFlux(() -> searchCommandBuilder.sugget(key, prefix, options));
}
@Override
public Mono sugdel(K key, V string) {
return createMono(() -> searchCommandBuilder.sugdel(key, string));
}
@Override
public Mono suglen(K key) {
return createMono(() -> searchCommandBuilder.suglen(key));
}
@Override
public Mono alter(K index, Field field) {
return createMono(() -> searchCommandBuilder.alter(index, field));
}
@Override
public Mono aliasAdd(K name, K index) {
return createMono(() -> searchCommandBuilder.aliasAdd(name, index));
}
@Override
public Mono aliasUpdate(K name, K index) {
return createMono(() -> searchCommandBuilder.aliasUpdate(name, index));
}
@Override
public Mono aliasDel(K name) {
return createMono(() -> searchCommandBuilder.aliasDel(name));
}
@Override
public Flux list() {
return createDissolvingFlux(searchCommandBuilder::list);
}
@Override
public Flux tagVals(K index, K field) {
return createDissolvingFlux(() -> searchCommandBuilder.tagVals(index, field));
}
@Override
public Mono dictadd(K dict, V... terms) {
return createMono(() -> searchCommandBuilder.dictadd(dict, terms));
}
@Override
public Mono dictdel(K dict, V... terms) {
return createMono(() -> searchCommandBuilder.dictdel(dict, terms));
}
@Override
public Flux dictdump(K dict) {
return createDissolvingFlux(() -> searchCommandBuilder.dictdump(dict));
}
}
