BinaryFile.h

Go to the documentation of this file.

#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/File/FileException.h"
#include <cstdint>
#include <fstream>
#include <iterator>
#include <memory>
#include <mutex>
#include <ostream>
#include <vector>
 
namespace inno
{

     */
    class BinaryFileAccess
    {
    public:
        virtual std::vector<uint8_t> ReadAll(const std::string& path) = 0;
        virtual void WriteAll(const std::string& path, const std::vector<uint8_t>& content) = 0;
 
        BinaryFileAccess() = default;
        virtual ~BinaryFileAccess() = default;
        BinaryFileAccess(const BinaryFileAccess&) = delete;
        BinaryFileAccess(BinaryFileAccess&&) = delete;
        BinaryFileAccess& operator=(const BinaryFileAccess&) = delete;
        BinaryFileAccess& operator=(BinaryFileAccess&&) = delete;
    };

     */
    class FilesystemAccess : public BinaryFileAccess
    {
    public:
        static std::shared_ptr<FilesystemAccess> Create()
        {
            return std::shared_ptr<FilesystemAccess>(new FilesystemAccess());
        }
         */
        std::vector<uint8_t> ReadAll(const std::string& path) final
        {
            try
            {
                std::ifstream file(path, std::ios::binary | std::ios::in);
                file.exceptions(~std::ifstream::goodbit);
                return { (std::istreambuf_iterator<char>(file)), (std::istreambuf_iterator<char>()) };
            }
            catch (...)
            {
                std::string errorMessage = path + ": " + std::error_code(errno, std::generic_category()).message();
                throw FileException(std::move(errorMessage));
            }
        }

         */
        void WriteAll(const std::string& path, const std::vector<uint8_t>& content) final
        {
            try
            {
                std::ofstream file(path, std::ios::out | std::ios::binary);
                file.exceptions(~std::ofstream::goodbit);
                const std::ostream_iterator<uint8_t> outputIterator(file);
                std::copy(content.begin(), content.end(), outputIterator);
            }
            catch (...)
            {
                std::string errorMessage = path + ": " + std::error_code(errno, std::generic_category()).message();
                throw FileException(std::move(errorMessage));
            }
        }
 
        virtual ~FilesystemAccess() = default;
        FilesystemAccess(const FilesystemAccess&) = delete;
        FilesystemAccess(FilesystemAccess&&) = delete;
        FilesystemAccess& operator=(const FilesystemAccess&) = delete;
        FilesystemAccess& operator=(FilesystemAccess&&) = delete;
 
    private:
        FilesystemAccess() = default;
    };

     */
    class GlobalFileAccess
    {
    public:
         */
        static std::shared_ptr<BinaryFileAccess> Get()
        {
            return GlobalFileAccess::Instance().GetInternal();
        }

         */
        static void Set(const std::shared_ptr<BinaryFileAccess>& fileAccess)
        {
            if (fileAccess == nullptr)
            {
                throw NullArgumentException("BinaryFileAccess can not be null");
            }
 
            GlobalFileAccess::Instance().SetInternal(fileAccess);
        }
 
        GlobalFileAccess() = delete;
        virtual ~GlobalFileAccess() = default;
        GlobalFileAccess(const GlobalFileAccess&) = delete;
        GlobalFileAccess(GlobalFileAccess&&) = delete;
        GlobalFileAccess& operator=(const GlobalFileAccess&) = delete;
        GlobalFileAccess& operator=(GlobalFileAccess&&) = delete;
 
    private:
        std::shared_ptr<BinaryFileAccess> fa;
        std::mutex faMux;
 
        std::shared_ptr<BinaryFileAccess> GetInternal()
        {
            const std::scoped_lock lock(faMux);
            return fa;
        }
 
        static GlobalFileAccess& Instance()
        {
            static GlobalFileAccess e(FilesystemAccess::Create());
            return e;
        }
 
        void SetInternal(const std::shared_ptr<BinaryFileAccess>& fileAccess)
        {
            if (fileAccess != nullptr)
            {
                UpdateFileAccess(fileAccess);
            }
            else
            {
                UpdateFileAccess(FilesystemAccess::Create());
            }
        }
 
        explicit GlobalFileAccess(std::shared_ptr<BinaryFileAccess> e)
          : fa(std::move(e))
        {
        }
 
        void UpdateFileAccess(std::shared_ptr<BinaryFileAccess> fileAccess)
        {
            const std::scoped_lock lock(faMux);
            fa = std::move(fileAccess);
        }
    };
 
    class BinaryFile final
    {
    public:
        static std::vector<uint8_t> ReadAll(const std::string& path)
        {
            return GlobalFileAccess::Get()->ReadAll(path);
        }

        static void WriteAll(const std::string& path, const std::vector<uint8_t>& content)
        {
            GlobalFileAccess::Get()->WriteAll(path, content);
        }
 
        BinaryFile() = default;
        BinaryFile(const BinaryFile&) = delete;
        BinaryFile(BinaryFile&&) = delete;
        BinaryFile& operator=(const BinaryFile&) = delete;
        BinaryFile& operator=(BinaryFile&&) = delete;
        virtual ~BinaryFile() = default;
    };
 
} // namespace inno