generic.hxx

#pragma once
 
#include <StormByte/buffer/typedefs.hxx>
 
#include <algorithm>
#include <iterator>
#include <ranges>
#include <type_traits>
#include <string_view>
#include <utility>
 
namespace StormByte::Buffer {
    class STORMBYTE_BUFFER_PUBLIC Generic {
        public:
            Generic() noexcept                                              = default;
 
            inline Generic(const DataType& data) noexcept: m_buffer(data) {}
 
            inline Generic(DataType&& data) noexcept: m_buffer(std::move(data)) {}
 
            Generic(const Generic&) noexcept                                = default;
            
            Generic(Generic&&) noexcept                                     = default;
 
            virtual ~Generic() noexcept                                     = 0;
            
            Generic& operator=(const Generic& other)                        = default;
        
            Generic& operator=(Generic&&) noexcept                          = default;
 
        protected:
            DataType m_buffer;                                              
 
            template<std::ranges::input_range Src>
            requires (!std::is_class_v<std::remove_cv_t<std::ranges::range_value_t<Src>>>) &&
                requires(std::ranges::range_value_t<Src> v) { static_cast<std::byte>(v); }
            static DataType DataConvert(const Src& src) noexcept {
                DataType out;
                if constexpr (requires { std::ranges::size(src); }) {
                    auto s = std::ranges::size(src);
                    if (s > 0) out.reserve(static_cast<typename DataType::size_type>(s));
                }
                std::transform(std::ranges::begin(src), std::ranges::end(src), std::back_inserter(out),
                            [] (auto&& e) noexcept { return static_cast<std::byte>(e); });
                return out;
            }
 
            template<std::ranges::input_range Src>
            requires (!std::is_class_v<std::remove_cv_t<std::ranges::range_value_t<Src>>>) &&
                requires(std::ranges::range_value_t<Src> v) { static_cast<std::byte>(v); }
            static DataType DataConvert(Src&& src) noexcept {
                using Dec = std::remove_cvref_t<Src>;
                if constexpr (std::same_as<Dec, DataType>) {
                    return std::move(src);
                } else {
                    DataType out;
                    if constexpr (requires { std::ranges::size(src); }) {
                        auto s = std::ranges::size(src);
                        if (s > 0) out.reserve(static_cast<typename DataType::size_type>(s));
                    }
                    std::transform(std::ranges::begin(src), std::ranges::end(src), std::back_inserter(out),
                               [] (auto&& e) noexcept { return static_cast<std::byte>(e); });
                    return out;
                }
            }
 
            static DataType DataConvert(std::string_view sv) noexcept {
                DataType out;
                if (!sv.empty()) out.reserve(static_cast<typename DataType::size_type>(sv.size()));
                std::transform(sv.begin(), sv.end(), std::back_inserter(out), [] (char c) noexcept { return static_cast<std::byte>(c); });
                return out;
            }
 
            static DataType DataConvert(const char* s) noexcept {
                if (!s) return DataType{};
                return DataConvert(std::string_view(s));
            }
    };
 
    class WriteOnly; // Forward declaration
 
    class STORMBYTE_BUFFER_PUBLIC ReadOnly: virtual public Generic {
        public:
            inline ReadOnly() noexcept: Generic() {};
 
            inline ReadOnly(const DataType& data) noexcept: Generic(data) {}
 
            inline ReadOnly(DataType&& data) noexcept: Generic(std::move(data)) {}
 
            ReadOnly(const ReadOnly&) noexcept                              = default;
            
            ReadOnly(ReadOnly&&) noexcept                                   = default;
 
            virtual ~ReadOnly() noexcept                                    = default;
            
            ReadOnly& operator=(const ReadOnly&)                            = default;
        
            ReadOnly& operator=(ReadOnly&&) noexcept                        = default;
 
            virtual std::size_t                                             AvailableBytes() const noexcept = 0;
 
            virtual void                                                    Clean() noexcept = 0;
 
            virtual void                                                    Clear() noexcept = 0;
 
            virtual const DataType&                                         Data() const noexcept {
                return m_buffer;
            }
 
            virtual bool                                                    Drop(const std::size_t& count) noexcept = 0;
 
            virtual bool                                                    Empty() const noexcept = 0;
 
            virtual bool                                                    EoF() const noexcept = 0;
 
            inline virtual bool                                             Extract(const std::size_t& count, DataType& outBuffer) noexcept = 0;
 
            inline bool                                                     Extract(DataType& outBuffer) noexcept {
                return Extract(0, outBuffer);
            }
 
            inline virtual bool                                             Extract(const std::size_t& count, WriteOnly& outBuffer) noexcept = 0;
 
            inline bool                                                     Extract(WriteOnly& outBuffer) noexcept {
                return Extract(0, outBuffer);
            }
 
            virtual void                                                    ExtractUntilEoF(DataType& outBuffer) noexcept = 0;
 
            virtual void                                                    ExtractUntilEoF(WriteOnly& outBuffer) noexcept = 0;
 
            virtual bool                                                    IsReadable() const noexcept = 0;
 
            virtual bool                                                    Peek(const std::size_t& count, DataType& outBuffer) const noexcept = 0;
 
            virtual bool                                                    Peek(const std::size_t& count, WriteOnly& outBuffer) const noexcept = 0;
 
            virtual bool                                                    Read(const std::size_t& count, DataType& outBuffer) const noexcept = 0;
 
            inline bool                                                     Read(DataType& outBuffer) const noexcept {
                return Read(0, outBuffer);
            }
 
            virtual bool                                                    Read(const std::size_t& count, WriteOnly& outBuffer) const noexcept = 0;
 
            inline bool                                                     Read(WriteOnly& outBuffer) const noexcept {
                return Read(0, outBuffer);
            }
 
            virtual void                                                    ReadUntilEoF(DataType& outBuffer) const noexcept = 0;
 
            virtual void                                                    ReadUntilEoF(WriteOnly& outBuffer) const noexcept = 0;
 
            virtual void                                                    Seek(const std::ptrdiff_t& offset, const Position& mode) const noexcept = 0;
 
            virtual std::size_t                                             Size() const noexcept = 0;
    };
 
    class STORMBYTE_BUFFER_PUBLIC WriteOnly: virtual public Generic {
        public:
            inline WriteOnly() noexcept: Generic() {};
 
            inline WriteOnly(const DataType& data) noexcept: Generic(data) {}
 
            inline WriteOnly(DataType&& data) noexcept: Generic(std::move(data)) {}
 
            WriteOnly(const WriteOnly&)                                     = default;
            
            WriteOnly(WriteOnly&&) noexcept                                 = default;
 
            virtual ~WriteOnly() noexcept                                   = default;
            
            WriteOnly& operator=(const WriteOnly&)                          = default;
        
            WriteOnly& operator=(WriteOnly&&) noexcept                      = default;
 
            virtual bool                                                    IsWritable() const noexcept = 0;
 
            virtual bool                                                    Write(const std::size_t& count, const DataType& data) noexcept = 0;
 
            bool                                                            Write(std::string_view sv) noexcept {
                DataType tmp;
                if (!sv.empty()) tmp.reserve(static_cast<typename DataType::size_type>(sv.size()));
                std::transform(sv.begin(), sv.end(), std::back_inserter(tmp), [] (char e) noexcept { return static_cast<std::byte>(e); });
                return Write(static_cast<std::size_t>(tmp.size()), std::move(tmp));
            }
 
            bool                                                            Write(const char* s) noexcept {
                if (!s) return Write(DataType{});
                return Write(std::string_view(s));
            }
 
            bool                                                            Write(const std::size_t& count, std::string_view sv) noexcept {
                size_t to_write = (count == 0) ? static_cast<size_t>(sv.size()) : std::min(count, static_cast<std::size_t>(sv.size()));
                DataType tmp;
                if (to_write > 0) tmp.reserve(static_cast<typename DataType::size_type>(to_write));
                std::transform(sv.begin(), sv.begin() + to_write, std::back_inserter(tmp), [] (char e) noexcept { return static_cast<std::byte>(e); });
                return Write(static_cast<std::size_t>(to_write), std::move(tmp));
            }
 
            bool                                                            Write(const std::size_t& count, const char* s) noexcept {
                if (!s) return Write(count, DataType{});
                return Write(count, std::string_view(s));
            }
 
            template<std::size_t N>
            bool                                                            Write(const char (&s)[N]) noexcept {
                // N includes the terminating NUL for string literals, so exclude it
                if (N == 0) return Write(DataType{});
                return Write(std::string_view(s, (N > 0) ? (N - 1) : 0));
            }
 
            template<std::ranges::input_range R>
                requires (!std::is_class_v<std::remove_cv_t<std::ranges::range_value_t<R>>>) &&
                requires(std::ranges::range_value_t<R> v) { static_cast<std::byte>(v); }
            bool                                                            Write(const R& r) noexcept {
                DataType tmp;
                if constexpr (requires(DataType& d, typename DataType::size_type n) { d.reserve(n); }) {
                    auto dist = std::ranges::distance(r);
                    if (dist > 0) tmp.reserve(static_cast<typename DataType::size_type>(dist));
                }
                std::transform(std::ranges::begin(r), std::ranges::end(r), std::back_inserter(tmp),
                        [] (auto&& e) noexcept { return static_cast<std::byte>(e); });
                return Write(static_cast<std::size_t>(tmp.size()), std::move(tmp));
            }
 
            template<std::ranges::input_range Rw>
                requires (!std::is_class_v<std::remove_cv_t<std::ranges::range_value_t<Rw>>>) &&
                requires(std::ranges::range_value_t<Rw> v) { static_cast<std::byte>(v); }
            bool                                                            Write(const std::size_t& count, const Rw& r) noexcept {
                if (count == 0) return Write(r);
                DataType tmp;
                if constexpr (requires(DataType& d, typename DataType::size_type n) { d.reserve(n); }) {
                    auto dist = std::ranges::distance(r);
                    if (dist > 0) tmp.reserve(static_cast<typename DataType::size_type>(std::min(dist, static_cast<decltype(dist)>(count))));
                }
                auto it = std::ranges::begin(r);
                auto end = std::ranges::end(r);
                std::size_t written = 0;
                for (; it != end && written < count; ++it, ++written) {
                    tmp.push_back(static_cast<std::byte>(*it));
                }
                return Write(static_cast<std::size_t>(written), std::move(tmp));
            }
 
            template<std::ranges::input_range Rrw>
                requires (!std::is_class_v<std::remove_cv_t<std::ranges::range_value_t<Rrw>>>) &&
                requires(std::ranges::range_value_t<Rrw> v) { static_cast<std::byte>(v); }
            bool                                                            Write(const std::size_t& count, Rrw&& r) noexcept {
                using Dec = std::remove_cvref_t<Rrw>;
                if (count == 0) return Write(std::forward<Rrw>(r));
                if constexpr (std::same_as<Dec, DataType>) {
                    // r is DataType; we can move and resize if needed
                    DataType tmp = std::move(r);
                    if (tmp.size() > count) tmp.resize(count);
                    return Write(static_cast<std::size_t>(tmp.size()), std::move(tmp));
                } else {
                    DataType tmp;
                    if constexpr (requires(DataType& d, typename DataType::size_type n) { d.reserve(n); }) {
                        auto dist = std::ranges::distance(r);
                        if (dist > 0) tmp.reserve(static_cast<typename DataType::size_type>(std::min(dist, static_cast<decltype(dist)>(count))));
                    }
                    auto it = std::ranges::begin(r);
                    auto end = std::ranges::end(r);
                    std::size_t written = 0;
                    for (; it != end && written < count; ++it, ++written) {
                        tmp.push_back(static_cast<std::byte>(*it));
                    }
                    return Write(static_cast<std::size_t>(written), std::move(tmp));
                }
            }
 
            template<std::ranges::input_range Rr>
                requires (!std::is_class_v<std::remove_cv_t<std::ranges::range_value_t<Rr>>>) &&
                requires(std::ranges::range_value_t<Rr> v) { static_cast<std::byte>(v); }
            bool                                                            Write(Rr&& r) noexcept {
                using Dec = std::remove_cvref_t<Rr>;
                if constexpr (std::same_as<Dec, DataType>) {
                    // r is already the library DataType (std::vector<std::byte>), forward to move overload
                    return Write(static_cast<std::size_t>(r.size()), std::move(r));
                } else {
                    DataType tmp;
                    if constexpr (requires(DataType& d, typename DataType::size_type n) { d.reserve(n); }) {
                        auto dist = std::ranges::distance(r);
                        if (dist > 0) tmp.reserve(static_cast<typename DataType::size_type>(dist));
                    }
                    std::transform(std::ranges::begin(r), std::ranges::end(r), std::back_inserter(tmp),
                           [] (auto&& e) noexcept { return static_cast<std::byte>(e); });
                    return Write(static_cast<std::size_t>(tmp.size()), std::move(tmp));
                }
            }
 
            template<std::input_iterator I, std::sentinel_for<I> S>
                requires (!std::is_class_v<std::remove_cv_t<std::iter_value_t<I>>>) &&
                requires(std::iter_value_t<I> v) { static_cast<std::byte>(v); }
            bool                                                            Write(I first, S last) noexcept {
                DataType tmp;
                std::transform(first, last, std::back_inserter(tmp), [] (auto&& e) noexcept { return static_cast<std::byte>(e); });
                return Write(static_cast<std::size_t>(tmp.size()), std::move(tmp));
            }
 
            template<std::input_iterator I2, std::sentinel_for<I2> S2>
                requires (!std::is_class_v<std::remove_cv_t<std::iter_value_t<I2>>>) &&
                requires(std::iter_value_t<I2> v) { static_cast<std::byte>(v); }
            bool                                                            Write(const std::size_t& count, I2 first, S2 last) noexcept {
                if (count == 0) return Write(first, last);
                DataType tmp;
                std::size_t written = 0;
                for (; first != last && written < count; ++first, ++written) {
                    tmp.push_back(static_cast<std::byte>(*first));
                }
                return Write(static_cast<std::size_t>(written), std::move(tmp));
            }
 
            virtual bool                                                    Write(const std::size_t& count, DataType&& data) noexcept = 0;
 
            virtual bool                                                    Write(const std::size_t& count, const ReadOnly& data) noexcept = 0;
 
            inline bool                                                     Write(const ReadOnly& data) noexcept {
                return Write(data.AvailableBytes(), data);
            }
 
            virtual bool                                                    Write(const std::size_t& count, ReadOnly&& data) noexcept = 0;
 
            inline bool                                                     Write(ReadOnly&& data) noexcept {
                return Write(data.AvailableBytes(), std::move(data));
            }
    };
 
    class STORMBYTE_BUFFER_PUBLIC ReadWrite: public ReadOnly, public WriteOnly {
        public:
            inline ReadWrite() noexcept: Generic() {};
 
            inline ReadWrite(const DataType& data) noexcept: Generic(data) {}
 
            inline ReadWrite(DataType&& data) noexcept: Generic(std::move(data)) {}
 
            ReadWrite(const ReadWrite& other) noexcept                      = default;
            
            ReadWrite(ReadWrite&& other) noexcept                           = default;
 
            virtual ~ReadWrite() noexcept                                   = default;
            
            ReadWrite& operator=(const ReadWrite& other)                    = default;
        
            ReadWrite& operator=(ReadWrite&& other) noexcept                = default;
    };
}