All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • org.redisson.spring.data.connection.RedissonReactiveHyperLogLogCommands Maven / Gradle / Ivy

    There is a newer version: 3.41.0
    Show newest version
    /**
 * Copyright (c) 2013-2022 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.spring.data.connection;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import org.reactivestreams.Publisher;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.client.protocol.RedisStrictCommand;
import org.redisson.reactive.CommandReactiveExecutor;
import org.springframework.data.redis.connection.ReactiveHyperLogLogCommands;
import org.springframework.data.redis.connection.ReactiveRedisConnection.BooleanResponse;
import org.springframework.data.redis.connection.ReactiveRedisConnection.NumericResponse;
import org.springframework.util.Assert;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

/**
 * 
 * @author Nikita Koksharov
 *
 */
public class RedissonReactiveHyperLogLogCommands extends RedissonBaseReactive implements ReactiveHyperLogLogCommands {

    RedissonReactiveHyperLogLogCommands(CommandReactiveExecutor executorService) {
        super(executorService);
    }

    private static final RedisCommand PFADD = new RedisCommand("PFADD");
    
    @Override
    public Flux> pfAdd(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notEmpty(command.getValues(), "Values must not be empty!");

            byte[] keyBuf = toByteArray(command.getKey());

            List params = new ArrayList(command.getValues().size() + 1);
            params.add(keyBuf);
            params.addAll(command.getValues().stream().map(v -> toByteArray(v)).collect(Collectors.toList()));

            Mono m = write(keyBuf, StringCodec.INSTANCE, PFADD, params.toArray());
            return m.map(v -> new NumericResponse<>(command, v));
        });
    }

    @Override
    public Flux> pfCount(Publisher commands) {
        return execute(commands, command -> {

            Assert.notEmpty(command.getKeys(), "Keys must not be empty!");

            Object[] args = command.getKeys().stream().map(v -> toByteArray(v)).toArray();

            Mono m = write((byte[])args[0], StringCodec.INSTANCE, RedisCommands.PFCOUNT, args);
            return m.map(v -> new NumericResponse<>(command, v));
        });
    }
    
    private static final RedisStrictCommand PFMERGE = new RedisStrictCommand("PFMERGE");

    @Override
    public Flux> pfMerge(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Destination key must not be null!");
            Assert.notEmpty(command.getSourceKeys(), "Source keys must not be null!");
            
            byte[] keyBuf = toByteArray(command.getKey());
            List args = new ArrayList(command.getSourceKeys().size() + 1);
            args.add(keyBuf);
            args.addAll(command.getSourceKeys().stream().map(v -> toByteArray(v)).collect(Collectors.toList()));
            Mono m = write(keyBuf, StringCodec.INSTANCE, PFMERGE, args.toArray());
            return m.map(v -> new BooleanResponse<>(command, true));
        });
    }

}
    
    
    
    

    




    
    
    © 2015 - 2024 Weber Informatics LLC | Privacy Policy