byte-helper.hpp

Go to the documentation of this file.

#pragma once
#include "library-pch.hpp"
 
#if __has_include(<boost/version.hpp>)
#include <boost/version.hpp>
#endif
#ifdef BOOST_VERSION
#include <boost/endian/conversion.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/vector.hpp>
 
#else
#pragma message "Boost wasn't found. Serialization for ByteArray is unavailable."
#endif
 
namespace mal_toolkit
{
    struct ByteView;
    struct ByteArray;
 
    struct ByteView : public std::span<const std::byte>
    {
        using std::span<const std::byte>::span;
        using std::span<const std::byte>::operator=;
        using std::span<const std::byte>::operator[];
 
        template <typename T>
        [[nodiscard]] const T *as() const
        {
            return reinterpret_cast<const T *>(data());
        }
 
        [[nodiscard]] constexpr ByteView subview(size_t from = 0) const
        {
            return ByteView{ data() + from, size() - from };
        }
 
        [[nodiscard]] constexpr ByteView subview(size_t from, size_t length) const
        {
            return ByteView{ data() + from, length };
        }
    };
 
    struct ByteArray : public std::vector<std::byte>
    {
        using std::vector<std::byte>::vector;
        using std::vector<std::byte>::operator=;
        using std::vector<std::byte>::operator[];
 
        template <typename T>
        [[nodiscard]] constexpr T *as()
        {
            return reinterpret_cast<T *>(data());
        }
 
        template <typename T>
        [[nodiscard]] constexpr const T *as() const
        {
            return reinterpret_cast<const T *>(data());
        }
 
        [[nodiscard]] constexpr ByteView as_view() const { return ByteView{ data(), size() }; }
 
        template <typename First, typename Second, typename... Args>
        void append(First &&first, Second &&second, Args &&...args)
        {
            append(std::forward<First>(first));
            append(std::forward<Second>(second));
            append(args...);
        }
 
        template <typename First, typename Second>
        void append(First &&first, Second &&second)
        {
            append(std::forward<First>(first));
            append(std::forward<Second>(second));
        }
 
        template <typename T>
        requires(sizeof(T) == sizeof(std::byte)) void append(const std::vector<T> &other)
        {
            reserve(size() + other.size());
            if constexpr (std::is_trivially_constructible_v<std::byte, T>)
            {
                insert(end(), other.begin(), other.end());
            }
            else
            {
                std::transform(other.begin(), other.end(), std::back_inserter(*this),
                               [](const T &t) { return static_cast<std::byte>(t); });
            }
        }
 
        template <typename T>
        requires(sizeof(T) == sizeof(std::byte)) void append(const std::span<T> &other)
        {
            reserve(size() + other.size());
            if constexpr (std::is_trivially_constructible_v<std::byte, T>)
            {
                insert(end(), other.begin(), other.end());
            }
            else
            {
                std::transform(other.begin(), other.end(), std::back_inserter(*this),
                               [](const T &t) { return static_cast<std::byte>(t); });
            }
        }
 
        template <typename T>
        requires(sizeof(T) == sizeof(std::byte)) void append(const std::basic_string<T> &other)
        {
            reserve(size() + other.size());
            if constexpr (std::is_trivially_constructible_v<std::byte, T>)
            {
                insert(end(), other.begin(), other.end());
            }
            else
            {
                std::transform(other.begin(), other.end(), std::back_inserter(*this),
                               [](const T &t) { return static_cast<std::byte>(t); });
            }
        }
 
        template <typename T>
        requires(sizeof(T) == sizeof(std::byte)) void append(const std::basic_string_view<T> &other)
        {
            reserve(size() + other.size());
            if constexpr (std::is_trivially_constructible_v<std::byte, T>)
            {
                insert(end(), other.begin(), other.end());
            }
            else
            {
                std::transform(other.begin(), other.end(), std::back_inserter(*this),
                               [](const T &t) { return static_cast<std::byte>(t); });
            }
        }
 
        template <typename... Args>
        static ByteArray from_byte_arrays(Args &&...args)
        {
            ByteArray result;
            result.append(std::forward<Args>(args)...);
            return result;
        }
 
        template <std::integral Integer>
        static ByteArray from_integral(const Integer integer)
        {
            ByteArray rv;
            rv.resize(sizeof(Integer));
            *rv.as<Integer>() = integer;
            return rv;
        }
 
        [[nodiscard]] constexpr ByteView view(size_t from = 0) const
        {
            return ByteView{ data() + from, size() - from };
        }
 
        [[nodiscard]] constexpr ByteView view(size_t from, size_t length) const
        {
            return ByteView{ data() + from, length };
        }
#ifdef BOOST_VERSION
    private:
        friend class boost::serialization::access;
 
        template <class Archive>
        void serialize(Archive &ar, [[maybe_unused]] const unsigned int version)
        {
            ar &boost::serialization::base_object<std::vector<std::byte>>(*this);
        }
#endif
    };
 
#ifdef BOOST_VERSION
    template <typename Integer>
    [[nodiscard]] inline Integer bytes_to_integer(const ByteView byte_view)
    {
        mal_toolkit::Assert(byte_view.size() >= sizeof(Integer),
                            "The byte array is too small to be converted to the specified integer type");
        return boost::endian::little_to_native(*reinterpret_cast<const Integer *>(byte_view.data()));
    }
 
    template <typename Integer>
    [[nodiscard]] inline ByteArray integer_to_bytes(const Integer value)
    {
        ByteArray byte_array(sizeof(Integer));
        *byte_array.as<Integer>() = boost::endian::native_to_little(value);
        return byte_array;
    }
#endif
 
    [[nodiscard]] inline uint16_t bytes_to_uint16(const ByteView byte_view)
    {
        return bytes_to_integer<uint16_t>(byte_view);
    }
 
    [[nodiscard]] inline ByteArray uint16_to_bytes(const uint16_t value) { return integer_to_bytes<uint16_t>(value); }
 
    [[nodiscard]] inline uint32_t bytes_to_uint32(const ByteView byte_view)
    {
        return bytes_to_integer<uint32_t>(byte_view);
    }
 
    [[nodiscard]] inline ByteArray uint32_to_bytes(const uint32_t value) { return integer_to_bytes<uint32_t>(value); }
 
    [[nodiscard]] inline uint64_t bytes_to_uint64(const ByteView byte_view)
    {
        return bytes_to_integer<uint64_t>(byte_view);
    }
 
    [[nodiscard]] inline ByteArray uint64_to_bytes(const uint64_t value) { return integer_to_bytes<uint64_t>(value); }
 
    [[nodiscard]] inline int16_t bytes_to_int16(const ByteView byte_view)
    {
        return bytes_to_integer<int16_t>(byte_view);
    }
 
    [[nodiscard]] inline ByteArray int16_to_bytes(const int16_t value) { return integer_to_bytes<int16_t>(value); }
 
    [[nodiscard]] inline int32_t bytes_to_int32(const ByteView byte_view)
    {
        return bytes_to_integer<int32_t>(byte_view);
    }
 
    [[nodiscard]] inline ByteArray int32_to_bytes(const int32_t value) { return integer_to_bytes<int32_t>(value); }
 
    [[nodiscard]] inline int64_t bytes_to_int64(const ByteView byte_view)
    {
        return bytes_to_integer<int64_t>(byte_view);
    }
 
    [[nodiscard]] inline ByteArray int64_to_bytes(const int64_t value) { return integer_to_bytes<int64_t>(value); }
 
}  // namespace mal_toolkit