BufferIn.h

 
#ifndef ACTIVE_UTILITY_BUFFER_IN
#define ACTIVE_UTILITY_BUFFER_IN
 
#include "Active/File/Interface/IOBase.h"
#include "Active/Utility/Memory.h"
#include "Active/Utility/String.h"
#include "Active/Utility/TextEncoding.h"
 
namespace active::file {
    
    class File;
    
}
 
namespace active::utility {
    
    class Memory;
    
    class BufferIn: public file::IOBase {
    public:
        
        using enum TextEncoding;
        
        // MARK: - Constructors
        
        BufferIn(const file::File& sourceFile, DataFormat::Option format = DataFormat{});
        BufferIn(const Memory& sourceMem, DataFormat::Option format = DataFormat{});
        BufferIn(const String& sourceString, DataFormat::Option format = DataFormat{});
        BufferIn(BufferIn&& source)noexcept;
        
        BufferIn(const BufferIn&) = delete;
        
        // MARK: - Operators
        
        BufferIn& operator= (BufferIn&& source) noexcept;
            //No assignment
        BufferIn& operator= (const BufferIn&) = delete;
        operator bool () const { return !fail(); }
        const BufferIn& operator>>(String& str) const { str = readWord(); return *this; }
        const BufferIn& operator>>(int16_t& val) const { return getValue(val); }
        const BufferIn& operator>>(int32_t& val) const { return getValue(val); }
        const BufferIn& operator>>(uint32_t& val) const { return getValue(val); }
        const BufferIn& operator>>(int64_t& val) const { return getValue(val); }
        const BufferIn& operator>>(uint64_t& val) const { return getValue(val); }
        const BufferIn& operator>>(double& val) const;
        
        // MARK: - Functions (const)
        
        const char* data() const { return !good() ? nullptr : m_buffer; }
        Memory::size_type dataSize() const { return (!good() || (m_readPos >= m_bufferLen)) ? 0 : m_bufferLen - m_readPos; }
        Memory::size_type sourceSize() const;
        Memory::size_type getLastRow() const { return m_lastRow; }
        Memory::size_type getLastColumn() const { return m_lastColumn; }
        Memory::size_type getPosition() const;
        TextEncoding textEncoding() const { return m_format.encoding; }
        void forEach(const String::Function& func, String* pool = nullptr) const;
        bool findIf(const String::Filter& filter, String* pool = nullptr, bool isFoundSkipped = false) const;
        bool find(char32_t toFind, String* pool = nullptr, bool isFoundSkipped = false) const;
        bool find(const String& toFind, String* pool = nullptr, bool isFoundSkipped = false) const
                { return seek(toFind, pool, true, true, true, false, isFoundSkipped, false); }
        bool findFirstOf(const String& toFind, String* pool = nullptr, bool isContiguousMatch = false, bool isRepeatMatch = false,
                         bool isFoundSkipped = false, bool isFoundPooled = false, std::optional<char32_t> escapeChar = std::nullopt) const
                { return seek(toFind, pool, isContiguousMatch, false, false, isRepeatMatch, isFoundSkipped, isFoundPooled, escapeChar); }
        bool findFirstNotOf(const String& toFind, String* pool = nullptr, std::optional<char32_t> escapeChar = std::nullopt) const
                { return seekNot(toFind, pool); }
        const BufferIn& get(unsigned char& dest) const;
        Memory::size_type getEncodedChar(String& encodedChar, bool isConsumed = true) const;
        std::pair<char32_t, String::size_type> getEncodedChar(bool isConsumed = true) const;
        const BufferIn& get(String& dest) const;
        const BufferIn& read(char* dest, Memory::size_type& howMany) const;
        String readWord(const String& division = String::allWhiteSpace) const;
        std::vector<String> readWords(Memory::sizeOption howMany = std::nullopt, const String& division = String::allWhiteSpace) const;
        template<class T>
        const BufferIn& getValue(T& val) const {
            if (std::optional<T> temp{ readWord() }; temp)
                val = *temp;
            else {
                setState(std::ios_base::failbit);
                val = T();
            }
            return *this;
        }
        const BufferIn& getString(String& dest, String::sizeOption howMany = std::nullopt) const;
        const BufferIn& getLine(String& line, bool keepStop = true) const;
        const BufferIn& skip(Memory::size_type howMany) const;
        const BufferIn& rewind(Memory::size_type howMany) const;
        void setPosition(Memory::size_type pos) const;
 
        // MARK: - Functions (mutating)
        
        void swap(BufferIn& other);
        void setFormat(DataFormat format) { m_format = format; }
        void setSourceEncoding(TextEncoding encoding) { m_format.encoding = encoding; }
        void setSource(const file::File& sourceFile, DataFormat::Option format = DataFormat{});
        void setSource(const Memory& sourceMem, DataFormat::Option format = DataFormat{});
        void setSource(const String& sourceString, DataFormat::Option format = DataFormat{});
        
    private:
        void bumpReadPos(Memory::size_type howMany) const;
        bool checkEndOfFile() const;
        Memory::size_type bufferMin(Memory::size_type minLength) const;
        bool refillBuffer() const;
        bool seek(const String& toFind, String* pool, bool isAllMatched, bool isContiguousMatch, bool isOrderedMatch,
                  bool isRepeatMatch, bool isFoundSkipped, bool isFoundPooled, std::optional<char32_t> escapeChar = std::nullopt) const;
        bool seekNot(const String& toFind, String* pool, std::optional<char32_t> escapeChar = std::nullopt) const;
        void updatePosition(unsigned char incoming, uint8_t size = 1) const;
        Memory::size_type getCapacity() const;
        Memory::size_type getSupplyCount() const { return (m_bufferLen - m_readPos) + m_remaining; }
        DataFormat discoverFormat();
        void initialise(char* pointerSrc, const file::File* fileSrc, Memory::size_type dataLen);
        
        char* m_buffer = nullptr;
        const file::File* m_file = nullptr;
        std::unique_ptr<Memory> m_fileCache;
        DataFormat m_format;
        mutable Memory::size_type m_readPos = 0;
        mutable Memory::size_type m_bufferLen = 0;
        mutable Memory::size_type m_remaining = 0;
        mutable Memory::size_type m_lastRow = 0;
        mutable Memory::size_type m_lastColumn = 0;
        mutable bool m_foundCR = false;
    };
    
    void swap(BufferIn& v1, BufferIn& v2);
}
 
#endif  //ACTIVE_UTILITY_BUFFER_IN