binary_data.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte.
 *
 * StormByte 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 source in this repository.
 * They do not cover other StormByte modules or any third-party material
 * shipped with this repository (including everything under thirdparty/),
 * 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 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. 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/byte_size.hxx>
#include <StormByte/cstring.hxx>
#include <StormByte/exception.hxx>
#include <StormByte/size.hxx>
#include <StormByte/type_traits.hxx>
#include <StormByte/visibility.h>
 
#include <compare>
#include <cstddef>
#include <initializer_list>
#include <iterator>
#include <memory>
#include <span>
#include <string_view>
#include <utility>
#include <vector>
 
namespace StormByte {
    class STORMBYTE_PUBLIC BinaryData final {
        public:
            using value_type = std::byte;
 
            using size_type = std::size_t;
 
            using difference_type = std::ptrdiff_t;
 
            using reference = std::byte&;
 
            using const_reference = const std::byte&;
 
            using pointer = std::byte*;
 
            using const_pointer = const std::byte*;
 
            using iterator = std::byte*;
 
            using const_iterator = const std::byte*;
 
            using reverse_iterator = std::reverse_iterator<iterator>;
 
            using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
            BinaryData() noexcept;
 
            BinaryData(const StormByte::ByteSize& count, std::byte value);
 
            explicit BinaryData(const StormByte::ByteSize& count);
 
            explicit BinaryData(std::span<const std::byte> bytes);
 
            BinaryData(const std::byte* bytes, const StormByte::ByteSize& count);
 
            BinaryData(std::initializer_list<std::byte> list);
 
            explicit BinaryData(std::string_view sv);
 
            explicit BinaryData(const char* s);
 
            explicit BinaryData(const std::vector<std::byte>& bytes);
 
            explicit BinaryData(std::vector<std::byte>&& bytes);
 
            template<Type::ByteInputRange R>
            explicit BinaryData(const R& range);
 
            template<Type::ByteInputRange R>
            explicit BinaryData(R&& range);
 
            BinaryData(const BinaryData& other);
 
            BinaryData(BinaryData&& other) noexcept;
 
            ~BinaryData() noexcept;
 
            BinaryData& operator=(const BinaryData& other);
 
            BinaryData& operator=(BinaryData&& other) noexcept;
 
            BinaryData& operator=(std::initializer_list<std::byte> list);
 
            bool operator==(const BinaryData& other) const noexcept;
 
            bool operator!=(const BinaryData& other) const noexcept;
 
            std::strong_ordering operator<=>(const BinaryData& other) const noexcept;
 
            bool operator==(std::span<const std::byte> bytes) const noexcept;
 
            bool operator!=(std::span<const std::byte> bytes) const noexcept;
 
            std::strong_ordering operator<=>(std::span<const std::byte> bytes) const noexcept;
 
            iterator begin() noexcept;
 
            const_iterator begin() const noexcept;
 
            iterator end() noexcept;
 
            const_iterator end() const noexcept;
 
            const_iterator cbegin() const noexcept;
 
            const_iterator cend() const noexcept;
 
            reverse_iterator rbegin() noexcept;
 
            reverse_iterator rend() noexcept;
 
            const_reverse_iterator rbegin() const noexcept;
 
            const_reverse_iterator rend() const noexcept;
 
            const_reverse_iterator crbegin() const noexcept;
 
            const_reverse_iterator crend() const noexcept;
 
            StormByte::ByteSize size() const noexcept;
 
            StormByte::ByteSize max_size() const noexcept;
 
            StormByte::ByteSize capacity() const noexcept;
 
            bool empty() const noexcept;
 
            void reserve(const StormByte::ByteSize& new_cap);
 
            void resize(const StormByte::ByteSize& new_size);
 
            void resize(const StormByte::ByteSize& new_size, std::byte value);
 
            void shrink_to_fit();
 
            void clear() noexcept;
 
            std::byte& operator[](const StormByte::ByteSize& index) noexcept;
 
            const std::byte& operator[](const StormByte::ByteSize& index) const noexcept;
 
            std::byte& at(const StormByte::ByteSize& index);
 
            const std::byte& at(const StormByte::ByteSize& index) const;
 
            std::byte& front();
 
            const std::byte& front() const;
 
            std::byte& back();
 
            const std::byte& back() const;
 
            std::byte* data() noexcept;
 
            const std::byte* data() const noexcept;
 
            std::span<std::byte> span() noexcept;
 
            std::span<const std::byte> span() const noexcept;
 
            operator std::span<std::byte>() noexcept;
 
            operator std::span<const std::byte>() const noexcept;
 
            STORMBYTE_FORCE_INLINE explicit operator std::vector<std::byte>() const& {
                const std::span<const std::byte> bytes = span();
                return std::vector<std::byte>(bytes.begin(), bytes.end());
            }
 
            STORMBYTE_FORCE_INLINE explicit operator std::vector<std::byte>() && {
                const std::span<const std::byte> bytes = span();
                std::vector<std::byte> out(bytes.begin(), bytes.end());
                clear();
                shrink_to_fit();
                return out;
            }
 
            void assign(const StormByte::ByteSize& count, std::byte value);
 
            void assign(std::span<const std::byte> bytes);
 
            void assign(std::initializer_list<std::byte> list);
 
            template<typename InputIt>
            void assign(InputIt first, InputIt last);
 
            void append(std::span<const std::byte> bytes);
 
            void append(const std::byte* bytes, const StormByte::ByteSize& count);
 
            void append(const BinaryData& other);
 
            void append(BinaryData&& other);
 
            BinaryData& operator+=(std::span<const std::byte> bytes);
 
            BinaryData& operator+=(const BinaryData& other);
 
            BinaryData& operator+=(BinaryData&& other);
 
            void push_back(std::byte value);
 
            template<typename T>
            reference emplace_back(T&& value);
 
            void pop_back();
 
            iterator insert(const_iterator pos, std::byte value);
 
            iterator insert(const_iterator pos, const StormByte::ByteSize& count, std::byte value);
 
            iterator insert(const_iterator pos, std::initializer_list<std::byte> list);
 
            iterator insert(const_iterator pos, std::span<const std::byte> bytes);
 
            template<typename InputIt>
            iterator insert(const_iterator pos, InputIt first, InputIt last);
 
            iterator erase(const_iterator pos);
 
            iterator erase(const_iterator first, const_iterator last);
 
            void swap(BinaryData& other) noexcept;
 
            CString HexDump() const;
 
            CString HexDump(Size columns) const;
 
        private:
            struct Storage;
            std::unique_ptr<Storage> m_storage;
    };
 
    STORMBYTE_PUBLIC void swap(BinaryData& lhs, BinaryData& rhs) noexcept;
 
    inline bool operator==(std::span<const std::byte> bytes, const BinaryData& data) noexcept {
        return data == bytes;
    }
 
    inline bool operator!=(std::span<const std::byte> bytes, const BinaryData& data) noexcept {
        return data != bytes;
    }
 
    inline std::strong_ordering operator<=>(std::span<const std::byte> bytes, const BinaryData& data) noexcept {
        return 0 <=> (data <=> bytes);
    }
 
    // Out-of-line template members. Documentation lives on the declarations.
    template<Type::ByteInputRange R>
    BinaryData::BinaryData(const R& range)
        : BinaryData() {
        if constexpr (requires { std::size(range); })
            reserve(StormByte::ByteSize{std::size(range)});
        for (auto&& b : range)
            push_back(static_cast<std::byte>(b));
    }
 
    template<Type::ByteInputRange R>
    BinaryData::BinaryData(R&& range)
        : BinaryData() {
        using U = std::remove_cvref_t<R>;
        if constexpr (Type::SameAs<U, BinaryData> && !Type::LvalueReference<R>) {
            *this = std::move(range);
        } else {
            if constexpr (requires { std::size(range); })
                reserve(StormByte::ByteSize{std::size(range)});
            for (auto&& b : range)
                push_back(static_cast<std::byte>(b));
        }
    }
 
    template<typename InputIt>
    void BinaryData::assign(InputIt first, InputIt last) {
        clear();
        for (; first != last; ++first)
            push_back(static_cast<std::byte>(*first));
    }
 
    template<typename InputIt>
    BinaryData::iterator BinaryData::insert(const_iterator pos, InputIt first, InputIt last) {
        const auto start = static_cast<std::size_t>(pos - cbegin());
        std::size_t n = start;
        for (; first != last; ++first) {
            insert(cbegin() + static_cast<difference_type>(n), static_cast<std::byte>(*first));
            ++n;
        }
        return begin() + static_cast<difference_type>(start);
    }
 
    template<typename T>
    BinaryData::reference BinaryData::emplace_back(T&& value) {
        push_back(std::byte{ static_cast<unsigned char>(std::forward<T>(value)) });
        return back();
    }
}