Cache.h

#pragma once
 
#include <unordered_map>
#include <map>
#include <mutex>
#include <atomic>
#include <vector>
 
#include "Utility.h"
 
namespace file_manager
{
    class FileManager;
 
    class FILE_MANAGER_API Cache
    {
    public:
        enum class CacheResultCodes
        {
            noError,
            fileDoesNotExist,
            notEnoughCacheSize
        };
 
    private:
        std::unordered_map<std::filesystem::path, std::string, utility::pathHash> cacheData;
        uint64_t cacheSize;
        std::atomic<uint64_t> currentCacheSize;
        mutable std::mutex cacheDataMutex;
 
    private:
        void updateCache();
 
        static Cache& getCache();
 
    private:
        Cache();
 
        ~Cache() = default;
 
    public:
        CacheResultCodes addCache(const std::filesystem::path& filePath, std::ios_base::openmode mode);
 
        CacheResultCodes appendCache(const std::filesystem::path& filePath, const std::vector<char>& data);
 
        CacheResultCodes appendCache(const std::filesystem::path& filePath, std::string_view data);
 
        bool contains(const std::filesystem::path& filePath) const;
 
        void clear();
 
        void clear(const std::filesystem::path& filePath);
 
        void setCacheSize(uint64_t sizeInBytes);
 
        const std::string& getCacheData(const std::filesystem::path& filePath) const;
 
        uint64_t getCacheSize() const;
 
        uint64_t getCurrentCacheSize() const;
 
        const std::string& operator [] (const std::filesystem::path& filePath) const;
 
        friend void _utility::addCache(std::filesystem::path&& filePath, std::string&& data);
 
        template<template<typename> typename OperationT> requires _utility::Operation<OperationT<uint64_t>>
        friend void _utility::changeCurrentCacheSize(uint64_t amount);
 
        friend class FileManager;
    };
 
    namespace _utility
    {
        template<template<typename> typename OperationT> requires _utility::Operation<OperationT<uint64_t>>
        void changeCurrentCacheSize(uint64_t amount)
        {
            Cache& cache = Cache::getCache();
 
            cache.currentCacheSize = OperationT<uint64_t>()(cache.currentCacheSize, amount);
        }
    }
}