redis.clients.jedis.commands.SortedSetPipelineBinaryCommands Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jedis_preview Show documentation
Jedis is a blazingly small and sane Redis java client.
The newest version!
package redis.clients.jedis.commands;

import java.util.List;
import java.util.Map;
import java.util.Set;

import redis.clients.jedis.Response;
import redis.clients.jedis.args.SortedSetOption;
import redis.clients.jedis.params.*;
import redis.clients.jedis.resps.ScanResult;
import redis.clients.jedis.resps.Tuple;
import redis.clients.jedis.util.KeyValue;

public interface SortedSetPipelineBinaryCommands {

  Response zadd(byte[] key, double score, byte[] member);

  Response zadd(byte[] key, double score, byte[] member, ZAddParams params);

  Response zadd(byte[] key, Map scoreMembers);

  Response zadd(byte[] key, Map scoreMembers, ZAddParams params);

  Response zaddIncr(byte[] key, double score, byte[] member, ZAddParams params);

  Response zrem(byte[] key, byte[]... members);

  Response zincrby(byte[] key, double increment, byte[] member);

  Response zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params);

  Response zrank(byte[] key, byte[] member);

  Response zrevrank(byte[] key, byte[] member);

  Response> zrankWithScore(byte[] key, byte[] member);

  Response> zrevrankWithScore(byte[] key, byte[] member);

  Response> zrange(byte[] key, long start, long stop);

  Response> zrevrange(byte[] key, long start, long stop);

  Response> zrangeWithScores(byte[] key, long start, long stop);

  Response> zrevrangeWithScores(byte[] key, long start, long stop);

  Response zrandmember(byte[] key);

  Response> zrandmember(byte[] key, long count);

  Response> zrandmemberWithScores(byte[] key, long count);

  Response zcard(byte[] key);

  Response zscore(byte[] key, byte[] member);

  Response> zmscore(byte[] key, byte[]... members);

  Response zpopmax(byte[] key);

  Response> zpopmax(byte[] key, int count);

  Response zpopmin(byte[] key);

  Response> zpopmin(byte[] key, int count);

  Response zcount(byte[] key, double min, double max);

  Response zcount(byte[] key, byte[] min, byte[] max);

  Response> zrangeByScore(byte[] key, double min, double max);

  Response> zrangeByScore(byte[] key, byte[] min, byte[] max);

  Response> zrevrangeByScore(byte[] key, double max, double min);

  Response> zrangeByScore(byte[] key, double min, double max, int offset, int count);

  Response> zrevrangeByScore(byte[] key, byte[] max, byte[] min);

  Response> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count);

  Response> zrevrangeByScore(byte[] key, double max, double min, int offset, int count);

  Response> zrangeByScoreWithScores(byte[] key, double min, double max);

  Response> zrevrangeByScoreWithScores(byte[] key, double max, double min);

  Response> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count);

  Response> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count);

  Response> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max);

  Response> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min);

  Response> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count);

  Response> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count);

  Response> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count);

  Response zremrangeByRank(byte[] key, long start, long stop);

  Response zremrangeByScore(byte[] key, double min, double max);

  Response zremrangeByScore(byte[] key, byte[] min, byte[] max);

  Response zlexcount(byte[] key, byte[] min, byte[] max);

  Response> zrangeByLex(byte[] key, byte[] min, byte[] max);

  Response> zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count);

  Response> zrevrangeByLex(byte[] key, byte[] max, byte[] min);

  Response> zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count);

  Response> zrange(byte[] key, ZRangeParams zRangeParams);

  Response> zrangeWithScores(byte[] key, ZRangeParams zRangeParams);

  Response zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams);

  Response zremrangeByLex(byte[] key, byte[] min, byte[] max);

  default Response> zscan(byte[] key, byte[] cursor) {
    return zscan(key, cursor, new ScanParams());
  }

  Response> zscan(byte[] key, byte[] cursor, ScanParams params);

  Response> bzpopmax(double timeout, byte[]... keys);

  Response> bzpopmin(double timeout, byte[]... keys);

  Response> zdiff(byte[]... keys);

  Response> zdiffWithScores(byte[]... keys);

  /**
   * @deprecated Use {@link #zdiffstore(byte..., byte[]...)}.
   */
  @Deprecated
  Response zdiffStore(byte[] dstkey, byte[]... keys);

  Response zdiffstore(byte[] dstkey, byte[]... keys);

  Response> zinter(ZParams params, byte[]... keys);

  Response> zinterWithScores(ZParams params, byte[]... keys);

  Response zinterstore(byte[] dstkey, byte[]... sets);

  Response zinterstore(byte[] dstkey, ZParams params, byte[]... sets);

  Response zintercard(byte[]... keys);

  Response zintercard(long limit, byte[]... keys);

  Response> zunion(ZParams params, byte[]... keys);

  Response> zunionWithScores(ZParams params, byte[]... keys);

  Response zunionstore(byte[] dstkey, byte[]... sets);

  Response zunionstore(byte[] dstkey, ZParams params, byte[]... sets);

  Response>> zmpop(SortedSetOption option, byte[]... keys);

  Response>> zmpop(SortedSetOption option, int count, byte[]... keys);

  Response>> bzmpop(double timeout, SortedSetOption option, byte[]... keys);

  Response>> bzmpop(double timeout, SortedSetOption option, int count, byte[]... keys);
}