Cache.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include <string>
#include <istream>
#include <future>
#include <mutex>
#include <ostream>
#include <optional>
#include <utility>
#include <filesystem>
#include <map>
#include <chrono>
#include "Constants.h"
#include "Signals.h"

namespace rose {

    using CacheURI = std::string;           
    using CacheObjectURI = std::string;     

    class CacheObject;

    class CacheLocalStore {
    public:
        CacheLocalStore() = default;
        virtual ~CacheLocalStore() = default;

        virtual CacheError create(const CacheObject &object) = 0;

        virtual bool find(const CacheObject &object) = 0;

        virtual std::ofstream openWrite(const CacheObject &object, bool temp) = 0;

        virtual void moveFromTemp(const CacheObject &object) = 0;

        virtual void
        setCacheTime(const CacheObject &object, std::chrono::system_clock::duration cacheTimeInc) = 0;

        virtual void removeTemp(const CacheObject &object) = 0;

        virtual std::ifstream openRead(const CacheObject &object) = 0;

        [[nodiscard]] virtual std::optional<std::string> fileSystemName(const CacheObject &object) const { return std::nullopt; }
    };

    class CacheObject {
    protected:
        std::string mObjectSrcName{};   
        std::string mObjectUsrName{};   

        long mStatusCode;               

        bool mFirstProcess{false};      

    public:
        CacheObject() = delete;
        virtual ~CacheObject() = default;

        explicit CacheObject(std::string srcName, std::string userName = "")
            : mObjectSrcName(std::move(srcName)), mObjectUsrName(std::move(userName)), mStatusCode(0) {}

        [[nodiscard]] const std::string& objectSrcName() const { return mObjectSrcName; }

        [[nodiscard]] const std::string& objectUsrName() const { return mObjectUsrName; }

        void setStatusCode(long statusCode) { mStatusCode = statusCode; }

        [[nodiscard]] long getStatusCode() const { return mStatusCode; }

        void setFirstProcess() { mFirstProcess = true; }

        [[nodiscard]] bool getFirstProcess() const { return mFirstProcess; }
    };

    class CacheSource {
    protected:
        std::chrono::system_clock::duration mCacheValidDuration{};

    public:
        CacheSource();
        virtual ~CacheSource() = default;

        virtual void fetch(CacheObject &cacheObject, std::ostream &ostrm, time_t cacheTime) = 0;

        [[nodiscard]] auto cacheValidDuration() const { return mCacheValidDuration; }
    };

    class Cache : public std::map<uint32_t,CacheObject> {
    protected:
        std::unique_ptr<CacheLocalStore> localStore;     
        std::unique_ptr<CacheSource> source;             

    public:
        Cache() = default;
        virtual ~Cache() = default;

        template<typename S>
        std::optional<uint32_t> findByUserName(S userName) {
            std::string un{userName};
            for (auto & it : *this) {
                if (it.second.objectUsrName() == un)
                    return it.first;
            }
            return std::nullopt;
        }
    };

    class CacheFileSystem : public CacheLocalStore {
    protected:
        std::error_code mErrorCode;         
        std::filesystem::path mRootPath;    

    public:
        CacheFileSystem() = delete;
        ~CacheFileSystem() override = default;

        explicit operator bool() const noexcept {
            return mErrorCode.operator bool();
        }

        explicit CacheFileSystem(std::filesystem::path rootPath);

        explicit CacheFileSystem(const std::string& rootPath) : CacheFileSystem(std::filesystem::path(rootPath)) {}

        CacheFileSystem(const std::filesystem::path& rootPath, const std::string& cacheName) : CacheFileSystem(rootPath) {
            mRootPath.append(cacheName);
            if (!mErrorCode)
                std::filesystem::create_directory(mRootPath, mErrorCode);
        }

        [[nodiscard]] const std::filesystem::path& rootPath() const { return mRootPath; }

        CacheError create(const CacheObject &object) override;

        bool find(const CacheObject &object) override;

        std::ofstream openWrite(const CacheObject &object, bool temp) override;

        std::ifstream openRead(const CacheObject &object) override;

        void moveFromTemp(const CacheObject &object) override;

        void removeTemp(const CacheObject &object) override;

        void setCacheTime(const CacheObject &object, std::chrono::system_clock::duration cacheTimeInc) override;

        [[nodiscard]] std::optional<std::string> fileSystemName(const CacheObject &object) const override;
    };

    class CacheWebSource : public CacheSource {
    protected:
        std::string mSourceURI;     
        long mResponseCode{0};      

    public:
        CacheWebSource() = delete;
        ~CacheWebSource() override = default;

        explicit CacheWebSource(std::string  sourceURI);

        CacheWebSource(std::string sourceURI, std::chrono::system_clock::duration cacheValidityDuration);

        void fetch(CacheObject &cacheObject, std::ostream &ostrm, time_t cacheTime) override;

        [[nodiscard]] long responseCode() const { return mResponseCode; }

        [[nodiscard]] const std::string& sourceURI() const { return mSourceURI; }
    };

    class WebFileCache : public Cache {
    protected:
        WebFileCache();

        SignalSerialNumber mSignalSerialNumber{};   

        std::mutex mMutex;      

        std::shared_ptr<Slot<int>> mCheckValidity;      
        std::shared_ptr<Slot<int>> mCheckFutures;       

        std::vector<std::future<uint32_t>> mFutureList;  

        void checkFutures();    

        static uint32_t asyncFetch(WebFileCache *self, uint32_t id, time_t cacheTime);

    public:
        ~WebFileCache() override = default;

        WebFileCache(const std::string& sourceURI,
                     const std::filesystem::path& rootPath, const std::string& cacheName);

        WebFileCache(const std::string& sourceURI, const std::filesystem::path& rootPath,
                     const std::string& cacheName, std::chrono::system_clock::duration cacheValidityDuration);

        void connect(Signal<int> &futureCheck, Signal<int> &validityCheck);

        Signal<uint32_t> itemFetched{};     

        explicit operator bool() const { return localStore.operator bool(); } 

        [[nodiscard]] auto cacheRootPath() const {
            return dynamic_cast<CacheFileSystem*>(localStore.get())->rootPath();
        }

        void fetchAll();
    };
}