BufferOut.h

 
#ifndef ACTIVE_UTILITY_BUFFER_OUT
#define ACTIVE_UTILITY_BUFFER_OUT
 
#include "Active/File/Interface/IOBase.h"
#include "Active/Utility/Memory.h"
#include "Active/Utility/String.h"
#include "Active/Utility/DataFormat.h"
 
namespace active::file {
    
    class File;
 
}
 
namespace active::utility {
    
        //Class to buffer data to a specified destination
    class BufferOut: public file::IOBase {
    public:
        using enum utility::TextEncoding;
        
        BufferOut();
        BufferOut(file::File& destFile, Memory::sizeOption bufferSize = std::nullopt, DataFormat format = DataFormat{});
        BufferOut(Memory& memory, Memory::sizeOption bufferSize = std::nullopt, DataFormat format = DataFormat{});
        BufferOut(Memory&& memory, Memory::sizeOption bufferSize = std::nullopt, DataFormat format = DataFormat{});
        BufferOut(String& destString, Memory::sizeOption bufferSize = std::nullopt, DataFormat format = DataFormat{});
        BufferOut(BufferOut&& source) noexcept;
            //No copy constructor
        BufferOut(const BufferOut& source) = delete;
        virtual ~BufferOut();
        
        //MARK: - Operators
        
        BufferOut& operator= (BufferOut&& source) noexcept;
            //No assignment
        BufferOut& operator= (const BufferOut&) = delete;
        operator bool () const { return !fail(); }
        const BufferOut& operator<<(char val) const { return write(val); }
        const BufferOut& operator<<(const String& str) const { return write(str); }
        const BufferOut& operator<<(int16_t val) const { return write(String{val}); }
        const BufferOut& operator<<(int32_t val) const { return write(String{val}); }
        const BufferOut& operator<<(uint32_t val) const { return write(String{val}); }
        const BufferOut& operator<<(int64_t val) const { return write(String{val}); }
#ifndef WINDOWS
        const BufferOut& operator<<(uint64_t val) const { return write(String{val}); }
#endif
        const BufferOut& operator<<(double val) const { return write(String{val}); }
        
        // MARK: - Functions (const)
 
        Memory::sizeOption maxSize() const;
        Memory::sizeOption getPosition() const;
        DataFormat format() const { return m_format; }
        TextEncoding getEncoding() const { return m_format.encoding; }
        const BufferOut& write(const String& toWrite) const { return write(toWrite, m_format); }
        const BufferOut& write(const String& toWrite, DataFormat format) const;
        const BufferOut& write(const char* toWrite, Memory::size_type length) const;
        const BufferOut& write(unsigned char toWrite) const;
        template<class T>
        const BufferOut& writeBinary(const T& obj) const {
            return write(reinterpret_cast<const char*>(&obj), sizeof(obj));
        }
        const BufferOut& flush() const { return flushBuffer(); }
        
        // MARK: - Functions (mutating)
        
        void setDestination(file::File* destFile);
        void setDestination(Memory* memory);
        void setDestination(String* destString);
        void setEncoding(TextEncoding encoding) { m_format.encoding = encoding; }
        
    protected:
        virtual bool isMyBuffer() const { return m_buffer.owned(); }
        const Memory& getBuffer() const { return m_buffer; }
        void setBuffer(void* buffer, Memory::size_type size) const { m_buffer = Memory{buffer, size}; }
        virtual bool confirmBuffer() const;
 
    private:
        static constexpr Memory::size_type defaultBufferSize = 0xF000;
 
        const BufferOut& performWrite(const char* toWrite, Memory::size_type length) const;
        const BufferOut& flushBuffer() const;
        void initialise(Memory* memory = nullptr, file::File* fileDest = nullptr, utility::String* stringDest = nullptr);
        
        file::File* m_file;
        Memory* m_memory;
        String* m_str;
        Memory::Unique m_cache;
        mutable Memory m_buffer;
        DataFormat m_format;
        mutable Memory::size_type m_bufferPos;
        Memory::size_type m_bufferSizeTip = defaultBufferSize;
    };
    
}
 
#endif  //ACTIVE_UTILITY_BUFFER_OUT