HiredisAdapter.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <exception>
#include <functional>
#include <memory>
#include <string>
 
#include <hiredis/hiredis.h>
 
class HiredisAdapter
{
public:
    using set_reply_t = std::unique_ptr<redisReply, std::function<void(redisReply*)>>;
    using sadd_reply_t = set_reply_t;
    using get_reply_t = set_reply_t;
    using smembers_reply_t = set_reply_t;
    using timeout_t = size_t;
 
    constexpr static int REDIS_DEFAULT_PORT{6379};
 
    inline HiredisAdapter(const std::string& srv_ip = "127.0.0.1", int port = REDIS_DEFAULT_PORT)
        : server_ip(srv_ip), port(port){};
    HiredisAdapter(const HiredisAdapter&) = delete;
    HiredisAdapter(HiredisAdapter&&) = default;
    virtual ~HiredisAdapter();
 
    virtual void connect();
    virtual void disconnect();
 
    virtual inline bool is_connected() const noexcept
    {
        return ctx != nullptr;
    }
 
    virtual set_reply_t set(const std::string& key, const std::string& value,
                            const timeout_t expire = 0);
    virtual sadd_reply_t sadd(const std::string& key, const std::string& value,
                              const timeout_t expire = 0);
 
    virtual void expire(const std::string& key, timeout_t expire);
 
    virtual get_reply_t get(const std::string& key);
    virtual smembers_reply_t smembers(const std::string& key);
 
    virtual inline bool last_expire_has_failed() const noexcept
    {
        return last_expire_failed;
    }
 
private:
    inline redisReply* generic_set(const std::string& command, const std::string& key,
                                   const std::string& value);
    inline redisReply* generic_read(const std::string& command, const std::string& key);
 
    inline void assert_connected() const;
    inline void assert_valid_redis_reply(const void* reply, const std::string& command = "");
 
    std::string server_ip;
    int port;
 
    redisContext* ctx{nullptr};
 
    bool last_expire_failed{false};
};
 
class HiredisException : public std::exception
{
public:
    inline HiredisException(const std::string& msg) : msg(msg)
    {}
 
    inline const char* what() const noexcept
    {
        return msg.c_str();
    }
 
private:
    std::string msg;
};