redis_slot.hpp

浏览该文件的文档.

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

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

namespace acl
{

class ACL_CPP_API redis_slot
{
public:
        /**
         * 构造函数
         * constructor
         * @param slot_min {size_t} 最小哈希槽值
         *  the min hash-slot
         * @param slot_max {size_t} 最大哈希槽值
         *  the max hash-slot
         * @param ip {const char*} 当前 redis-server 的 IP 地址
         *  the given redis-server's ip
         * @param port {int} 当前 redis-server 的监听端口
         *  the listening port of the given redis-server
         * 
         */
        redis_slot(size_t slot_min, size_t slot_max,
                const char* ip, int port);
        redis_slot(const redis_slot& node);

        ~redis_slot(void);

        /**
         * 将一个 redis 哈希槽从结点添加至当前结点中
         * add a slave slot node to the current node
         * @param node {redis_slot*} 一个存储哈希槽的从结点
         *  the slave slot node
         */
        redis_slot& add_slave(redis_slot* node);

        /**
         * 获得当前哈希槽结点的所有从结点
         * get the slave nodes of the current node
         * @return {const std::vector<redis_slot*>&}
         */
        const std::vector<redis_slot*>& get_slaves() const
        {
                return slaves_;
        }

        /**
         * 获得当前结点的 IP 地址
         * get the ip of the current node
         * @return {const char*}
         */
        const char* get_ip(void) const
        {
                return ip_;
        }

        /**
         * 获得当前结点的端口号
         * get the port of the current node
         * @return {int}
         */
        int get_port(void) const
        {
                return port_;
        }

        /**
         * 获得当前哈希槽结点的最小值
         * get the min hash slot of the current node
         * @return {size_t}
         */
        size_t get_slot_min(void) const
        {
                return slot_min_;
        }

        /**
         * 获得当前哈希槽结点的最大值
         * get the max hash slot of the current node
         * @return {size_t}
         */
        size_t get_slot_max(void) const
        {
                return slot_max_;
        }

private:
        size_t slot_min_;
        size_t slot_max_;
        char ip_[128];
        int port_;

        std::vector<redis_slot*> slaves_;
};

} // namespace acl

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