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 original source is dual-licensed:
 *
 * 1. GNU Lesser General Public License v3.0 (or later)
 *    You may redistribute and/or modify this file under the terms of the
 *    GNU Lesser General Public License as published by the Free Software
 *    Foundation, either version 3 of the License, or (at your option)
 *    any later version.
 *
 * 2. Commercial license
 *    Alternatively, this file may be used under the terms of a commercial
 *    license agreement with the copyright holder
 *    (David C. Manuelda <StormByte@gmail.com>).
 *
 * Both licenses apply only to original StormByte-Buffer source in this
 * repository. They do not cover other StormByte modules or any third-party
 * material shipped with this repository (including everything under
 * thirdparty/, and in particular the bundled StormByte-Logger tree and
 * the rest of the StormByte suite it vendors), which remains under its own
 * license.
 *
 * Neither license grants any patent rights. Any patent licenses required
 * to use this software or third-party components must be obtained separately
 * from the patent holders.
 *
 * 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
 * version 3 along with StormByte-Buffer. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
 */
 
#pragma once
 
#include <StormByte/buffer/typedefs.hxx>
#include <StormByte/byte_size.hxx>
#include <StormByte/type_traits.hxx>
 
#include <algorithm>
#include <cstdint>
#include <iterator>
#include <ranges>
#include <span>
#include <string_view>
#include <type_traits>
#include <utility>
 
namespace StormByte {
    namespace Buffer {
        class STORMBYTE_BUFFER_PUBLIC Generic {
            public:
                Generic() noexcept = default;
 
                Generic(const Generic& other) noexcept = default;
 
                Generic(Generic&& other) noexcept = default;
 
                virtual ~Generic() noexcept = 0;
 
                Generic& operator=(const Generic& other) = default;
 
                Generic& operator=(Generic&& other) noexcept = default;
 
                virtual StormByte::ByteSize Size() const noexcept = 0;
 
            protected:
                template<Type::ByteInputRange Src>
                static BinaryData DataConvert(const Src& src) noexcept {
                    BinaryData out;
                    if constexpr (requires { std::ranges::size(src); }) {
                        auto s = std::ranges::size(src);
                        if (s > 0)
                            out.reserve(StormByte::ByteSize{static_cast<std::size_t>(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 BinaryData DataConvert(Src&& src) noexcept {
                    if constexpr (Type::SameAs<Src, BinaryData>) {
                        return std::move(src);
                    } else {
                        BinaryData out;
                        if constexpr (requires { std::ranges::size(src); }) {
                            auto s = std::ranges::size(src);
                            if (s > 0)
                                out.reserve(StormByte::ByteSize{static_cast<std::size_t>(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 BinaryData DataConvert(std::string_view sv) noexcept {
                    BinaryData out;
                    if (!sv.empty())
                        out.reserve(StormByte::ByteSize{sv.size()});
                    std::transform(sv.begin(), sv.end(), std::back_inserter(out),
                        [](char c) noexcept { return static_cast<std::byte>(c); });
                    return out;
                }
 
                static BinaryData DataConvert(const char* s) noexcept {
                    if (!s)
                        return BinaryData{};
                    return DataConvert(std::string_view(s));
                }
 
        };
 
        class WriteOnly;
 
        class STORMBYTE_BUFFER_PUBLIC ReadOnly: virtual public Generic {
            public:
                inline ReadOnly() noexcept: Generic() {}
 
                ReadOnly(const ReadOnly& other) noexcept = default;
 
                ReadOnly(ReadOnly&& other) noexcept = default;
 
                virtual ~ReadOnly() noexcept;
 
                ReadOnly& operator=(const ReadOnly& other) = default;
 
                ReadOnly& operator=(ReadOnly&& other) noexcept = default;
 
                virtual StormByte::ByteSize Available() const noexcept = 0;
 
                virtual const BinaryData& Data() const noexcept = 0;
 
                virtual bool Empty() const noexcept = 0;
 
                virtual bool EoF() const noexcept = 0;
 
                virtual bool IsReadable() const noexcept = 0;
 
                virtual void Clean() noexcept = 0;
 
                virtual void Clear() noexcept = 0;
 
                virtual bool Drop(const StormByte::ByteSize& count) noexcept = 0;
 
                virtual void Seek(const std::ptrdiff_t& offset, const Position& mode) const noexcept = 0;
 
                inline virtual bool Extract(const StormByte::ByteSize& count, StormByte::BinaryData& outBuffer) noexcept = 0;
 
                inline bool Extract(StormByte::BinaryData& outBuffer) noexcept {
                    return Extract(StormByte::ByteSize{0}, outBuffer);
                }
 
                inline virtual bool Extract(const StormByte::ByteSize& count, WriteOnly& outBuffer) noexcept = 0;
 
                inline bool Extract(WriteOnly& outBuffer) noexcept {
                    return Extract(StormByte::ByteSize{0}, outBuffer);
                }
 
                virtual void ExtractUntilEoF(StormByte::BinaryData& outBuffer) noexcept = 0;
 
                virtual void ExtractUntilEoF(WriteOnly& outBuffer) noexcept = 0;
 
                virtual bool Peek(const StormByte::ByteSize& count, StormByte::BinaryData& outBuffer) const noexcept = 0;
 
                virtual bool Peek(const StormByte::ByteSize& count, WriteOnly& outBuffer) const noexcept = 0;
 
                virtual bool Read(const StormByte::ByteSize& count, StormByte::BinaryData& outBuffer) const noexcept = 0;
 
                inline bool Read(StormByte::BinaryData& outBuffer) const noexcept {
                    return Read(StormByte::ByteSize{0}, outBuffer);
                }
 
                virtual bool Read(const StormByte::ByteSize& count, WriteOnly& outBuffer) const noexcept = 0;
 
                inline bool Read(WriteOnly& outBuffer) const noexcept {
                    return Read(StormByte::ByteSize{0}, outBuffer);
                }
 
                virtual void ReadUntilEoF(StormByte::BinaryData& 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& other) = default;
 
                WriteOnly(WriteOnly&& other) noexcept = default;
 
                virtual ~WriteOnly() noexcept;
 
                WriteOnly& operator=(const WriteOnly& other) = default;
 
                WriteOnly& operator=(WriteOnly&& other) noexcept = default;
 
                virtual bool IsWritable() const noexcept = 0;
 
                virtual void Close() noexcept = 0;
 
                virtual void SetError() noexcept = 0;
 
                virtual bool Write(const StormByte::ByteSize& count, const BinaryData& data) noexcept = 0;
 
                virtual bool Write(const StormByte::ByteSize& count, BinaryData&& data) noexcept = 0;
 
                virtual bool Write(const StormByte::ByteSize& count, const ReadOnly& data) noexcept = 0;
 
                virtual bool Write(const StormByte::ByteSize& count, ReadOnly&& data) noexcept = 0;
 
                inline bool Write(const ReadOnly& data) noexcept {
                    return Write(data.Available(), data);
                }
 
                inline bool Write(ReadOnly&& data) noexcept {
                    return Write(data.Available(), std::move(data));
                }
 
                bool Write(std::string_view sv) noexcept {
                    BinaryData tmp;
                    if (!sv.empty())
                        tmp.reserve(StormByte::ByteSize{sv.size()});
                    std::transform(sv.begin(), sv.end(), std::back_inserter(tmp),
                        [](char e) noexcept { return static_cast<std::byte>(e); });
                    return Write(tmp.size(), std::move(tmp));
                }
 
                bool Write(const char* s) noexcept {
                    if (!s)
                        return Write(BinaryData{});
                    return Write(std::string_view(s));
                }
 
                bool Write(const StormByte::ByteSize& count, std::string_view sv) noexcept {
                    const StormByte::ByteSize to_write = (count == StormByte::ByteSize{0})
                        ? StormByte::ByteSize{sv.size()}
                        : std::min(count, StormByte::ByteSize{sv.size()});
                    BinaryData tmp;
                    if (to_write > StormByte::ByteSize{0})
                        tmp.reserve(to_write);
                    std::transform(sv.begin(), sv.begin() + static_cast<std::ptrdiff_t>(static_cast<std::size_t>(to_write)),
                        std::back_inserter(tmp),
                        [](char e) noexcept { return static_cast<std::byte>(e); });
                    return Write(to_write, std::move(tmp));
                }
 
                bool Write(const StormByte::ByteSize& count, const char* s) noexcept {
                    if (!s)
                        return Write(count, BinaryData{});
                    return Write(count, std::string_view(s));
                }
 
                template<std::size_t N>
                bool Write(const char (&s)[N]) noexcept {
                    if (N == 0)
                        return Write(BinaryData{});
                    return Write(std::string_view(s, (N > 0) ? (N - 1) : 0));
                }
 
                template<Type::ByteInputRange R>
                bool Write(const R& r) noexcept {
                    BinaryData tmp;
                    if constexpr (requires { std::ranges::size(r); }) {
                        auto dist = std::ranges::size(r);
                        if (dist > 0)
                            tmp.reserve(StormByte::ByteSize{static_cast<std::size_t>(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(tmp.size(), std::move(tmp));
                }
 
                template<Type::ByteInputRange Rw>
                bool Write(const StormByte::ByteSize& count, const Rw& r) noexcept {
                    if (count == StormByte::ByteSize{0})
                        return Write(r);
                    BinaryData tmp;
                    tmp.reserve(count);
                    auto it = std::ranges::begin(r);
                    auto end = std::ranges::end(r);
                    StormByte::ByteSize written{0};
                    for (; it != end && written < count; ++it, written = written + StormByte::ByteSize{1})
                        tmp.push_back(static_cast<std::byte>(*it));
                    return Write(written, std::move(tmp));
                }
 
                template<Type::ByteInputRange Rrw>
                bool Write(const StormByte::ByteSize& count, Rrw&& r) noexcept {
                    if (count == StormByte::ByteSize{0})
                        return Write(std::forward<Rrw>(r));
                    if constexpr (Type::SameAs<Rrw, BinaryData>) {
                        BinaryData tmp = std::move(r);
                        if (tmp.size() > count)
                            tmp.resize(count);
                        return Write(tmp.size(), std::move(tmp));
                    } else {
                        BinaryData tmp;
                        tmp.reserve(count);
                        auto it = std::ranges::begin(r);
                        auto end = std::ranges::end(r);
                        StormByte::ByteSize written{0};
                        for (; it != end && written < count; ++it, written = written + StormByte::ByteSize{1})
                            tmp.push_back(static_cast<std::byte>(*it));
                        return Write(written, std::move(tmp));
                    }
                }
 
                template<Type::ByteInputRange Rr>
                bool Write(Rr&& r) noexcept {
                    if constexpr (Type::SameAs<Rr, BinaryData>) {
                        return Write(r.size(), std::move(r));
                    } else {
                        BinaryData tmp;
                        if constexpr (requires { std::ranges::size(r); }) {
                            auto dist = std::ranges::size(r);
                            if (dist > 0)
                                tmp.reserve(StormByte::ByteSize{static_cast<std::size_t>(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(tmp.size(), std::move(tmp));
                    }
                }
 
                template<Type::ByteInputIterator I, typename S>
                    requires Type::SentinelFor<S, I>
                bool Write(I first, S last) noexcept {
                    BinaryData tmp;
                    std::transform(first, last, std::back_inserter(tmp),
                        [](auto&& e) noexcept { return static_cast<std::byte>(e); });
                    return Write(tmp.size(), std::move(tmp));
                }
 
                template<Type::ByteInputIterator I2, typename S2>
                    requires Type::SentinelFor<S2, I2>
                bool Write(const StormByte::ByteSize& count, I2 first, S2 last) noexcept {
                    if (count == StormByte::ByteSize{0})
                        return Write(first, last);
                    BinaryData tmp;
                    StormByte::ByteSize written{0};
                    for (; first != last && written < count; ++first, written = written + StormByte::ByteSize{1})
                        tmp.push_back(static_cast<std::byte>(*first));
                    return Write(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;
 
        };
 
        extern template BinaryData STORMBYTE_BUFFER_PUBLIC Generic::DataConvert<BinaryData>(const BinaryData&) noexcept;
        extern template BinaryData STORMBYTE_BUFFER_PUBLIC Generic::DataConvert<BinaryData>(BinaryData&&) noexcept;
        extern template BinaryData STORMBYTE_BUFFER_PUBLIC Generic::DataConvert<std::span<const std::byte>>(const std::span<const std::byte>&) noexcept;
        extern template BinaryData STORMBYTE_BUFFER_PUBLIC Generic::DataConvert<std::span<std::byte>>(const std::span<std::byte>&) noexcept;
        extern template BinaryData STORMBYTE_BUFFER_PUBLIC Generic::DataConvert<std::span<std::byte>>(std::span<std::byte>&&) noexcept;
 
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<BinaryData>(const BinaryData&) noexcept;
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<BinaryData>(BinaryData&&) noexcept;
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<BinaryData>(const StormByte::ByteSize&, const BinaryData&) noexcept;
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<BinaryData>(const StormByte::ByteSize&, BinaryData&&) noexcept;
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<std::span<const std::byte>>(const std::span<const std::byte>&) noexcept;
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<std::span<const std::byte>>(const StormByte::ByteSize&, const std::span<const std::byte>&) noexcept;
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<std::span<std::byte>>(const std::span<std::byte>&) noexcept;
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<std::span<std::byte>>(const StormByte::ByteSize&, const std::span<std::byte>&) noexcept;
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<BinaryData::const_iterator, BinaryData::const_iterator>(BinaryData::const_iterator, BinaryData::const_iterator) noexcept;
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<BinaryData::iterator, BinaryData::iterator>(BinaryData::iterator, BinaryData::iterator) noexcept;
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<BinaryData::const_iterator, BinaryData::const_iterator>(const StormByte::ByteSize&, BinaryData::const_iterator, BinaryData::const_iterator) noexcept;
        extern template bool STORMBYTE_BUFFER_PUBLIC WriteOnly::Write<BinaryData::iterator, BinaryData::iterator>(const StormByte::ByteSize&, BinaryData::iterator, BinaryData::iterator) noexcept;
    }
}