ResponseExpirationCache.hpp

#pragma once
 
#include "util/Mutex.hpp"
 
#include <boost/json/object.hpp>
 
#include <chrono>
#include <optional>
#include <shared_mutex>
#include <string>
#include <unordered_map>
#include <unordered_set>
 
namespace util {

class ResponseExpirationCache {
    class Entry {
        std::chrono::steady_clock::time_point lastUpdated_;
        std::optional<boost::json::object> response_;
 
    public:
        void
        put(boost::json::object response);

        std::optional<boost::json::object>
        get() const;

        std::chrono::steady_clock::time_point
        lastUpdated() const;

        void
        invalidate();
    };
 
    std::chrono::steady_clock::duration cacheTimeout_;
    std::unordered_map<std::string, util::Mutex<Entry, std::shared_mutex>> cache_;
 
    bool
    shouldCache(std::string const& cmd);
 
public:
    ResponseExpirationCache(
        std::chrono::steady_clock::duration cacheTimeout,
        std::unordered_set<std::string> const& cmds
    )
        : cacheTimeout_(cacheTimeout)
    {
        for (auto const& command : cmds) {
            cache_.emplace(command, Entry{});
        }
    }

    [[nodiscard]] std::optional<boost::json::object>
    get(std::string const& cmd) const;

    void
    put(std::string const& cmd, boost::json::object const& response);

    void
    invalidate();
};
 
}  // namespace util