simple.hxx

#pragma once
 
#include <StormByte/buffer/exception.hxx>
#include <StormByte/buffer/typedefs.hxx>
#include <StormByte/visibility.h>
 
#include <functional>
 
namespace StormByte::Buffer {
    class STORMBYTE_PUBLIC Simple {
        public:
            Simple() noexcept;
 
            explicit Simple(const std::size_t& size);
 
            Simple(const char* data, const std::size_t& length);
 
            Simple(const std::string& data);
 
            Simple(const Data& data);
 
            Simple(Data&& data);
 
            Simple(const std::span<const Byte>& data);
 
            Simple(const Simple& other)                                             = default;
 
            Simple(Simple&& other) noexcept                                         = default;
 
            virtual ~Simple() noexcept                                              = default;
 
            Simple& operator=(const Simple& other)                                  = default;
 
            Simple& operator=(Simple&& other) noexcept                              = default;
 
            virtual Simple&                                                         operator<<(const Data& data);
 
            virtual Simple&                                                         operator<<(Data&& data);
 
            virtual Simple&                                                         operator<<(const Simple& buffer);
 
            virtual Simple&                                                         operator<<(Simple&& buffer);
 
            virtual Simple&                                                         operator<<(const std::string& data);
 
            template <typename NumericType, typename = std::enable_if_t<std::is_arithmetic_v<std::decay_t<NumericType>>>>
            Simple& operator<<(const NumericType& value) {
                const auto* raw_data = reinterpret_cast<const std::byte*>(&value);
                m_data.insert(m_data.end(), raw_data, raw_data + sizeof(NumericType));
                return *this;
            }
 
            virtual Simple&                                                         operator>>(Simple& buffer);
 
            virtual size_t                                                          AvailableBytes() const noexcept;
 
            virtual size_t                                                          Capacity() const noexcept;
 
            virtual void                                                            Clear();
 
            virtual Buffer::Data                                                    Data() const noexcept;
 
            virtual void                                                            Discard(const std::size_t& length, const Read::Position& mode = Read::Position::Relative) noexcept;
 
            virtual bool                                                            Empty() const noexcept;
 
            virtual bool                                                            End() const noexcept;
 
            virtual ExpectedData<BufferOverflow>                                    Extract(const size_t& length);
 
            virtual Read::Status                                                    ExtractInto(const size_t& length, Simple& output) noexcept;
 
            virtual bool                                                            HasEnoughData(const std::size_t& length) const;
 
            virtual std::string                                                     HexData(const std::size_t& column_size = 16) const;
 
            virtual bool                                                            IsEoF() const noexcept;
 
            virtual ExpectedByte<BufferOverflow>                                    Peek() const;
 
            virtual std::size_t                                                     Position() const noexcept;
 
            Read::Status                                                            Process(const std::size_t& length, Processor function, Simple& output) noexcept;
 
            virtual ExpectedData<BufferOverflow>                                    Read(const size_t& length) const;
 
            virtual void                                                            Reserve(const std::size_t& size);
 
            virtual void                                                            Seek(const std::ptrdiff_t& position, const Read::Position& mode) const;
 
            virtual std::size_t                                                     Size() const noexcept;
 
            const std::span<const Byte>                                             Span() const noexcept;
 
            std::span<Byte>                                                         Span() noexcept;
 
            virtual Write::Status                                                   Write(const Buffer::Data& data);
 
            virtual Write::Status                                                   Write(Buffer::Data&& data);
 
            virtual Write::Status                                                   Write(const Simple& buffer);
 
            virtual Write::Status                                                   Write(Simple&& buffer);
 
            virtual Write::Status                                                   Write(const std::string& data);
 
        protected:
            std::vector<std::byte> m_data;                                          
            mutable std::size_t m_position;                                         
            mutable std::size_t m_minimum_chunk_size;                               
    };
}