redis_zset.hpp

浏览该文件的文档.

#pragma once
#include "../acl_cpp_define.hpp"
#include <vector>
#include <map>
#include <utility>
#include "redis_command.hpp"

#if !defined(ACL_CLIENT_ONLY) && !defined(ACL_REDIS_DISABLE)

namespace acl
{

class ACL_CPP_API redis_zset : virtual public redis_command
{
public:
        /**
         * see redis_command::redis_command()
         */
        redis_zset(void);

        /**
         * see redis_command::redis_command(redis_client*)
         */
        redis_zset(redis_client* conn);

        /**
         * see redis_command::redis_command(redis_client_cluster*)
         */
        redis_zset(redis_client_cluster* cluster);

        redis_zset(redis_client_pipeline* pipeline);

        ACL_CPP_DEPRECATED
        redis_zset(redis_client_cluster* cluster, size_t max_conns);

        virtual ~redis_zset(void);

        /////////////////////////////////////////////////////////////////////

        /**
         * 添加对应 key 的有序集
         * add one or more members to a sorted set, or update its score if
         * it already exists
         * @param key {const char*} 有序集键值
         *  the key of a sorted set
         * @param members "分值-成员"集合
         *  the set storing values and stores
         * @return {int} 新成功添加的 "分值-成员" 对的数量
         *  the number of elements added to the sorted set, not including
         *  elements already existing for which the score was updated
         *  0：表示一个也未添加，可能因为该成员已经存在于有序集中
         *     nothing was added to the sorted set
         * -1：表示出错或 key 对象非有序集对象
         *     error or it was not a sorted set by the key
         * >0：新添加的成员数量
         *     the number of elements added
         */
        int zadd(const char* key, const std::map<string, double>& members,
                const std::vector<string>* options = NULL);
        int zadd(const char* key,
                const std::vector<std::pair<string, double> >&members);
        int zadd(const char* key,
                const std::vector<std::pair<const char*, double> >&members);
        int zadd(const char* key, const std::vector<string>& members,
                const std::vector<double>& scores);
        int zadd(const char* key, const std::vector<const char*>& members,
                const std::vector<double>& scores);
        int zadd(const char* key, const char* members[], double scores[],
                size_t size);
        int zadd(const char* key, const char* members[], size_t members_len[],
                double scores[], size_t size);

        int zadd_with_ch_xx(const char* key, const std::map<string, double>& members);
        int zadd_with_ch_nx(const char* key, const std::map<string, double>& members);

        bool zadd_with_incr(const char* key, const char* member, size_t len,
                double score, double* result = NULL, const char* option = NULL);
        bool zadd_with_incr(const char* key, const char* member,
                double score, double* result = NULL, const char* option = NULL);
        bool zadd_with_incr_xx(const char* key, const char* member,
                double score, double* result = NULL);
        bool zadd_with_incr_nx(const char* key, const char* member,
                double score, double* result = NULL);

        /**
         * 获得相应键的有序集的成员数量
         * get the number of elements in a sorted set
         * @param key {const char*} 有序集键值
         *  the key of a a sorted set
         * @return {int} 一个键的有序集的成员数量
         *  the number of elements of the sorted set
         *   0：该键不存在
         *      the key doesn't exist
         *  -1：出错或该键的数据对象不是有效的有序集对象
         *      error or it wasn't a sorted set by the key
         *  >0：当前键值对应的数据对象中的成员个数
         *      the number of elements in the sorted set
         */
        int zcard(const char* key);

        /**
         * 获得 key 的有序集中指定分值区间的成员个数
         * get the number of elements in a sorted set with scores within
         * the given values
         * @param key {const char*} 有序集键值
         *  the key of a sorted set
         * @param min {double} 最小分值
         *  the min score specified
         * @param max {double} 最大分值
         *  the max socre specified
         * @return {int} 符合条件的成员个数
         *  the number of elements in specified score range
         *  0：该键对应的有序集不存在或该 KEY 有序集的对应分值区间成员为空
         *     nothing in the specified score range, or the key doesn't exist
         *  -1: 出错或该键的数据对象不是有效的有序集对象
         *     error or it is not a sorted set by the key
         */
        int zcount(const char* key, double min, double max);

        /**
         * 将 key 的有序集中的某个成员的分值加上增量 inc
         * increase the score of a memeber in a sorted set
         * @param key {const char*} 有序集键值
         *  the key of the sorted set
         * @param inc {double} 增量值
         *  the value to be increased
         * @param member {const char*} 有序集中成员名
         *  the specified memeber of a sorted set
         * @param result {double*} 非空时存储结果值
         *  if not null, it will store the score result after increment
         * @return {bool} 操作是否成功
         *  if successful about the operation
         */
        bool zincrby(const char* key, double inc, const char* member,
                double* result = NULL);
        bool zincrby(const char* key, double inc, const char* member,
                size_t len, double* result = NULL);

        /**
         * 从 key 的有序集中获得指定位置区间的成员名列表，成员按分值递增方式排序
         * get the specified range memebers of a sorted set sotred at key
         * @param key {const char*} 有序集键值
         *  the key of a sorted set
         * @param start {int} 起始下标位置
         *  the begin index of the sorted set
         * @param stop {int} 结束下标位置（结果集同时含该位置）
         *  the end index of the sorted set
         * @param result {std::vector<string>*} 非空时存储结果集，内部先调用
         *  result.clear() 清除其中的元素
         *  if not NULL, it will store the memebers result
         * @return {int} 结果集中成员的数量
         *  the number of memebers
         *  0: 表示结果集为空或 key 不存在
         *     the result is empty or the key doesn't exist
         * -1: 表示出错或 key 对象非有序集对象
         *     error or it's not a sorted set by the key
         * >0: 结果集的数量
         *     the number of the memebers result
         *  注：对于下标位置，0 表示第一个成员，1 表示第二个成员；-1 表示最后一个成员，
         *     -2 表示倒数第二个成员，以此类推
         *  Notice: about the index, element by index 0 is the first
         *   of the sorted set, element by index -1 is the last one. 
         *
         *  操作成功后可以通过以下任一方式获得数据
         *  when success, the result can be got by one of the below proccess: 
         *  1、在调用方法中传入非空的存储结果对象的地址
         *     the most easily way is to set a non-NULL result parameter
         *     for this function
         *  2、基类方法 get_value 获得指定下标的元素数据
         *     get the specified subscript's element by redis_command::get_value
         *  3、基类方法 get_child 获得指定下标的元素对象(redis_result），然后再通过
         *     redis_result::argv_to_string 方法获得元素数据
         *     redis_result::argv_to_string 方法获得元素数据
         *     get redis_result object with the given subscript, and get the
         *     element by redis_result::argv_to_string
         *  4、基类方法 get_result 方法取得总结果集对象 redis_result，然后再通过
         *     redis_result::get_child 获得一个元素对象，然后再通过方式 2 中指定
         *     的方法获得该元素的数据
         *     get redis_result object by redis_command::get_result, and get
         *     the first element by redis_result::get_child, then get the
         *     element by the way same as the way 2 above.
         *  5、基类方法 get_children 获得结果元素数组对象，再通过 redis_result 中
         *     的方法 argv_to_string 从每一个元素对象中获得元素数据
         *     get child array by redis_command::get_children, and get the
         *     element from one of redis_result array by argv_to_string
         */
        int zrange(const char* key, int start, int stop,
                std::vector<string>* result);

        /**
         * 从 key 的有序集中获得指定位置区间的成员名及分值列表，成员按分值递增方式排序
         * @param key {const char*} 有序集键值
         * @param start {int} 起始下标位置
         * @param stop {int} 结束下标位置（结果集同时含该位置）
         * @param out 存储 "成员名-分值对"结果集，内部先调用 out.clear()
         * @return {int} 结果集中成员的数量
         *  0: 表示结果集为空或 key 不存在
         * -1: 表示出错或 key 对象非有序集对象
         * >0: 结果集的数量
         *  注：对于下标位置，0 表示第一个成员，1 表示第二个成员；-1 表示最后一个成员，
         *     -2 表示倒数第二个成员，以此类推
         */
        int zrange_with_scores(const char* key, int start, int stop,
                std::vector<std::pair<string, double> >& out);

        /**
         * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
         * 的成员。有序集成员按 score 值递增(从小到大)次序排列
         * @param key {const char*} 有序集键值
         * @param min {double} 最小分值
         * @param max {double} 最大分值
         * @param out {std::vector<string>*} 非空时存储“成员名”结果集
         * @param offset {const int*} 非空时表示结果集的起始下标
         * @param count {const int*} 非空时表示截取的结果集中成员个数
         * @return {int} 结果集中成员的数量
         *  0: 表示结果集为空或 key 不存在
         * -1: 表示出错或 key 对象非有序集对象
         * >0: 结果集的数量
         *  注：offset 和 count 必须同时为非空指针时才有效
         *
         *  操作成功后可以通过以下任一方式获得数据
         *  1、在调用方法中传入非空的存储结果对象的地址
         *  2、基类方法 get_value 获得指定下标的元素数据
         *  3、基类方法 get_child 获得指定下标的元素对象(redis_result），然后再通过
         *     redis_result::argv_to_string 方法获得元素数据
         *  4、基类方法 get_result 方法取得总结果集对象 redis_result，然后再通过
         *     redis_result::get_child 获得一个元素对象，然后再通过方式 2 中指定
         *     的方法获得该元素的数据
         *  5、基类方法 get_children 获得结果元素数组对象，再通过 redis_result 中
         *     的方法 argv_to_string 从每一个元素对象中获得元素数据
         */
        int zrangebyscore(const char* key, double min, double max,
                std::vector<string>* out, const int* offset = NULL,
                const int* count = NULL);

        /**
         * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
         * 的成员。有序集成员按 score 值递增(从小到大)次序排列
         * @param key {const char*} 有序集键值
         * @param min {const char*} 以字符串表示最小分值
         * @param max {const char*} 以字符串表示最大分值
         * @param out {std::vector<string>*} 非空时存储“成员名”结果集
         * @param offset {const int*} 非空时表示结果集的起始下标
         * @param count {const int*} 非空时表示截取的结果集中成员个数
         * @return {int} 结果集中成员的数量
         *  0: 表示结果集为空或 key 不存在
         * -1: 表示出错或 key 对象非有序集对象
         * >0: 结果集的数量
         *  注：
         * 1）offset 和 count 必须同时为非空指针时才有效
         * 2）min 和 max 可以是 -inf 和 +inf 来表示无限区间
         * 3）默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，也可以通过给参数前
         *   增加 ( 符号来使用可选的开区间 (小于或大于)，如：
         * 3.1）"ZRANGEBYSCORE zset (1 5" 返回所有符合条件 1 < score <= 5 的成员
         * 3.2）"ZRANGEBYSCORE zset (5 (10" 返回所有符合条件 5 < score < 10 的成员
         *
         *  操作成功后可以通过以下任一方式获得数据
         *  1、在调用方法中传入非空的存储结果对象的地址
         *  2、基类方法 get_value 获得指定下标的元素数据
         *  3、基类方法 get_child 获得指定下标的元素对象(redis_result），然后再通过
         *     redis_result::argv_to_string 方法获得元素数据
         *  4、基类方法 get_result 方法取得总结果集对象 redis_result，然后再通过
         *     redis_result::get_child 获得一个元素对象，然后再通过方式 2 中指定
         *     的方法获得该元素的数据
         *  5、基类方法 get_children 获得结果元素数组对象，再通过 redis_result 中
         *     的方法 argv_to_string 从每一个元素对象中获得元素数据
         */
        int zrangebyscore(const char* key, const char* min, const char* max,
                std::vector<string>* out, const int* offset = NULL,
                const int* count = NULL);

        /**
         * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
         * 的成员及分值。有序集成员按 score 值递增(从小到大)次序排列；分值(min/max)使用
         * 浮点数表示
         * @param out 存储结果集，内部先调用 out.clear()
         * @return {int} 结果集中成员的数量
         */
        int zrangebyscore_with_scores(const char* key, double min, double max,
                std::vector<std::pair<string, double> >& out,
                const int* offset = NULL, const int* count = NULL);

        /**
         * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
         * 的成员及分值。有序集成员按 score 值递增(从小到大)次序排列；分值(min/max)使用
         * 字符串表示
         * @param out 存储结果集，内部先调用 out.clear()
         * @return {int} 结果集中成员的数量
         */
        int zrangebyscore_with_scores(const char* key, const char* min,
                const char* max, std::vector<std::pair<string, double> >& out,
                const int* offset = NULL, const int* count = NULL);

        /**
         * 返回有序集 key 中成员 member 的排名(下标从 0 开始）；其中有序集成员按 score
         * 值递增(从小到大)顺序排列
         * @param key {const char*} 有序集键值
         * @param member {const char*} 成员名
         * @param len {size_t} member 的长度
         * @return {int} 下标位置值，-1 -- 出错，或 key 非有序集对象，或成员名不存在
         */
        int zrank(const char* key, const char* member, size_t len);
        int zrank(const char* key, const char* member);

        /**
         * 从有序集中删除某个成员
         * @param key {const char*} 有序集键值
         * @param first_member {const char*} 要删除的成员列表的第一个
         * @return {int} 成功删除的成员的数量，-1 表示出错或该 key 非有序集对象，
         *  0 表示该有序集不存在或成员不存在，> 0 表示成功删除的成员数量
         */
        int zrem(const char* key, const char* first_member, ...);
        int zrem(const char* key, const std::vector<string>& members);
        int zrem(const char* key, const std::vector<const char*>& members);
        int zrem(const char* key, const char* members[], const size_t lens[],
                size_t argc);

        /**
         * 移除有序集 key 中，指定排名(rank)区间内的所有成员；
         * 区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内；
         * 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，
         * 以 1 表示有序集第二个成员，以此类推；
         * 也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推
         * @param key {const char*} 有序集键值
         * @param start {int} 起始下标位置（从 0 开始）
         * @param stop {int} 结束下标位置
         * @return {int} 被移除的成员数量
         *  0：表示 key 不存在或移除的区间不存在
         * -1：表示出错或 key 不是有序集合对象键值
         */
        int zremrangebyrank(const char* key, int start, int stop);

        /**
         * 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
         * 的成员；自版本2.1.6开始，score 值等于 min 或 max 的成员也可以不包括在内，
         * 详情请参见 ZRANGEBYSCORE 命令
         * @param key {const char*} 有序集键值
         * @param min {double} 最小分值
         * @param max {double} 最大分值
         * @return {int} 成功删除的成员的数量，-1 表示出错或该 key 非有序集对象，
         *  0 表示该有序集不存在或成员不存在，> 0 表示成功删除的成员数量
         */
        int zremrangebyscore(const char* key, double min, double max);

        /**
         * 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
         * 的成员；自版本2.1.6开始，score 值等于 min 或 max 的成员也可以不包括在内，
         * 详情请参见 ZRANGEBYSCORE 命令
         * @param key {const char*} 有序集键值
         * @param min {const char*} 字符串形式的最小分值，意义参见：zrangebyscore 注释
         * @param max {const char*} 字符串形式的最大分值
         * @return {int} 成功删除的成员的数量，-1 表示出错或该 key 非有序集对象，
         *  0 表示该有序集不存在或成员不存在，> 0 表示成功删除的成员数量
         */
        int zremrangebyscore(const char* key, const char* min, const char* max);

        /**
         * 从 key 的有序集中获得指定位置区间的成员名列表，成员按分值递减方式排序
         * @param key {const char*} 有序集键值
         * @param start {int} 起始下标位置
         * @param stop {int} 结束下标位置（结果集同时含该位置）
         * @param result {std::vector<string>*} 非空时存储结果集
         *  注：对于下标位置，0 表示第一个成员，1 表示第二个成员；-1 表示最后一个成员，
         *     -2 表示倒数第二个成员，以此类推
         * @return {int} 结果集数量，-1 表示出错
         */
        int zrevrange(const char* key, int start, int stop,
                std::vector<string>* result);

        /**
         * 从 key 的有序集中获得指定位置区间的成员名及分值列表，成员按分值递减方式排序
         * @param key {const char*} 有序集键值
         * @param start {int} 起始下标位置
         * @param stop {int} 结束下标位置（结果集同时含该位置）
         * @param out 存储 "成员名-分值对"结果集，内部先调用 out.clear()
         *  注：对于下标位置，0 表示第一个成员，1 表示第二个成员；-1 表示最后一个成员，
         *     -2 表示倒数第二个成员，以此类推
         * @return {int} 结果集数量，-1 表示出错
         */
        int zrevrange_with_scores(const char* key, int start, int stop,
                std::vector<std::pair<string, double> >& out);

        /**
         * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
         * 的成员。有序集成员按 score 值递8减(从小到大)次序排列
         * @param key {const char*} 有序集键值
         * @param min {const char*} 以字符串表示最小分值
         * @param max {const char*} 以字符串表示最大分值
         * @param out {std::vector<string>*} 非空时存储“成员名”结果集
         * @param offset {const int*} 非空时表示结果集的起始下标
         * @param count {const int*} 非空时表示截取的结果集中成员个数
         * @return {int} 结果集中成员的数量
         *  0: 表示结果集为空或 key 不存在
         * -1: 表示出错或 key 对象非有序集对象
         * >0: 结果集的数量
         *  注：
         * 1）offset 和 count 必须同时为非空指针时才有效
         * 2）min 和 max 可以是 -inf 和 +inf 来表示无限区间
         * 3）默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，也可以通过给参数前
         *   增加 ( 符号来使用可选的开区间 (小于或大于)，如：
         * 3.1）"ZRANGEBYSCORE zset (1 5" 返回所有符合条件 1 < score <= 5 的成员
         * 3.2）"ZRANGEBYSCORE zset (5 (10" 返回所有符合条件 5 < score < 10 的成员
         */
        //int zrevrangebyscore(const char* key, const char* min, const char* max,
        //      std::vector<string>* out, const int* offset = NULL,
        //      const int* count = NULL);

        /**
         * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )
         * 的成员及分值。有序集成员按 score 值递减(从小到大)次序排列；分值(min/max)使用
         * 浮点数表示
         * @param out 存储“分值-成员名”对的结果集，内部先调用 out.clear()
         * @param count {const int*} 非空时表示截取的结果集中成员个数
         */
        int zrevrangebyscore_with_scores(const char* key, double min,
                double max, std::vector<std::pair<string, double> >& out,
                const int* offset = NULL, const int* count = NULL);
        int zrevrangebyscore_with_scores(const char* key, const char* min,
                const char* max, std::vector<std::pair<string, double> >& out,
                const int* offset = NULL, const int* count = NULL);

        /**
         * 返回有序集 key 中成员 member 的排名(下标从 0 开始)；其中有序集成员按 score
         * 值递减(从大到小)排序
         * @param key {const char*} 有序集键值
         * @param member {const char*} 成员名
         * @param len {size_t} member 的长度
         * @return {int} 下标位置值，-1 -- 出错，或 key 非有序集对象，或成员名不存在
         */
        int zrevrank(const char* key, const char* member, size_t len);
        int zrevrank(const char* key, const char* member);

        /**
         * 获得有序集 key 中，成员 member 的 score 值
         * @param key {const char*} 有序集键值
         * @param member {const char*} 成员名
         * @param len {size_t} member 的长度
         * @param result {double&} 存储分值结果
         * @return {bool} 当不存在或出错时返回 false，否则返回 true
         */
        bool zscore(const char* key, const char* member, size_t len,
                double& result);
        bool zscore(const char* key, const char* member, double& result);

        /**
         * 计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，
         * 并将该并集(结果集)储存到目标有序集; 默认情况下，结果集中某个成员的 score
         * 值是所有给定集下该成员 score 值之和
         * @param dst {const char*} 目标有序集键值
         * @param keys 源有序集键值-权重集合；使用权重选项，可以为 每个 给定有序集 分别
         *  指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score
         *  值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子；
         *  如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1
         * @param aggregate {const char*} 聚合方式，默认是 SUM 聚合方式，聚合方式如下：
         *  SUM: 将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值
         *  MIN: 将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值
         *  MAX: 将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值
         * @return {int} 新保存到目标有序集的结果集中的元素(成员)数量，如果源有序集
         *  集合中存在相同的成员，则只新增一个成员；返回 -1 表示出错
         */
        int zunionstore(const char* dst, const std::map<string, double>& keys,
                const char* aggregate = "SUM");

        int zunionstore(const char* dst, const std::vector<string>& keys,
                const std::vector<double>* weights = NULL,
                const char* aggregate = "SUM");

        /**
         * 计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，
         * 并将该并集(结果集)储存到目标有序集; 默认情况下，结果集中某个成员的 score
         * 值是所有给定集下该成员 score 值之和
         * @return {int} 新保存到目标有序集的结果集中的元素(成员)数量
         */
        int zinterstore(const char* dst, const std::map<string, double>& keys,
                const char* aggregate = "SUM");

        int zinterstore(const char* dst, const std::vector<string>& keys,
                const std::vector<double>* weights = NULL,
                const char* aggregate = "SUM");
        
        /**
         * 命令用于迭代有序集合中的元素（包括元素成员和元素分值）
         * @param cursor {int} 游标值，开始遍历时该值写 0
         * @param out 存储结果集，内部以追加方式将本次遍历结果集合添加进该数组中，
         *  为防止因总结果集过大导致该数组溢出，用户可在调用本函数前后清理该数组对象
         * @param pattern {const char*} 匹配模式，glob 风格，非空时有效
         * @param count {const size_t*} 限定的结果集数量，非空指针时有效
         * @return {int} 下一个游标位置，含义如下：
         *   0：遍历结束
         *  -1: 出错
         *  >0: 游标的下一个位置，即使这样，具体有多少结果还需要检查 out，因为有可能为空
         */
        int zscan(const char* key, int cursor,
                std::vector<std::pair<string, double> >& out,
                const char* pattern = NULL, const size_t* count = NULL);

        /**
         * 当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序
         * （lexicographical ordering）来进行排序， 而这个命令则可以返回给定的
         * 有序集合键 key 中， 值介于 min 和 max 之间的成员
         * @param min {const char*} 区间最小值
         * @param max {const char*} 区间最大值
         * @param out {std::vector<string>*} 非空时存储结果集
         * @param offset {const int*} 非空时有效，从结果集中选取的下标起始值
         * @param count {const int*} 非空时有效，从结果集中的指定下标位置起选取的数量
         * @return {int} 结果集中成员的数量
         *  0: 表示结果集为空或 key 不存在
         * -1: 表示出错或 key 对象非有序集对象
         * >0: 结果集的数量
         * 注：关于区间的选择规则如下：
         * 1）合法的 min 和 max 参数必须包含 ( 或者 [ ， 其中 ( 表示开区间（指定的值
         *   不会被包含在范围之内）， 而 [ 则表示闭区间（指定的值会被包含在范围之内）
         * 2）特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义， 其中 + 表示
         *   正无限， 而 - 表示负无限。因此，向一个所有成员的分值都相同的有序集合发送命令
         *   ZRANGEBYLEX <zset> - + ， 命令将返回有序集合中的所有元素
         */
        int zrangebylex(const char* key, const char* min, const char* max,
                std::vector<string>* out, const int* offset = NULL,
                const int* count = NULL);

        /**
         * 于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会返回该集合中， 
         * 成员介于 min 和 max 范围内的元素数量
         * @return {int} 符合条件的元素数量
         */
        int zlexcount(const char* key, const char* min, const char* max);

        /**
         * 对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会移除该集合中，
         * 成员介于 min 和 max 范围内的所有元素
         * @return {int} 被移除的元素数量
         */
        int zremrangebylex(const char* key, const char* min, const char* max);

        int zpopmin(const char* key,
                std::vector<std::pair<string, double> >& out, size_t count = 1);
        int zpopmax(const char* key,
                std::vector<std::pair<string, double> >& out, size_t count = 1);
        int bzpopmin(const char* key, size_t timeout, string& member,
                double* score = NULL);
        int bzpopmax(const char* key, size_t timeout, string& member,
                double* score = NULL);
        int bzpopmin(const std::vector<string>& keys, size_t timeout,
                string& member, double* score = NULL);
        int bzpopmax(const std::vector<string>& keys, size_t timeout,
                string& member, double* score = NULL);

private:
        int zrange_get(const char* cmd, const char* key, int start,
                int stop, std::vector<string>* result);
        int zrange_get_with_scores(const char* cmd, const char* key, int start,
                int stop, std::vector<std::pair<string, double> >& out);
        int zrangebyscore_get(const char* cmd, const char* key,
                const char* min, const char* max, std::vector<string>* out,
                const int* offset = NULL, const int* count = NULL);
        int zrangebyscore_get_with_scores(const char* cmd,
                const char* key, const char* min, const char* max,
                std::vector<std::pair<string, double> >& out,
                const int* offset = NULL, const int* count = NULL);
        int zstore(const char* cmd, const char* dst,
                const std::map<string, double>& keys, const char* aggregate);
        int zstore(const char* cmd, const char* dst, const std::vector<string>& keys,
                const std::vector<double>* weights, const char* aggregate);
        int zpop(const char* cmd, const char* key,
                std::vector<std::pair<string, double> >& out, size_t count);
        int get_with_scores(std::vector<std::pair<string, double> >& out);
        int bzpop(const char* cmd, const char* key, size_t timeout,
                string& member, double* score);
        int bzpop(const char* cmd, const std::vector<string>& keys,
                size_t timeout, string& member, double* score);
        int bzpop_result(string& member, double* score);
};

} // namespace acl

#endif // !defined(ACL_CLIENT_ONLY) && !defined(ACL_REDIS_DISABLE)