generic.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte-Buffer.
 *
 * StormByte-Buffer is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * or later, as published by the Free Software Foundation.
 *
 * StormByte-Buffer is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with StormByte-Buffer. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 */
 
#pragma once
 
#include <StormByte/buffer/typedefs.hxx>
#include <StormByte/type_traits.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;
 
            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:
            template<Type::ByteInputRange Src>
            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<Type::ByteInputRange Src>
            static DataType DataConvert(Src&& src) noexcept {
                if constexpr (Type::SameAs<Src, 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() {}
 
            ReadOnly(const ReadOnly&) noexcept = default;
 
            ReadOnly(ReadOnly&&) noexcept = default;
 
            virtual ~ReadOnly() noexcept;
 
            ReadOnly& operator=(const ReadOnly&) = default;
 
            ReadOnly& operator=(ReadOnly&&) noexcept = default;
            virtual std::size_t AvailableBytes() const noexcept = 0;
 
            virtual const DataType& Data() const noexcept = 0;
 
            virtual bool Empty() const noexcept = 0;
 
            virtual bool EoF() const noexcept = 0;
 
            virtual bool IsReadable() const noexcept = 0;
 
            virtual std::size_t Size() const noexcept = 0;
 
            virtual void Clean() noexcept = 0;
 
            virtual void Clear() noexcept = 0;
 
            virtual bool Drop(const std::size_t& count) noexcept = 0;
 
            virtual void Seek(const std::ptrdiff_t& offset, const Position& mode) 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 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;
 
    };
 
    class STORMBYTE_BUFFER_PUBLIC WriteOnly: virtual public Generic {
        public:
            inline WriteOnly() noexcept: Generic() {}
 
            WriteOnly(const WriteOnly&) = default;
 
            WriteOnly(WriteOnly&&) noexcept = default;
 
            virtual ~WriteOnly() noexcept;
 
            WriteOnly& operator=(const WriteOnly&) = default;
 
            WriteOnly& operator=(WriteOnly&&) noexcept = default;
            virtual bool IsWritable() const noexcept = 0;
 
            virtual void Close() noexcept = 0;
 
            virtual void SetError() noexcept = 0;
 
            virtual bool Write(const std::size_t& count, const DataType& data) noexcept = 0;
 
            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;
 
            virtual bool Write(const std::size_t& count, ReadOnly&& data) noexcept = 0;
 
            inline bool Write(const ReadOnly& data) noexcept {
                return Write(data.AvailableBytes(), data);
            }
 
            inline bool Write(ReadOnly&& data) noexcept {
                return Write(data.AvailableBytes(), std::move(data));
            }
 
            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 {
                if (N == 0) return Write(DataType{});
                return Write(std::string_view(s, (N > 0) ? (N - 1) : 0));
            }
 
            template<Type::ByteInputRange R>
            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<Type::ByteInputRange Rw>
            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<Type::ByteInputRange Rrw>
            bool Write(const std::size_t& count, Rrw&& r) noexcept {
                if (count == 0) return Write(std::forward<Rrw>(r));
                if constexpr (Type::SameAs<Rrw, DataType>) {
                    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<Type::ByteInputRange Rr>
            bool Write(Rr&& r) noexcept {
                if constexpr (Type::SameAs<Rr, DataType>) {
                    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<Type::ByteInputIterator I, typename S>
                requires Type::SentinelFor<S, I>
            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<Type::ByteInputIterator I2, typename S2>
                requires Type::SentinelFor<S2, I2>
            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));
            }
 
    };
 
    class STORMBYTE_BUFFER_PUBLIC ReadWrite: public ReadOnly, public WriteOnly {
        public:
            inline ReadWrite() noexcept: Generic() {}
 
            ReadWrite(const ReadWrite& other) noexcept = default;
 
            ReadWrite(ReadWrite&& other) noexcept = default;
 
            virtual ~ReadWrite() noexcept;
 
            ReadWrite& operator=(const ReadWrite& other) = default;
 
            ReadWrite& operator=(ReadWrite&& other) noexcept = default;
    };
}