File.h

 
#ifndef ACTIVE_FILE_FILE
#define ACTIVE_FILE_FILE
 
#include "Active/File/Interface/FSNode.h"
#include "Active/File/Interface/IOBase.h"
#include "Active/Utility/Memory.h"
 
#include <fstream>
#include <optional>
 
namespace active::file {
    
    class Directory;
 
    class File : public FSNode, public IOBase {
    public:
 
        using enum utility::TextEncoding;
 
        // MARK: - Types
        
        using Unique = std::unique_ptr<File>;
        using Shared = std::shared_ptr<File>;
        enum Anchor {
            start,
            current,
            end,
        };
        
        using size_type = std::fstream::off_type;
        using sizeOption = std::optional<size_type>;
        using pos_type = std::fstream::pos_type;
        using posOption = std::optional<pos_type>;
        
        enum class Permission {
            readOnly,
            writeOnly,
            overWrite,
            readWrite,
            append
        };
        
        using enum Permission;
        
        // MARK: - Constants
        
        static const size_type defBufferSize;
        
        // MARK: - Constructors
        
        File();
        File(const Path& path, Permission perm = readWrite, bool isMissingCreated = false, bool canReplaceDirectory = false);
        File(const Directory& parent, const utility::String& name, Permission perm = readWrite,
             bool isMissingCreated = false, bool canReplaceDirectory = false);
        File(const File& source);
        virtual ~File();
        
        virtual File* clonePtr() const override { return new File(*this); }
        
        // MARK: - Operators
        
            //Operators
        void operator= (const File& source);
        bool operator== (const File& ref) const;
        
        // MARK: - Functions (const)
        
        void open(std::optional<Permission> perm = std::nullopt) const;
        void close() const noexcept;
        bool isOpen() const noexcept;
        bool isWritable() const noexcept { return m_permission != readOnly; }
        pos_type getPosition() const;
        void setPosition(pos_type pos) const;
        void setPosition(size_type pos, Anchor anchor = Anchor::start) const;
        size_type size() const;
        size_type remaining() const;
        size_type read(utility::String& text, sizeOption howMany = std::nullopt, utility::TextEncoding encoding = UTF8) const;
        size_type read(utility::Memory& memory, sizeOption howMany = std::nullopt) const;
        virtual bool good() const noexcept override { return m_file ? m_file->good() : false; }
        virtual bool eof() const noexcept override { return m_file ? m_file->eof() : true; }
        virtual bool fail() const noexcept override { return m_file ? m_file->fail() : true; }
        virtual bool bad() const noexcept override { return m_file ? m_file->bad() : true; }
        
        // MARK: - Functions (mutating)
        void resize(size_type fileSize);
        void write(const utility::String& text, utility::String::sizeOption howMany = std::nullopt, utility::TextEncoding encoding = UTF8);
        void write(const utility::Memory& data, sizeOption howMany = std::nullopt);
        bool write(const File& file);
        virtual void remove(bool isRecursive = true) override;
        void flush();
        virtual void clear(flag_type f = std::ios_base::goodbit) override { if (m_file) m_file->clear(f); }
        virtual void setState(flag_type f) noexcept override { if (m_file) m_file->setstate(f); }
 
    private:
        void validate(bool confirmOpen = true) const;
        
        mutable std::unique_ptr<std::fstream> m_file;
        mutable Permission m_permission;
    };
 
}
 
#endif  //ACTIVE_FILE_FILE