filecache.h

Go to the documentation of this file.

 
#ifndef CPPCOMMON_CACHE_FILECACHE_H
#define CPPCOMMON_CACHE_FILECACHE_H
 
#include "filesystem/directory.h"
#include "filesystem/file.h"
#include "filesystem/path.h"
#include "time/timespan.h"
#include "time/timestamp.h"
 
#include <functional>
#include <map>
#include <mutex>
#include <shared_mutex>
#include <string>
#include <string_view>
#include <tuple>
#include <unordered_map>
 
namespace CppCommon {
 
 
class FileCache
{
public:
    typedef std::function<bool (FileCache& cache, const std::string& key, const std::string& value, const Timespan& timeout)> InsertHandler;
 
    FileCache() = default;
    FileCache(const FileCache&) = delete;
    FileCache(FileCache&&) = delete;
    ~FileCache() = default;
 
    FileCache& operator=(const FileCache&) = delete;
    FileCache& operator=(FileCache&&) = delete;
 
    explicit operator bool() const { return !empty(); }
 
    bool empty() const;
 
    size_t size() const;
 
 
    bool emplace(std::string&& key, std::string&& value, const Timespan& timeout = Timespan(0));
 
 
    bool insert(const std::string& key, const std::string& value, const Timespan& timeout = Timespan(0));
 
 
    std::pair<bool, std::string_view> find(const std::string& key);
 
    std::pair<bool, std::string_view> find(const std::string& key, Timestamp& timeout);
 
 
    bool remove(const std::string& key);
 
 
    bool insert_path(const CppCommon::Path& path, const std::string& prefix = "/", const Timespan& timeout = Timespan(0), const InsertHandler& handler = [](FileCache& cache, const std::string& key, const std::string& value, const Timespan& timeout){ return cache.insert(key, value, timeout); });
 
 
    bool find_path(const CppCommon::Path& path);
 
    bool find_path(const CppCommon::Path& path, Timestamp& timeout);
 
 
    bool remove_path(const CppCommon::Path& path);
 
    void clear();
 
    void watchdog(const UtcTimestamp& utc = UtcTimestamp());
 
    void swap(FileCache& cache) noexcept;
    friend void swap(FileCache& cache1, FileCache& cache2) noexcept;
 
private:
    mutable std::shared_mutex _lock;
    Timestamp _timestamp;
 
    struct MemCacheEntry
    {
        std::string value;
        Timestamp timestamp;
        Timespan timespan;
 
        MemCacheEntry() = default;
        MemCacheEntry(const std::string& v, const Timestamp& ts = Timestamp(), const Timespan& tp = Timespan()) : value(v), timestamp(ts), timespan(tp) {}
        MemCacheEntry(std::string&& v, const Timestamp& ts = Timestamp(), const Timespan& tp = Timespan()) : value(v), timestamp(ts), timespan(tp) {}
    };
 
    struct FileCacheEntry
    {
        std::string prefix;
        InsertHandler handler;
        Timestamp timestamp;
        Timespan timespan;
 
        FileCacheEntry() = default;
        FileCacheEntry(const std::string& pfx, const InsertHandler& h, const Timestamp& ts = Timestamp(), const Timespan& tp = Timespan()) : prefix(pfx), handler(h), timestamp(ts), timespan(tp) {}
    };
 
    std::unordered_map<std::string, MemCacheEntry> _entries_by_key;
    std::map<Timestamp, std::string> _entries_by_timestamp;
    std::map<CppCommon::Path, FileCacheEntry> _paths_by_key;
    std::map<Timestamp, CppCommon::Path> _paths_by_timestamp;
 
    bool remove_internal(const std::string& key);
    bool insert_path_internal(const CppCommon::Path& path, const std::string& prefix, const Timespan& timeout, const InsertHandler& handler);
    bool remove_path_internal(const CppCommon::Path& path);
};
 
} // namespace CppCommon
 
#include "filecache.inl"
 
#endif // CPPCOMMON_CACHE_FILECACHE_H