file-desc.hpp

Go to the documentation of this file.

/*
 * This file is part of libkazv.
 * SPDX-FileCopyrightText: 2021 Tusooa Zhu <tusooa@kazv.moe>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
 
#pragma once
#include "libkazv-config.hpp"
 
#include <optional>
#include <string>
#include <variant>
#include <functional>
#include <immer/box.hpp>
#include <immer/flex_vector.hpp>
 
namespace Kazv
{
    enum struct FileOpRetCode
    {
        Error,
        Success,
        Eof
    };
 
    enum struct FileOpenMode
    {
        Read,
        Write
    };
 
    using FileContent = immer::flex_vector<char>;
 
    class FileStream
    {
    public:
        using DataT = FileContent;
 
        template<class DeriveT>
        FileStream(DeriveT &&o)
            : m_d(std::make_unique<Model<std::decay_t<DeriveT>>>(
                      std::forward<DeriveT>(o))) {}
 
        template<class Callback>
        void read(int maxSize, Callback readCallback) { m_d->read(maxSize, readCallback); }
 
        template<class Callback>
        void write(DataT data, Callback writeCallback) { m_d->write(data, writeCallback); }
 
 
    private:
        struct Concept
        {
            virtual ~Concept() = default;
            using ReadCallback = std::function<void(FileOpRetCode, DataT)>;
            using WriteCallback = std::function<void(FileOpRetCode, int)>;
 
            virtual void read(int maxSize, ReadCallback callback) = 0;
            virtual void write(DataT data, WriteCallback callback) = 0;
        };
 
        template<class DeriveT>
        struct Model : public Concept
        {
            explicit Model(const DeriveT &o) : obj(o) {}
            explicit Model(DeriveT &&o) : obj(std::move(o)) {}
            ~Model() override = default;
            void read(int maxSize, ReadCallback callback) override {
                return obj.read(maxSize, callback);
            }
            void write(DataT data, WriteCallback callback) override {
                return obj.write(data, callback);
            }
 
            DeriveT obj;
        };
 
        std::unique_ptr<Concept> m_d;
    };
 
    class FileProvider
    {
    public:
        template<class DeriveT>
        FileProvider(DeriveT &&o)
            : m_d(std::make_unique<Model<std::decay_t<DeriveT>>>(
                      std::forward<DeriveT>(o))) {}
 
        inline FileProvider(const FileProvider &that) : m_d(that.m_d->clone()) {}
        inline FileProvider(FileProvider &&that) : m_d(std::move(that.m_d)) {}
 
        inline FileProvider &operator=(const FileProvider &that) {
            m_d = that.m_d->clone();
            return *this;
        }
 
        inline FileProvider &operator=(FileProvider &&that) {
            m_d = std::move(that.m_d);
            return *this;
        }
 
        inline FileStream getStream(FileOpenMode mode = FileOpenMode::Read) const {
            return m_d->getStream(mode);
        }
 
    private:
        struct Concept
        {
            virtual ~Concept() = default;
            virtual std::unique_ptr<Concept> clone() const = 0;
            virtual FileStream getStream(FileOpenMode mode) const = 0;
        };
 
        template<class DeriveT>
        struct Model : public Concept
        {
            explicit Model(const DeriveT &o) : obj(o) {}
            explicit Model(DeriveT &&o) : obj(std::move(o)) {}
            ~Model() override = default;
            std::unique_ptr<Concept> clone() const override {
                return std::make_unique<Model>(obj);
            }
            FileStream getStream(FileOpenMode mode) const override {
                return obj.getStream(mode);
            }
 
            DeriveT obj;
        };
 
        std::unique_ptr<Concept> m_d;
    };
 
    class FileDesc;
 
    class FileInterface;
 
    struct DumbFileStream
    {
        inline explicit DumbFileStream(FileContent r) : remaining(r) {}
 
        template<class Callback>
        void read(int maxSize, Callback callback) {
            if (remaining.empty()) {
                callback(FileOpRetCode::Eof, remaining);
            } else {
                auto taken = remaining.take(maxSize);
                remaining = remaining.drop(maxSize);
                callback(FileOpRetCode::Success, taken);
            }
        }
 
        template<class Callback>
        void write(FileContent data, Callback callback) {
            remaining = remaining + data;
            callback(FileOpRetCode::Success, data.size());
        }
 
        FileContent remaining;
    };
 
    struct DumbFileProvider
    {
        inline explicit DumbFileProvider(FileContent content)
            : m_content(content)
            {}
 
        inline DumbFileStream getStream(FileOpenMode /* mode */) const {
            return DumbFileStream(m_content);
        }
 
        FileContent m_content;
    };
 
    class FileDesc
    {
    public:
        explicit FileDesc(FileContent content)
            : m_inMemory{true}
            , m_content(content)
            {}
 
        explicit FileDesc(std::string name,
                          std::optional<std::string> contentType = std::nullopt)
            : m_inMemory{false}
            , m_name(std::move(name))
            , m_contentType(std::move(contentType)) {}
 
        FileProvider provider(const FileInterface &fh) const;
 
        inline std::optional<std::string> name() const { return m_name; }
 
        inline std::optional<std::string> contentType() const { return m_contentType; }
 
        bool operator==(const FileDesc &that) const;
 
    private:
        bool m_inMemory;
        FileContent m_content;
        std::optional<std::string> m_name;
        std::optional<std::string> m_contentType;
    };
 
    class DumbFileInterface
    {
    public:
        DumbFileProvider getProviderFor(FileDesc desc) const;
    };
 
    class FileInterface
    {
    public:
        template<class DeriveT>
        inline FileInterface(DeriveT &&o)
            : m_d(std::make_unique<Model<std::decay_t<DeriveT>>>(
                      std::forward<DeriveT>(o))) {}
 
        inline FileProvider getProviderFor(FileDesc desc) const {
            return m_d->getProviderFor(std::move(desc));
        }
 
    private:
        struct Concept
        {
            virtual ~Concept() = default;
            virtual FileProvider getProviderFor(FileDesc desc) const = 0;
        };
 
        template<class DeriveT>
        struct Model : public Concept
        {
            explicit Model(const DeriveT &o) : obj(o) {}
            explicit Model(DeriveT &&o) : obj(std::move(o)) {}
            ~Model() override = default;
            FileProvider getProviderFor(FileDesc desc) const override {
                return obj.getProviderFor(std::move(desc));
            }
 
            DeriveT obj;
        };
 
        std::unique_ptr<Concept> m_d;
    };
}