sbepp.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Copyright (c) 2023, Oleksandr Koval
 
#pragma once
 
#include <array>
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <iterator>
#include <limits>
#include <type_traits>
#include <initializer_list>
 
// Clang generates tons of warnings about code like `return {N};` where `N` is
// calculated during generation or just a value from schema. Using braced
// initialization syntax provides additional safety in such cases.
#ifdef __clang__
#    define SBEPP_WARNINGS_OFF()          \
        _Pragma("clang diagnostic push"); \
        _Pragma("clang diagnostic ignored \"-Wbraced-scalar-init\"")
#    define SBEPP_WARNINGS_ON() _Pragma("clang diagnostic pop")
#else
#    define SBEPP_WARNINGS_OFF()
#    define SBEPP_WARNINGS_ON()
#endif
 
SBEPP_WARNINGS_OFF();
 
#ifdef _MSVC_LANG
#    define SBEPP_CPLUSPLUS _MSVC_LANG
#else
#    define SBEPP_CPLUSPLUS __cplusplus
#endif
 
#ifdef __has_include
#    if __has_include(<version>)
#        include <version>
#    endif
#endif
 
#if !defined(SBEPP_HAS_THREE_WAY_COMPARISON)    \
    && defined(__cpp_impl_three_way_comparison) \
    && defined(__cpp_lib_three_way_comparison)
#    if(__cpp_impl_three_way_comparison >= 201907L) \
        && (__cpp_lib_three_way_comparison >= 201907L)
#        define SBEPP_HAS_THREE_WAY_COMPARISON 1
#        include <compare>
#    endif
#endif
#ifndef SBEPP_HAS_THREE_WAY_COMPARISON
#    define SBEPP_HAS_THREE_WAY_COMPARISON 0
#endif
 
#if !defined(SBEPP_HAS_CONCEPTS) && defined(__cpp_concepts)
#    if(__cpp_concepts >= 201907L)
#        define SBEPP_HAS_CONCEPTS 1
#    endif
#endif
#ifndef SBEPP_HAS_CONCEPTS
#    define SBEPP_HAS_CONCEPTS 0
#endif
 
#if !defined(SBEPP_HAS_INLINE_VARS) && defined(__cpp_inline_variables)
#    if(__cpp_inline_variables >= 201606L)
#        define SBEPP_HAS_INLINE_VARS 1
#        define SBEPP_CPP17_INLINE_VAR inline
#    endif
#endif
#ifndef SBEPP_CPP17_INLINE_VAR
#    define SBEPP_HAS_INLINE_VARS 0
#    define SBEPP_CPP17_INLINE_VAR
#endif
 
#if !defined(SBEPP_HAS_ENDIAN) && defined(__cpp_lib_endian)
#    if(__cpp_lib_endian >= 201907L)
#        define SBEPP_HAS_ENDIAN 1
#        include <bit>
#    endif
#endif
#ifndef SBEPP_HAS_ENDIAN
#    define SBEPP_HAS_ENDIAN 0
#endif
 
#if !defined(SBEPP_HAS_BITCAST) && defined(__cpp_lib_bit_cast)
#    if(__cpp_lib_bit_cast >= 201806L)
#        define SBEPP_HAS_BITCAST 1
#        include <bit>
#    endif
#endif
#ifndef SBEPP_HAS_BITCAST
#    define SBEPP_HAS_BITCAST 0
#endif
 
#if !defined(SBEPP_HAS_BYTESWAP) && defined(__cpp_lib_byteswap)
#    if(__cpp_lib_byteswap >= 202110L)
#        define SBEPP_HAS_BYTESWAP 1
#        include <bit>
#    endif
#endif
#ifndef SBEPP_HAS_BYTESWAP
#    define SBEPP_HAS_BYTESWAP 0
#endif
 
#if !defined(SBEPP_HAS_CONSTEXPR_ALGORITHMS) \
    && defined(__cpp_lib_constexpr_algorithms)
#    if(__cpp_lib_constexpr_algorithms >= 201806L)
#        define SBEPP_HAS_CONSTEXPR_ALGORITHMS 1
#    endif
#endif
#ifndef SBEPP_HAS_CONSTEXPR_ALGORITHMS
#    define SBEPP_HAS_CONSTEXPR_ALGORITHMS 0
#endif
 
#ifdef __has_cpp_attribute
// Clang provides `nodiscard` in C++11 but then warns that it's a C++17 feature
#    if __has_cpp_attribute(nodiscard) \
        && !(defined(__clang__) && (SBEPP_CPLUSPLUS < 201703L))
#        define SBEPP_CPP17_NODISCARD [[nodiscard]]
#    endif
 
#    if __has_cpp_attribute(deprecated) \
        && !(defined(__clang__) && (SBEPP_CPLUSPLUS < 201402L))
#        define SBEPP_DEPRECATED [[deprecated]]
#    endif
#endif
 
#ifndef SBEPP_CPP17_NODISCARD
#    define SBEPP_CPP17_NODISCARD
#endif
 
#ifndef SBEPP_DEPRECATED
#    if defined(__GNUC__) || defined(__clang__)
#        define SBEPP_DEPRECATED __attribute__((deprecated))
#    elif defined(_MSC_VER)
#        define SBEPP_DEPRECATED __declspec(deprecated)
#    else
#        define SBEPP_DEPRECATED
#    endif
#endif
 
#if SBEPP_HAS_BITCAST && SBEPP_HAS_CONSTEXPR_ALGORITHMS
#    define SBEPP_HAS_CONSTEXPR_ACCESSORS 1
#else
#    define SBEPP_HAS_CONSTEXPR_ACCESSORS 0
#endif
 
#if SBEPP_HAS_CONSTEXPR_ACCESSORS
#    include <bit>
#    define SBEPP_CPP20_CONSTEXPR constexpr
#else
#    define SBEPP_CPP20_CONSTEXPR
#endif
 
#ifdef __cpp_constexpr
#    if(__cpp_constexpr >= 201304L)
#        define SBEPP_CPP14_CONSTEXPR constexpr
#    endif
#else
#    if(SBEPP_CPLUSPLUS >= 201402L)
#        define SBEPP_CPP14_CONSTEXPR constexpr
#    endif
#endif
#ifndef SBEPP_CPP14_CONSTEXPR
#    define SBEPP_CPP14_CONSTEXPR
#endif
 
#if !defined(SBEPP_HAS_RANGES) && defined(__cpp_lib_ranges)
#    if(__cpp_lib_ranges >= 201911L)
#        define SBEPP_HAS_RANGES 1
#        include <ranges>
#    endif
#endif
#ifndef SBEPP_HAS_RANGES
#    define SBEPP_HAS_RANGES 0
#endif
 
#if !defined(SBEPP_HAS_IS_CONSTANT_EVALUATED)   \
    && defined(__cpp_lib_is_constant_evaluated) \
    && (__cpp_lib_is_constant_evaluated >= 201811L)
#    define SBEPP_HAS_IS_CONSTANT_EVALUATED 1
#endif
#ifndef SBEPP_HAS_IS_CONSTANT_EVALUATED
#    define SBEPP_HAS_IS_CONSTANT_EVALUATED 0
#endif
 
 
#ifdef SBEPP_DOXYGEN
#    define SBEPP_DISABLE_ASSERTS
 
#    define SBEPP_ASSERT_HANDLER
 
#    define SBEPP_ENABLE_ASSERTS_WITH_HANDLER
 
namespace sbepp
{
[[noreturn]] void assertion_failed(
    char const* expr, char const* function, char const* file, long line);
} // namespace sbepp
#endif
 
#ifdef SBEPP_DISABLE_ASSERTS
#    define SBEPP_SIZE_CHECKS_ENABLED 0
#    define SBEPP_ASSERT(expr) ((void)0)
#elif defined(SBEPP_ASSERT_HANDLER) \
    || defined(SBEPP_ENABLE_ASSERTS_WITH_HANDLER)
#    if !defined(NDEBUG) || defined(SBEPP_ENABLE_ASSERTS_WITH_HANDLER)
namespace sbepp
{
// must be defined by user
[[noreturn]] void assertion_failed(
    char const* expr, char const* function, char const* file, long line);
} // namespace sbepp
 
#        define SBEPP_SIZE_CHECKS_ENABLED 1
#        define SBEPP_ASSERT(expr)            \
            (static_cast<bool>(expr)          \
                 ? ((void)0)                  \
                 : ::sbepp::assertion_failed( \
                       #expr, __func__, __FILE__, __LINE__))
#    else
#        define SBEPP_SIZE_CHECKS_ENABLED 0
#        define SBEPP_ASSERT(expr) ((void)0)
#    endif
#else
#    include <cassert>
#    ifdef NDEBUG
#        define SBEPP_SIZE_CHECKS_ENABLED 0
#    else
#        define SBEPP_SIZE_CHECKS_ENABLED 1
#    endif
#    define SBEPP_ASSERT(expr) assert(expr)
#endif
 
#define SBEPP_SIZE_CHECK(begin, end, offset, size) \
    SBEPP_ASSERT(                                  \
        (begin)                                    \
        && (((offset) + (size)) <= static_cast<std::size_t>((end) - (begin))))
 
namespace sbepp
{
using length_t = std::uint64_t;
// for unknown reasons, in the SBE standard `offset` is specified as an unsigned
// 32-bit integer which makes no sense since `length` has 64 bits
using offset_t = std::uint64_t;
using version_t = std::uint64_t;
using schema_id_t = std::uint32_t;
using message_id_t = std::uint32_t;
using block_length_t = std::uint64_t;
using member_id_t = std::uint16_t;
using choice_index_t = std::uint8_t;
 
enum class field_presence
{
    required,
    optional,
    constant
};
 
#ifdef SBEPP_DOXYGEN
#    define SBEPP_BYTE_ORDER
#endif
 
#ifdef SBEPP_DOXYGEN
enum class endian
{
    little,
    big,
    native
};
#elif SBEPP_HAS_ENDIAN
using endian = std::endian;
#else
// https://en.cppreference.com/w/cpp/types/endian
enum class endian
{
#    if defined(_WIN32) || defined(WIN32)
    little = 0,
    big = 1,
    native = little
#    elif defined(__BYTE_ORDER__)
    little = __ORDER_LITTLE_ENDIAN__,
    big = __ORDER_BIG_ENDIAN__,
    native = __BYTE_ORDER__
#    elif defined(SBEPP_BYTE_ORDER)
    little = 0,
    big = 1,
    native = SBEPP_BYTE_ORDER
#    else
#        error "Byte order cannot be detected.\
 Define SBEPP_BYTE_ORDER to 'little' or 'big'"
#    endif
};
#endif
 
static_assert(
    (endian::native == endian::little) || (endian::native == endian::big),
    "Mixed-endian is not supported");
 
namespace detail
{
// modern C++ bits
template<bool B, typename T = void>
using enable_if_t = typename std::enable_if<B, T>::type;
 
template<typename T>
using remove_cv_t = typename std::remove_cv<T>::type;
 
template<typename T>
using remove_reference_t = typename std::remove_reference<T>::type;
 
template<typename ByteFrom, typename ByteTo>
using enable_if_convertible_t =
    enable_if_t<std::is_convertible<ByteFrom*, ByteTo*>::value>;
 
template<typename Byte, typename T = void>
using enable_if_writable_t = enable_if_t<!std::is_const<Byte>::value, T>;
 
template<typename...>
using void_t = void;
 
#if !SBEPP_HAS_BYTESWAP
 
// intrinsics detection is taken from <boost/endian/detail/intrinsic.hpp>
#    ifndef __has_builtin          // Optional of course
#        define __has_builtin(x) 0 // Compatibility with non-clang compilers
#    endif
 
#    if defined(_MSC_VER) && (!defined(__clang__) || defined(__c2__))
 
#        include <cstdlib>
 
inline std::uint64_t byteswap(std::uint64_t v) noexcept
{
    return _byteswap_uint64(v);
}
 
inline std::uint32_t byteswap(std::uint32_t v) noexcept
{
    return _byteswap_ulong(v);
}
 
inline std::uint16_t byteswap(std::uint16_t v) noexcept
{
    return _byteswap_ushort(v);
}
 
#    elif(                                                     \
        defined(__clang__) && __has_builtin(__builtin_bswap32) \
        && __has_builtin(__builtin_bswap64))                   \
        || (defined(__GNUC__)                                  \
            && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)))
 
#        if(defined(__clang__) && __has_builtin(__builtin_bswap16)) \
            || (defined(__GNUC__)                                   \
                && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
 
inline std::uint16_t byteswap(std::uint16_t v) noexcept
{
    return __builtin_bswap16(v);
}
 
#        else
 
inline std::uint16_t byteswap(std::uint16_t v) noexcept
{
    return __builtin_bswap32(v) << 16;
}
 
#        endif
 
inline std::uint64_t byteswap(std::uint64_t v) noexcept
{
    return __builtin_bswap64(v);
}
 
inline std::uint32_t byteswap(std::uint32_t v) noexcept
{
    return __builtin_bswap32(v);
}
 
#    else
 
constexpr std::uint64_t byteswap(std::uint64_t v) noexcept
{
    return ((v & UINT64_C(0x00000000000000FF)) << 56)
           | ((v & UINT64_C(0x000000000000FF00)) << 40)
           | ((v & UINT64_C(0x0000000000FF0000)) << 24)
           | ((v & UINT64_C(0x00000000FF000000)) << 8)
           | ((v & UINT64_C(0x000000FF00000000)) >> 8)
           | ((v & UINT64_C(0x0000FF0000000000)) >> 24)
           | ((v & UINT64_C(0x00FF000000000000)) >> 40)
           | ((v & UINT64_C(0xFF00000000000000)) >> 56);
}
 
constexpr std::uint32_t byteswap(std::uint32_t v) noexcept
{
    return ((v & UINT32_C(0x000000FF)) << 24)
           | ((v & UINT32_C(0x0000FF00)) << 8)
           | ((v & UINT32_C(0x00FF0000)) >> 8)
           | ((v & UINT32_C(0xFF000000)) >> 24);
}
 
constexpr std::uint16_t byteswap(std::uint16_t v) noexcept
{
    return ((v & UINT16_C(0x00FF)) << 8) | ((v & UINT16_C(0xFF00)) >> 8);
}
 
#    endif
#endif
 
template<typename T>
struct fp_underlying_type;
 
template<typename T>
using fp_underlying_type_t = typename fp_underlying_type<T>::type;
 
template<>
struct fp_underlying_type<float>
{
    using type = std::uint32_t;
};
 
template<>
struct fp_underlying_type<double>
{
    using type = std::uint64_t;
};
 
// usually, I don't like putting `enable_if` into return type but these
// overloads are not public and it looks better than adding `typename = void` to
// template headers
template<typename T>
constexpr enable_if_t<sizeof(T) == 1, T> byteswap(T value) noexcept
{
    return value;
}
 
template<typename T>
SBEPP_CPP20_CONSTEXPR
    enable_if_t<!std::is_floating_point<T>::value && (sizeof(T) != 1), T>
    byteswap(T value) noexcept
{
#if SBEPP_HAS_BYTESWAP
    // casts are required because this overload is selected for enums which are
    // not integral and can't be passed to `std::byteswap` as is
    return static_cast<T>(std::byteswap(
        static_cast<typename std::make_unsigned<T>::type>(value)));
#else
    return static_cast<T>(
        byteswap(static_cast<typename std::make_unsigned<T>::type>(value)));
#endif
}
 
template<typename T>
enable_if_t<std::is_floating_point<T>::value, T> byteswap(T value) noexcept
{
    fp_underlying_type_t<T> underlying{};
    std::memcpy(&underlying, &value, sizeof(underlying));
    underlying = byteswap(underlying);
 
    std::memcpy(&value, &underlying, sizeof(underlying));
 
    return value;
}
 
template<typename T, endian E, typename Byte>
SBEPP_CPP20_CONSTEXPR T get_primitive(const Byte* ptr)
{
#if SBEPP_HAS_BITCAST
    std::array<Byte, sizeof(T)> arr;
    if(E == endian::native)
    {
        std::copy(ptr, ptr + sizeof(T), std::begin(arr));
    }
    else
    {
        std::reverse_copy(ptr, ptr + sizeof(T), std::begin(arr));
    }
    return std::bit_cast<T>(arr);
#else
    // old compilers don't optimize `std::copy` approach good enough, that's
    // why explicit `std::memcpy` call is required
    T res;
    std::memcpy(&res, ptr, sizeof(T));
    if(E == endian::native)
    {
        return res;
    }
    else
    {
        return byteswap(res);
    }
#endif
}
 
template<endian E, typename T, typename Byte>
SBEPP_CPP20_CONSTEXPR void set_primitive(Byte* ptr, T value)
{
#if SBEPP_HAS_BITCAST
    auto arr = std::bit_cast<std::array<Byte, sizeof(T)>>(value);
    if(E == endian::native)
    {
        std::copy(std::begin(arr), std::end(arr), ptr);
    }
    else
    {
        std::reverse_copy(std::begin(arr), std::end(arr), ptr);
    }
#else
    // old compilers don't optimize `std::copy` approach good enough, that's
    // why explicit `std::memcpy` call is required
    if(E != endian::native)
    {
        value = byteswap(value);
    }
    std::memcpy(ptr, &value, sizeof(T));
#endif
}
 
struct fill_message_header_tag
{
    explicit fill_message_header_tag() = default;
};
 
struct fill_group_header_tag
{
    explicit fill_group_header_tag() = default;
};
 
struct size_bytes_tag
{
    explicit size_bytes_tag() = default;
};
 
struct addressof_tag
{
    explicit addressof_tag() = default;
};
 
struct end_ptr_tag
{
    explicit end_ptr_tag() = default;
};
 
struct get_header_tag
{
    explicit get_header_tag() = default;
};
 
struct get_block_length_tag
{
    explicit get_block_length_tag() = default;
};
 
struct get_bit_tag
{
    explicit get_bit_tag() = default;
};
 
struct set_bit_tag
{
    explicit set_bit_tag() = default;
};
 
struct get_level_tag
{
    explicit get_level_tag() = default;
};
 
struct visit_tag
{
    explicit visit_tag() = default;
};
 
struct visit_children_tag
{
    explicit visit_children_tag() = default;
};
 
struct enum_to_str_tag
{
    explicit enum_to_str_tag() = default;
};
 
struct visit_set_tag
{
    explicit visit_set_tag() = default;
};
 
template<typename T, typename U, endian E, typename View>
SBEPP_CPP20_CONSTEXPR T
    get_value(const View view, const std::size_t offset) noexcept
{
    SBEPP_SIZE_CHECK(
        view(addressof_tag{}), view(end_ptr_tag{}), offset, sizeof(U));
    return T{get_primitive<U, E>(view(addressof_tag{}) + offset)};
}
 
template<endian E, typename T, typename View>
SBEPP_CPP20_CONSTEXPR void
    set_value(const View view, const std::size_t offset, const T value) noexcept
{
    SBEPP_SIZE_CHECK(
        view(addressof_tag{}), view(end_ptr_tag{}), offset, sizeof(T));
    set_primitive<E>(view(addressof_tag{}) + offset, value);
}
 
template<typename Res, typename View>
SBEPP_CPP20_CONSTEXPR Res
    get_static_field_view(const View view, const std::size_t offset) noexcept
{
    SBEPP_SIZE_CHECK(view(addressof_tag{}), view(end_ptr_tag{}), offset, 0);
    return {view(addressof_tag{}) + offset, view(end_ptr_tag{})};
}
 
template<typename Group, typename View>
SBEPP_CPP20_CONSTEXPR Group
    get_first_dynamic_field_view(const View view) noexcept
{
    return {
        view(get_level_tag{}) + view(get_block_length_tag{}),
        view(end_ptr_tag{})};
}
 
template<typename Group, typename View, typename Prev>
SBEPP_CPP20_CONSTEXPR Group
    get_dynamic_field_view(const View view, const Prev prev) noexcept
{
    return {
        prev(addressof_tag{}) + prev(size_bytes_tag{}), view(end_ptr_tag{})};
}
 
template<typename Byte>
class byte_range
{
public:
    static_assert(sizeof(Byte) == 1, "Byte must represent a single byte");
 
    template<typename Byte2>
    friend class byte_range;
 
    byte_range() = default;
 
    SBEPP_CPP14_CONSTEXPR byte_range(Byte* begin, Byte* end) noexcept
        : begin{begin}
#if SBEPP_SIZE_CHECKS_ENABLED
          ,
          end{end}
#endif
    {
        (void)end;
    }
 
    constexpr byte_range(Byte* ptr, const std::size_t size) noexcept
        : byte_range{ptr, ptr + size}
    {
    }
 
    template<typename Byte2, typename = enable_if_convertible_t<Byte2, Byte>>
    // NOLINTNEXTLINE: intentionally implicit
    constexpr byte_range(const byte_range<Byte2>& other) noexcept
        : begin{other.begin}
#if SBEPP_SIZE_CHECKS_ENABLED
          ,
          end{other.end}
#endif
    {
    }
 
    constexpr Byte* operator()(addressof_tag) const noexcept
    {
        return begin;
    }
 
    constexpr Byte* operator()(end_ptr_tag) const noexcept
    {
#if SBEPP_SIZE_CHECKS_ENABLED
        return end;
#else
        return nullptr;
#endif
    }
 
private:
    Byte* begin{};
#if SBEPP_SIZE_CHECKS_ENABLED
    Byte* end{};
#endif
};
} // namespace detail
 
template<typename Byte>
class cursor
{
public:
    using byte_type = Byte;
 
    // in accessors we have to use trailing return type because in "skip" mode
    // they should return `void`. In most cases it's not a problem but
    // `get_group_view` and `get_data_view` take lambdas which were not allowed
    // in unevaluated context (e.g. decltype) prior to C++20 so we need this
    // alias to specify return types for them. First attempt used
    // pointer-to-member instead of lambda but GCC doesn't support it so I
    // switched to simpler approach with lambda and trait.
    template<typename T>
    using result_type = T;
 
    cursor() = default;
 
    template<
        typename Byte2,
        typename = detail::enable_if_convertible_t<Byte2, Byte>>
    // NOLINTNEXTLINE: implicit conversion is intentional
    constexpr cursor(cursor<Byte2> other) noexcept : ptr{other.ptr}
    {
    }
 
    template<
        typename Byte2,
        typename = detail::enable_if_convertible_t<Byte2, Byte>>
    SBEPP_CPP14_CONSTEXPR cursor& operator=(cursor<Byte2> other) noexcept
    {
        ptr = other.ptr;
        return *this;
    }
 
    SBEPP_CPP14_CONSTEXPR Byte*& pointer() noexcept
    {
        return ptr;
    }
 
    SBEPP_CPP14_CONSTEXPR Byte* pointer() const noexcept
    {
        return ptr;
    }
 
    template<typename T, typename U, endian E, typename View>
    SBEPP_CPP20_CONSTEXPR T get_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (ptr + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(ptr, view(detail::end_ptr_tag{}), offset, sizeof(U));
        T res{detail::get_primitive<U, E>(ptr + offset)};
        ptr += offset + sizeof(U);
        return res;
    }
 
    template<endian E, typename T, typename View>
    SBEPP_CPP20_CONSTEXPR void set_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset,
        const T value) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (ptr + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(ptr, view(detail::end_ptr_tag{}), offset, sizeof(T));
        detail::set_primitive<E>(ptr + offset, value);
        ptr += offset + sizeof(T);
    }
 
    template<typename T, typename U, endian E, typename View>
    SBEPP_CPP20_CONSTEXPR T get_last_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (ptr + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(ptr, view(detail::end_ptr_tag{}), offset, sizeof(U));
        auto res = T{detail::get_primitive<U, E>(ptr + offset)};
        ptr = view(detail::get_level_tag{})
              + view(detail::get_block_length_tag{});
        return res;
    }
 
    template<endian E, typename T, typename View>
    SBEPP_CPP20_CONSTEXPR void set_last_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset,
        const T value) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (ptr + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(ptr, view(detail::end_ptr_tag{}), offset, sizeof(T));
        detail::set_primitive<E>(ptr + offset, value);
        ptr = view(detail::get_level_tag{})
              + view(detail::get_block_length_tag{});
    }
 
    template<typename Res, typename View>
    SBEPP_CPP20_CONSTEXPR Res get_static_field_view(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (ptr + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(ptr, view(detail::end_ptr_tag{}), offset, 0);
        Res res{ptr + offset, view(detail::end_ptr_tag{})};
        ptr += offset + res(detail::size_bytes_tag{});
        return res;
    }
 
    template<typename Res, typename View>
    SBEPP_CPP20_CONSTEXPR Res get_last_static_field_view(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (ptr + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(ptr, view(detail::end_ptr_tag{}), offset, 0);
        Res res{ptr + offset, view(detail::end_ptr_tag{})};
        ptr = view(detail::get_level_tag{})
              + view(detail::get_block_length_tag{});
        return res;
    }
 
    template<typename ResView, typename View>
    SBEPP_CPP20_CONSTEXPR ResView get_first_group_view(const View view) noexcept
    {
        ptr = view(detail::get_level_tag{})
              + view(detail::get_block_length_tag{});
        ResView g{ptr, view(detail::end_ptr_tag{})};
        ptr += g(detail::get_header_tag{})(detail::size_bytes_tag{});
 
        return g;
    }
 
    template<typename ResView, typename View>
    SBEPP_CPP20_CONSTEXPR ResView get_first_data_view(const View view) noexcept
    {
        ptr = view(detail::get_level_tag{})
              + view(detail::get_block_length_tag{});
        ResView d{ptr, view(detail::end_ptr_tag{})};
        ptr += d(detail::size_bytes_tag{});
 
        return d;
    }
 
    template<typename ResView, typename View, typename Getter>
    SBEPP_CPP20_CONSTEXPR ResView
        get_group_view(const View view, Getter&& getter) noexcept
    {
        SBEPP_ASSERT(
            (getter()(detail::addressof_tag{}) == ptr) && "Wrong cursor value");
        ResView res{ptr, view(detail::end_ptr_tag{})};
        auto header = res(detail::get_header_tag{});
        ptr += header(detail::size_bytes_tag{});
        return res;
    }
 
    template<typename ResView, typename View, typename Getter>
    SBEPP_CPP20_CONSTEXPR ResView
        get_data_view(const View view, Getter&& getter) noexcept
    {
        SBEPP_ASSERT(
            (getter()(detail::addressof_tag{}) == ptr) && "Wrong cursor value");
        ResView res{ptr, view(detail::end_ptr_tag{})};
        ptr += res(detail::size_bytes_tag{});
        return res;
    }
 
private:
    template<typename T>
    friend class cursor;
 
    Byte* ptr{};
};
 
namespace detail
{
template<typename Byte>
class init_cursor_wrapper
{
public:
    using byte_type = Byte;
 
    template<typename T>
    using result_type = T;
 
    init_cursor_wrapper() = default;
 
    explicit constexpr init_cursor_wrapper(sbepp::cursor<Byte>& cursor)
        : cursor{&cursor}
    {
    }
 
    template<typename T, typename U, endian E, typename View>
    SBEPP_CPP20_CONSTEXPR T get_value(
        const View view,
        const std::size_t /*offset*/,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_SIZE_CHECK(
            view(addressof_tag{}),
            view(end_ptr_tag{}),
            absolute_offset,
            sizeof(U));
        T res{get_primitive<U, E>(view(addressof_tag{}) + absolute_offset)};
        cursor->pointer() = view(addressof_tag{}) + absolute_offset + sizeof(U);
        return res;
    }
 
    template<endian E, typename T, typename View>
    SBEPP_CPP20_CONSTEXPR void set_value(
        const View view,
        const std::size_t /*offset*/,
        const std::size_t absolute_offset,
        const T value) noexcept
    {
        SBEPP_SIZE_CHECK(
            view(addressof_tag{}),
            view(end_ptr_tag{}),
            absolute_offset,
            sizeof(T));
        set_primitive<E>(view(addressof_tag{}) + absolute_offset, value);
        cursor->pointer() = view(addressof_tag{}) + absolute_offset + sizeof(T);
    }
 
    template<typename T, typename U, endian E, typename View>
    SBEPP_CPP20_CONSTEXPR T get_last_value(
        const View view,
        const std::size_t /*offset*/,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_SIZE_CHECK(
            view(addressof_tag{}),
            view(end_ptr_tag{}),
            absolute_offset,
            sizeof(U));
        T res{get_primitive<U, E>(view(addressof_tag{}) + absolute_offset)};
        cursor->pointer() =
            view(get_level_tag{}) + view(get_block_length_tag{});
        return res;
    }
 
    template<endian E, typename T, typename View>
    SBEPP_CPP20_CONSTEXPR void set_last_value(
        const View view,
        const std::size_t /*offset*/,
        const std::size_t absolute_offset,
        const T value) noexcept
    {
        SBEPP_SIZE_CHECK(
            view(addressof_tag{}),
            view(end_ptr_tag{}),
            absolute_offset,
            sizeof(T));
        set_primitive<E>(view(addressof_tag{}) + absolute_offset, value);
        cursor->pointer() =
            view(get_level_tag{}) + view(get_block_length_tag{});
    }
 
    template<typename Res, typename View>
    SBEPP_CPP20_CONSTEXPR Res get_static_field_view(
        const View view,
        const std::size_t /*offset*/,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_SIZE_CHECK(
            view(addressof_tag{}), view(end_ptr_tag{}), absolute_offset, 0);
        Res res{view(addressof_tag{}) + absolute_offset, view(end_ptr_tag{})};
        cursor->pointer() = res(addressof_tag{}) + res(size_bytes_tag{});
        return res;
    }
 
    template<typename Res, typename View>
    SBEPP_CPP20_CONSTEXPR Res get_last_static_field_view(
        const View view,
        const std::size_t /*offset*/,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_SIZE_CHECK(
            view(addressof_tag{}), view(end_ptr_tag{}), absolute_offset, 0);
        Res res{view(addressof_tag{}) + absolute_offset, view(end_ptr_tag{})};
        cursor->pointer() =
            view(get_level_tag{}) + view(get_block_length_tag{});
        return res;
    }
 
    template<typename ResView, typename View>
    SBEPP_CPP20_CONSTEXPR ResView get_first_group_view(const View view) noexcept
    {
        return cursor->template get_first_group_view<ResView>(view);
    }
 
    template<typename ResView, typename View>
    SBEPP_CPP20_CONSTEXPR ResView get_first_data_view(const View view) noexcept
    {
        return cursor->template get_first_data_view<ResView>(view);
    }
 
    template<typename ResView, typename View, typename Getter>
    SBEPP_CPP20_CONSTEXPR ResView
        get_group_view(const View /*view*/, Getter&& getter) noexcept
    {
        auto res = getter();
        auto header = res(get_header_tag{});
        cursor->pointer() = res(addressof_tag{}) + header(size_bytes_tag{});
        return res;
    }
 
    template<typename ResView, typename View, typename Getter>
    SBEPP_CPP20_CONSTEXPR ResView
        get_data_view(const View /*view*/, Getter&& getter) noexcept
    {
        auto res = getter();
        cursor->pointer() = res(addressof_tag{}) + res(size_bytes_tag{});
        return res;
    }
 
private:
    sbepp::cursor<Byte>* cursor{};
};
 
template<typename Byte>
class init_dont_move_cursor_wrapper
{
public:
    using byte_type = Byte;
 
    template<typename T>
    using result_type = T;
 
    init_dont_move_cursor_wrapper() = default;
 
    explicit constexpr init_dont_move_cursor_wrapper(
        sbepp::cursor<Byte>& cursor)
        : cursor{&cursor}
    {
    }
 
    template<typename T, typename U, endian E, typename View>
    SBEPP_CPP20_CONSTEXPR T get_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_SIZE_CHECK(
            view(addressof_tag{}),
            view(end_ptr_tag{}),
            absolute_offset,
            sizeof(U));
        cursor->pointer() = view(addressof_tag{}) + absolute_offset - offset;
        return T{get_primitive<U, E>(view(addressof_tag{}) + absolute_offset)};
    }
 
    template<endian E, typename T, typename View>
    SBEPP_CPP20_CONSTEXPR void set_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset,
        const T value) noexcept
    {
        SBEPP_SIZE_CHECK(
            view(addressof_tag{}),
            view(end_ptr_tag{}),
            absolute_offset,
            sizeof(T));
        cursor->pointer() = view(addressof_tag{}) + absolute_offset - offset;
        set_primitive<E>(view(addressof_tag{}) + absolute_offset, value);
    }
 
    template<typename T, typename U, endian E, typename View>
    SBEPP_CPP20_CONSTEXPR T get_last_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        return get_value<T, U, E>(view, offset, absolute_offset);
    }
 
    template<endian E, typename T, typename View>
    SBEPP_CPP20_CONSTEXPR void set_last_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset,
        const T value) noexcept
    {
        return set_value<E>(view, offset, absolute_offset, value);
    }
 
    template<typename Res, typename View>
    SBEPP_CPP20_CONSTEXPR Res get_static_field_view(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_SIZE_CHECK(
            view(addressof_tag{}), view(end_ptr_tag{}), absolute_offset, 0);
        cursor->pointer() = view(addressof_tag{}) + absolute_offset - offset;
        return {view(addressof_tag{}) + absolute_offset, view(end_ptr_tag{})};
    }
 
    template<typename Res, typename View>
    SBEPP_CPP20_CONSTEXPR Res get_last_static_field_view(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        return get_static_field_view<Res>(view, offset, absolute_offset);
    }
 
    template<typename ResView, typename View>
    SBEPP_CPP20_CONSTEXPR ResView get_first_group_view(const View view) noexcept
    {
        cursor->pointer() =
            view(get_level_tag{}) + view(get_block_length_tag{});
        ResView g{cursor->pointer(), view(end_ptr_tag{})};
 
        return g;
    }
 
    template<typename ResView, typename View>
    SBEPP_CPP20_CONSTEXPR ResView get_first_data_view(const View view) noexcept
    {
        cursor->pointer() =
            view(get_level_tag{}) + view(get_block_length_tag{});
        ResView d{cursor->pointer(), view(end_ptr_tag{})};
 
        return d;
    }
 
    template<typename ResView, typename View, typename Getter>
    SBEPP_CPP20_CONSTEXPR ResView
        get_group_view(const View /*view*/, Getter&& getter) noexcept
    {
        auto res = getter();
        cursor->pointer() = res(addressof_tag{});
        return res;
    }
 
    template<typename ResView, typename View, typename Getter>
    SBEPP_CPP20_CONSTEXPR ResView
        get_data_view(const View /*view*/, Getter&& getter) noexcept
    {
        auto res = getter();
        cursor->pointer() = res(addressof_tag{});
        return res;
    }
 
private:
    sbepp::cursor<Byte>* cursor{};
};
 
template<typename Byte>
class dont_move_cursor_wrapper
{
public:
    using byte_type = Byte;
 
    template<typename T>
    using result_type = T;
 
    dont_move_cursor_wrapper() = default;
 
    explicit constexpr dont_move_cursor_wrapper(sbepp::cursor<Byte>& cursor)
        : cursor{&cursor}
    {
    }
 
    template<typename T, typename U, endian E, typename View>
    SBEPP_CPP20_CONSTEXPR T get_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (cursor->pointer() + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(
            cursor->pointer(), view(end_ptr_tag{}), offset, sizeof(U));
        return T{get_primitive<U, E>(cursor->pointer() + offset)};
    }
 
    template<endian E, typename T, typename View>
    SBEPP_CPP20_CONSTEXPR void set_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset,
        const T value) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (cursor->pointer() + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(
            cursor->pointer(), view(end_ptr_tag{}), offset, sizeof(T));
        set_primitive<E>(cursor->pointer() + offset, value);
    }
 
    template<typename T, typename U, endian E, typename View>
    SBEPP_CPP20_CONSTEXPR T get_last_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (cursor->pointer() + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(
            cursor->pointer(), view(end_ptr_tag{}), offset, sizeof(U));
        return T{get_primitive<U, E>(cursor->pointer() + offset)};
    }
 
    template<endian E, typename T, typename View>
    SBEPP_CPP20_CONSTEXPR void set_last_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset,
        const T value) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (cursor->pointer() + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(
            cursor->pointer(), view(end_ptr_tag{}), offset, sizeof(T));
        set_primitive<E>(cursor->pointer() + offset, value);
    }
 
    template<typename Res, typename View>
    SBEPP_CPP20_CONSTEXPR Res get_static_field_view(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (cursor->pointer() + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(cursor->pointer(), view(end_ptr_tag{}), offset, 0);
        return {cursor->pointer() + offset, view(end_ptr_tag{})};
    }
 
    template<typename Res, typename View>
    SBEPP_CPP20_CONSTEXPR Res get_last_static_field_view(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (cursor->pointer() + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(cursor->pointer(), view(end_ptr_tag{}), offset, 0);
        return {cursor->pointer() + offset, view(end_ptr_tag{})};
    }
 
    template<typename ResView, typename View>
    SBEPP_CPP20_CONSTEXPR ResView get_first_group_view(const View view) noexcept
    {
        cursor->pointer() =
            view(get_level_tag{}) + view(get_block_length_tag{});
        ResView g{cursor->pointer(), view(end_ptr_tag{})};
 
        return g;
    }
 
    template<typename ResView, typename View>
    SBEPP_CPP20_CONSTEXPR ResView get_first_data_view(const View view) noexcept
    {
        cursor->pointer() =
            view(get_level_tag{}) + view(get_block_length_tag{});
        ResView d{cursor->pointer(), view(end_ptr_tag{})};
 
        return d;
    }
 
    template<typename ResView, typename View, typename Getter>
    SBEPP_CPP20_CONSTEXPR ResView
        get_group_view(const View view, Getter&& getter) noexcept
    {
        SBEPP_ASSERT(
            (getter()(detail::addressof_tag{}) == cursor->pointer())
            && "Wrong cursor value");
        return {cursor->pointer(), view(end_ptr_tag{})};
    }
 
    template<typename ResView, typename View, typename Getter>
    SBEPP_CPP20_CONSTEXPR ResView
        get_data_view(const View view, Getter&& getter) noexcept
    {
        SBEPP_ASSERT(
            (getter()(detail::addressof_tag{}) == cursor->pointer())
            && "Wrong cursor value");
        return {cursor->pointer(), view(end_ptr_tag{})};
    }
 
private:
    sbepp::cursor<Byte>* cursor{};
};
 
template<typename Byte>
class skip_cursor_wrapper
{
public:
    using byte_type = Byte;
 
    template<typename T>
    using result_type = void;
 
    skip_cursor_wrapper() = default;
 
    explicit constexpr skip_cursor_wrapper(sbepp::cursor<Byte>& cursor)
        : cursor{&cursor}
    {
    }
 
    template<typename T, typename U, endian E, typename View>
    SBEPP_CPP20_CONSTEXPR void get_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (cursor->pointer() + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(
            cursor->pointer(), view(end_ptr_tag{}), offset, sizeof(U));
        cursor->pointer() += offset + sizeof(U);
    }
 
    template<typename T, typename U, endian E, typename View>
    SBEPP_CPP20_CONSTEXPR void get_last_value(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (cursor->pointer() + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(
            cursor->pointer(), view(end_ptr_tag{}), offset, sizeof(U));
        cursor->pointer() =
            view(get_level_tag{}) + view(get_block_length_tag{});
    }
 
    template<typename Res, typename View>
    SBEPP_CPP20_CONSTEXPR void get_static_field_view(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (cursor->pointer() + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(cursor->pointer(), view(end_ptr_tag{}), offset, 0);
        Res res{cursor->pointer(), view(end_ptr_tag{})};
        cursor->pointer() += offset + res(size_bytes_tag{});
    }
 
    template<typename Res, typename View>
    SBEPP_CPP20_CONSTEXPR void get_last_static_field_view(
        const View view,
        const std::size_t offset,
        const std::size_t absolute_offset) noexcept
    {
        SBEPP_ASSERT(
            ((view(detail::addressof_tag{}) + absolute_offset)
             == (cursor->pointer() + offset))
            && "Wrong cursor value");
        SBEPP_SIZE_CHECK(cursor->pointer(), view(end_ptr_tag{}), offset, 0);
        cursor->pointer() =
            view(get_level_tag{}) + view(get_block_length_tag{});
    }
 
    template<typename ResView, typename View>
    SBEPP_CPP20_CONSTEXPR void get_first_group_view(const View view) noexcept
    {
        cursor->pointer() =
            view(get_level_tag{}) + view(get_block_length_tag{});
        ResView g{cursor->pointer(), view(end_ptr_tag{})};
        cursor->pointer() += g(size_bytes_tag{});
    }
 
    template<typename ResView, typename View>
    SBEPP_CPP20_CONSTEXPR void get_first_data_view(const View view) noexcept
    {
        cursor->pointer() =
            view(get_level_tag{}) + view(get_block_length_tag{});
        ResView d{cursor->pointer(), view(end_ptr_tag{})};
        cursor->pointer() += d(size_bytes_tag{});
    }
 
    template<typename ResView, typename View, typename Getter>
    SBEPP_CPP20_CONSTEXPR void
        get_group_view(const View view, Getter&& getter) noexcept
    {
        SBEPP_ASSERT(
            (getter()(detail::addressof_tag{}) == cursor->pointer())
            && "Wrong cursor value");
        ResView res{cursor->pointer(), view(end_ptr_tag{})};
        cursor->pointer() += res(size_bytes_tag{});
    }
 
    template<typename ResView, typename View, typename Getter>
    SBEPP_CPP20_CONSTEXPR void
        get_data_view(const View view, Getter&& getter) noexcept
    {
        SBEPP_ASSERT(
            (getter()(detail::addressof_tag{}) == cursor->pointer())
            && "Wrong cursor value");
        ResView res{cursor->pointer(), view(end_ptr_tag{})};
        cursor->pointer() += res(size_bytes_tag{});
    }
 
private:
    sbepp::cursor<Byte>* cursor{};
};
 
template<typename Cursor, typename T>
using cursor_result_type_t =
    typename remove_reference_t<Cursor>::template result_type<T>;
 
template<typename Cursor>
using cursor_byte_type_t = typename remove_reference_t<Cursor>::byte_type;
 
template<typename MessageByte, typename CursorByte>
using enable_if_cursor_compatible_t =
    enable_if_convertible_t<MessageByte, CursorByte>;
 
template<typename MessageByte, typename CursorByte>
using enable_if_cursor_writeable_t = enable_if_t<
    std::is_convertible<MessageByte*, CursorByte*>::value
    && !std::is_const<MessageByte>::value && !std::is_const<CursorByte>::value>;
} // namespace detail
 
template<typename T>
constexpr std::size_t size_bytes(T v) noexcept
{
    return v(detail::size_bytes_tag{});
}
 
template<typename T, typename Byte>
constexpr std::size_t size_bytes(T v, cursor<Byte> c) noexcept
{
    return v(detail::size_bytes_tag{}, c);
}
 
template<typename T>
constexpr auto get_header(T v) noexcept -> decltype(v(detail::get_header_tag{}))
{
    return v(detail::get_header_tag{});
}
 
template<typename T>
constexpr auto addressof(T v) noexcept -> decltype(v(detail::addressof_tag{}))
{
    return v(detail::addressof_tag{});
}
 
template<typename View>
struct byte_type
{
    using type = typename std::remove_pointer<decltype(sbepp::addressof(
        std::declval<View>()))>::type;
};
 
template<typename View>
using byte_type_t = typename byte_type<View>::type;
 
namespace cursor_ops
{
template<typename Byte>
constexpr detail::init_cursor_wrapper<Byte> init(cursor<Byte>& c) noexcept
{
    return detail::init_cursor_wrapper<Byte>{c};
}
 
template<typename Byte>
constexpr detail::dont_move_cursor_wrapper<Byte>
    dont_move(cursor<Byte>& c) noexcept
{
    return detail::dont_move_cursor_wrapper<Byte>{c};
}
 
template<typename Byte>
constexpr detail::init_dont_move_cursor_wrapper<Byte>
    init_dont_move(cursor<Byte>& c) noexcept
{
    return detail::init_dont_move_cursor_wrapper<Byte>{c};
}
 
template<typename Byte>
constexpr detail::skip_cursor_wrapper<Byte> skip(cursor<Byte>& c) noexcept
{
    return detail::skip_cursor_wrapper<Byte>{c};
}
} // namespace cursor_ops
 
namespace detail
{
// the only purpose of this class is to implement `is_composite` trait
template<typename Byte>
class composite_base : public byte_range<Byte>
{
public:
    using byte_range<Byte>::byte_range;
    using byte_range<Byte>::operator();
};
 
template<typename Byte, typename Header>
class message_base : public byte_range<Byte>
{
public:
    using byte_range<Byte>::byte_range;
    using byte_range<Byte>::operator();
 
    SBEPP_CPP14_CONSTEXPR Header operator()(get_header_tag) const noexcept
    {
        Header header{(*this)(addressof_tag{}), (*this)(end_ptr_tag{})};
        SBEPP_SIZE_CHECK(
            (*this)(addressof_tag{}),
            (*this)(end_ptr_tag{}),
            0,
            sbepp::size_bytes(header));
        return header;
    }
 
    SBEPP_CPP14_CONSTEXPR Byte* operator()(get_level_tag) const noexcept
    {
        auto header = (*this)(get_header_tag{});
        return header(addressof_tag{}) + header(size_bytes_tag{});
    }
 
    constexpr typename std::decay<
        decltype(std::declval<Header>().blockLength().value())>::type
        operator()(get_block_length_tag) const noexcept
    {
        return operator()(get_header_tag{}).blockLength().value();
    }
 
    template<
        typename Byte2,
        typename = enable_if_cursor_compatible_t<Byte, Byte2>>
    SBEPP_CPP20_CONSTEXPR std::size_t
        operator()(size_bytes_tag, cursor<Byte2>& c) const noexcept
    {
        return c.pointer() - (*this)(addressof_tag{});
    }
};
 
template<typename Byte, typename BlockLengthType>
class entry_base : public byte_range<Byte>
{
public:
    using byte_range<Byte>::operator();
 
    template<typename Byte2, typename BlockLengthType2>
    friend class entry_base;
 
    entry_base() = default;
 
    constexpr entry_base(
        Byte* ptr, Byte* end, BlockLengthType block_length) noexcept
        : byte_range<Byte>{ptr, end}, block_length{block_length}
    {
    }
 
    constexpr entry_base(
        Byte* ptr,
        const std::size_t size,
        const BlockLengthType block_length) noexcept
        : entry_base{ptr, ptr + size, block_length}
    {
    }
 
    template<typename Byte2, typename = enable_if_convertible_t<Byte2, Byte>>
    constexpr entry_base(
        cursor<Byte2>& c, Byte* end_ptr, BlockLengthType block_length) noexcept
        : entry_base{c.pointer(), end_ptr, block_length}
    {
        // forwards to the above one for non-empty entries. Empty entries have
        // implementation in the derived class which advances cursor up to
        // `block_length`.
    }
 
    template<typename Byte2, typename = enable_if_convertible_t<Byte2, Byte>>
    constexpr entry_base(
        const entry_base<Byte2, BlockLengthType>& other) noexcept
        : byte_range<Byte>{other}, block_length{other.block_length}
    {
    }
 
    constexpr BlockLengthType operator()(get_block_length_tag) const noexcept
    {
        return block_length;
    }
 
    constexpr Byte* operator()(get_level_tag) const noexcept
    {
        return (*this)(addressof_tag{});
    }
 
private:
    BlockLengthType block_length{};
};
 
template<typename Entry>
class arrow_proxy
{
public:
    explicit constexpr arrow_proxy(Entry entry) noexcept : entry{entry}
    {
    }
 
    constexpr const Entry* operator->() const noexcept
    {
        return &entry;
    }
 
private:
    Entry entry;
};
 
template<
    typename Byte,
    typename ValueType,
    typename IndexType,
    typename DifferenceType,
    typename BlockLengthType>
class forward_iterator
{
public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = ValueType;
    using reference = value_type;
    using difference_type = DifferenceType;
    using pointer = arrow_proxy<value_type>;
 
    forward_iterator() = default;
 
    SBEPP_CPP14_CONSTEXPR forward_iterator(
        Byte* ptr,
        const IndexType index,
        const BlockLengthType block_length,
        Byte* end) noexcept
        : ptr{ptr},
          index{index},
          block_length{block_length}
#if SBEPP_SIZE_CHECKS_ENABLED
          ,
          end{end}
#endif
    {
        (void)end;
    }
 
    constexpr reference operator*() const noexcept
    {
#if SBEPP_SIZE_CHECKS_ENABLED
        return {ptr, end, block_length};
#else
        return {ptr, nullptr, block_length};
#endif
    }
 
    constexpr pointer operator->() const noexcept
    {
        return pointer{operator*()};
    }
 
    SBEPP_CPP14_CONSTEXPR forward_iterator& operator++() noexcept
    {
        SBEPP_SIZE_CHECK(ptr, end, 0, sbepp::size_bytes(operator*()));
        ptr += sbepp::size_bytes(operator*());
        index++;
        return *this;
    }
 
    SBEPP_CPP14_CONSTEXPR forward_iterator operator++(int) noexcept
    {
        auto old = *this;
        operator++();
        return old;
    }
 
    friend constexpr bool operator==(
        const forward_iterator& lhs, const forward_iterator& rhs) noexcept
    {
        return lhs.index == rhs.index;
    }
 
    friend constexpr bool operator!=(
        const forward_iterator& lhs, const forward_iterator& rhs) noexcept
    {
        return lhs.index != rhs.index;
    }
 
private:
    Byte* ptr{};
    IndexType index{};
    BlockLengthType block_length{};
#if SBEPP_SIZE_CHECKS_ENABLED
    Byte* end{};
#endif
};
 
template<
    typename Byte,
    typename ValueType,
    typename BlockLengthType,
    typename DifferenceType,
    typename IndexType>
class random_access_iterator
{
public:
    using iterator_category = std::random_access_iterator_tag;
    using value_type = ValueType;
    using reference = value_type;
    using difference_type = DifferenceType;
    using pointer = arrow_proxy<value_type>;
 
    random_access_iterator() = default;
 
    SBEPP_CPP14_CONSTEXPR random_access_iterator(
        Byte* ptr,
        const BlockLengthType block_length,
        const IndexType index,
        Byte* end) noexcept
        : ptr{ptr},
          block_length{block_length},
          index{index}
#if SBEPP_SIZE_CHECKS_ENABLED
          ,
          end{end}
#endif
    {
        (void)end;
    }
 
    constexpr reference operator*() const noexcept
    {
#if SBEPP_SIZE_CHECKS_ENABLED
        return {ptr, end, block_length};
#else
        return {ptr, nullptr, block_length};
#endif
    }
 
    constexpr pointer operator->() const noexcept
    {
        return pointer{operator*()};
    }
 
    SBEPP_CPP14_CONSTEXPR random_access_iterator& operator++() noexcept
    {
        SBEPP_SIZE_CHECK(ptr, end, 0, block_length);
        ptr += block_length;
        index++;
        return *this;
    }
 
    SBEPP_CPP14_CONSTEXPR random_access_iterator operator++(int) noexcept
    {
        auto old = *this;
        operator++();
        return old;
    }
 
    SBEPP_CPP14_CONSTEXPR random_access_iterator& operator--() noexcept
    {
        ptr -= block_length;
        index--;
        return *this;
    }
 
    SBEPP_CPP14_CONSTEXPR random_access_iterator operator--(int) noexcept
    {
        auto old = *this;
        operator--();
        return old;
    }
 
    SBEPP_CPP14_CONSTEXPR random_access_iterator&
        operator+=(difference_type n) noexcept
    {
        ptr += n * block_length;
        index += n;
        return *this;
    }
 
    SBEPP_CPP14_CONSTEXPR random_access_iterator
        operator+(difference_type n) const noexcept
    {
        auto tmp = *this;
        return tmp += n;
    }
 
    friend constexpr random_access_iterator
        operator+(difference_type n, const random_access_iterator& it) noexcept
    {
        return it + n;
    }
 
    SBEPP_CPP14_CONSTEXPR random_access_iterator&
        operator-=(difference_type n) noexcept
    {
        return *this += -n;
    }
 
    SBEPP_CPP14_CONSTEXPR random_access_iterator
        operator-(difference_type n) const noexcept
    {
        auto tmp = *this;
        return tmp -= n;
    }
 
    constexpr difference_type
        operator-(const random_access_iterator& rhs) const noexcept
    {
        return index - rhs.index;
    }
 
    constexpr reference operator[](difference_type n) const noexcept
    {
        return *(*this + n);
    }
 
    friend constexpr bool operator==(
        const random_access_iterator& lhs,
        const random_access_iterator& rhs) noexcept
    {
        return lhs.index == rhs.index;
    }
 
    friend constexpr bool operator!=(
        const random_access_iterator& lhs,
        const random_access_iterator& rhs) noexcept
    {
        return lhs.index != rhs.index;
    }
 
    friend constexpr bool operator<(
        const random_access_iterator& lhs,
        const random_access_iterator& rhs) noexcept
    {
        return lhs.index < rhs.index;
    }
 
    friend constexpr bool operator<=(
        const random_access_iterator& lhs,
        const random_access_iterator& rhs) noexcept
    {
        return lhs.index <= rhs.index;
    }
 
    friend constexpr bool operator>(
        const random_access_iterator& lhs,
        const random_access_iterator& rhs) noexcept
    {
        return lhs.index > rhs.index;
    }
 
    friend constexpr bool operator>=(
        const random_access_iterator& lhs,
        const random_access_iterator& rhs) noexcept
    {
        return lhs.index >= rhs.index;
    }
 
private:
    Byte* ptr{};
    BlockLengthType block_length{};
    // iterator should be index-based instead of just pointer-based to support
    // groups with empty entries, i.e. when `block_length == 0`
    IndexType index{};
#if SBEPP_SIZE_CHECKS_ENABLED
    Byte* end{};
#endif
};
 
template<
    typename ValueType,
    typename IndexType,
    typename CursorType,
    typename BlockLengthType,
    typename Byte>
class input_iterator
{
public:
    using iterator_category = std::input_iterator_tag;
    using value_type = ValueType;
    using reference = value_type;
    using difference_type = typename std::make_signed<IndexType>::type;
    using pointer = arrow_proxy<value_type>;
 
    input_iterator() = default;
 
    SBEPP_CPP14_CONSTEXPR input_iterator(
        const IndexType index,
        CursorType* cursor,
        BlockLengthType block_length,
        Byte* end) noexcept
        : index{index},
          cursor{cursor},
          block_length{block_length}
#if SBEPP_SIZE_CHECKS_ENABLED
          ,
          end{end}
#endif
    {
        (void)end;
    }
 
    constexpr reference operator*() const noexcept
    {
#if SBEPP_SIZE_CHECKS_ENABLED
        return {*cursor, end, block_length};
#else
        return {*cursor, nullptr, block_length};
#endif
    }
 
    constexpr pointer operator->() const noexcept
    {
        return pointer{operator*()};
    }
 
    SBEPP_CPP14_CONSTEXPR input_iterator& operator++() noexcept
    {
        index++;
        return *this;
    }
 
    SBEPP_CPP14_CONSTEXPR input_iterator operator++(int) noexcept
    {
        auto old = *this;
        operator++();
        return old;
    }
 
    friend constexpr bool operator==(
        const input_iterator& lhs, const input_iterator& rhs) noexcept
    {
        return lhs.index == rhs.index;
    }
 
    friend constexpr bool operator!=(
        const input_iterator& lhs, const input_iterator& rhs) noexcept
    {
        return lhs.index != rhs.index;
    }
 
private:
    IndexType index{};
    CursorType* cursor{};
    BlockLengthType block_length{};
#if SBEPP_SIZE_CHECKS_ENABLED
    Byte* end{};
#endif
};
 
template<
    typename ValueType,
    typename IndexType,
    typename CursorType,
    typename BlockLengthType,
    typename Byte>
class cursor_range
{
public:
    SBEPP_CPP14_CONSTEXPR cursor_range(
        CursorType& cursor,
        BlockLengthType block_length,
        Byte* end,
        IndexType start_pos,
        IndexType length) noexcept
        : cursor{&cursor},
          block_length{block_length},
          start_pos{start_pos},
#if SBEPP_SIZE_CHECKS_ENABLED
          end_ptr{end},
#endif
          length{length}
    {
        (void)end;
    }
 
    using iterator =
        input_iterator<ValueType, IndexType, CursorType, BlockLengthType, Byte>;
 
    constexpr iterator begin() const noexcept
    {
#if SBEPP_SIZE_CHECKS_ENABLED
        return {start_pos, cursor, block_length, end_ptr};
#else
        return {start_pos, cursor, block_length, nullptr};
#endif
    }
 
    constexpr iterator end() const noexcept
    {
#if SBEPP_SIZE_CHECKS_ENABLED
        return {
            static_cast<IndexType>(start_pos + size()),
            cursor,
            block_length,
            end_ptr};
#else
        return {
            static_cast<IndexType>(start_pos + size()),
            cursor,
            block_length,
            nullptr};
#endif
    }
 
    constexpr IndexType size() const noexcept
    {
        return length;
    }
 
private:
    CursorType* cursor{};
    BlockLengthType block_length{};
    IndexType start_pos{};
#if SBEPP_SIZE_CHECKS_ENABLED
    Byte* end_ptr{};
#endif
    IndexType length{};
};
 
template<typename Byte, typename Entry, typename Dimension>
class flat_group_base : public byte_range<Byte>
{
public:
    using value_type = Entry;
    using reference = value_type;
    using sbe_size_type = typename std::decay<
        decltype(std::declval<Dimension>().numInGroup())>::type;
    using size_type = typename sbe_size_type::value_type;
    using difference_type = typename std::make_signed<size_type>::type;
    using iterator = random_access_iterator<
        Byte,
        Entry,
        typename std::decay<
            decltype(std::declval<Dimension>().blockLength().value())>::type,
        difference_type,
        size_type>;
 
    using byte_range<Byte>::byte_range;
    using byte_range<Byte>::operator();
 
    SBEPP_CPP14_CONSTEXPR Dimension operator()(get_header_tag) const noexcept
    {
        Dimension header{(*this)(addressof_tag{}), (*this)(end_ptr_tag{})};
        SBEPP_SIZE_CHECK(
            (*this)(addressof_tag{}),
            (*this)(end_ptr_tag{}),
            0,
            sbepp::size_bytes(header));
        return header;
    }
 
    SBEPP_CPP20_CONSTEXPR std::size_t operator()(size_bytes_tag) const noexcept
    {
        auto dimension = (*this)(get_header_tag{});
        return sbepp::size_bytes(dimension)
               + dimension.numInGroup().value()
                     * dimension.blockLength().value();
    }
 
    SBEPP_CPP20_CONSTEXPR sbe_size_type sbe_size() const noexcept
    {
        return (*this)(get_header_tag{}).numInGroup();
    }
 
    SBEPP_CPP20_CONSTEXPR size_type size() const noexcept
    {
        return sbe_size().value();
    }
 
    SBEPP_CPP20_CONSTEXPR void resize(const size_type count) const noexcept
    {
        (*this)(get_header_tag{}).numInGroup(count);
    }
 
    SBEPP_CPP17_NODISCARD SBEPP_CPP20_CONSTEXPR bool empty() const noexcept
    {
        return !size();
    }
 
    constexpr static size_type max_size() noexcept
    {
        return sbe_size_type::max_value();
    }
 
    SBEPP_CPP14_CONSTEXPR iterator begin() const noexcept
    {
        auto dimension = (*this)(get_header_tag{});
        return iterator{
            (*this)(addressof_tag{}) + sbepp::size_bytes(dimension),
            dimension.blockLength().value(),
            0,
            (*this)(end_ptr_tag{})};
    }
 
    constexpr iterator end() const noexcept
    {
        return iterator{
            (*this)(addressof_tag{}) + (*this)(size_bytes_tag{}),
            (*this)(get_header_tag{}).blockLength().value(),
            size(),
            (*this)(end_ptr_tag{})};
    }
 
    SBEPP_CPP14_CONSTEXPR reference operator[](size_type pos) const noexcept
    {
        SBEPP_ASSERT(pos < size());
        return *(begin() + pos);
    }
 
    SBEPP_CPP14_CONSTEXPR reference front() const noexcept
    {
        SBEPP_ASSERT(!empty());
        return *begin();
    }
 
    SBEPP_CPP14_CONSTEXPR reference back() const noexcept
    {
        SBEPP_ASSERT(!empty());
        return *(--end());
    }
 
    SBEPP_CPP14_CONSTEXPR void clear() const noexcept
    {
        resize(0);
    }
 
    template<typename Byte2>
    using cursor_range_t = detail::cursor_range<
        value_type,
        size_type,
        cursor<Byte2>,
        typename std::decay<
            decltype(std::declval<Dimension>().blockLength().value())>::type,
        Byte>;
 
    template<
        typename Byte2,
        typename = enable_if_cursor_compatible_t<Byte, Byte2>>
    SBEPP_CPP20_CONSTEXPR cursor_range_t<Byte2>
        cursor_range(cursor<Byte2>& c) const noexcept
    {
        return {
            c,
            (*this)(get_header_tag{}).blockLength().value(),
            (*this)(end_ptr_tag{}),
            0,
            size()};
    }
 
    template<
        typename Byte2,
        typename = enable_if_cursor_compatible_t<Byte, Byte2>>
    SBEPP_CPP20_CONSTEXPR cursor_range_t<Byte2>
        cursor_subrange(cursor<Byte2>& c, const size_type pos) const noexcept
    {
        SBEPP_ASSERT(pos < size());
 
        return {
            c,
            (*this)(get_header_tag{}).blockLength().value(),
            (*this)(end_ptr_tag{}),
            pos,
            static_cast<size_type>(size() - pos)};
    }
 
    template<
        typename Byte2,
        typename = enable_if_cursor_compatible_t<Byte, Byte2>>
    SBEPP_CPP20_CONSTEXPR cursor_range_t<Byte2> cursor_subrange(
        cursor<Byte2>& c,
        const size_type pos,
        const size_type count) const noexcept
    {
        SBEPP_ASSERT(pos < size());
        SBEPP_ASSERT(count <= (size() - pos));
 
        return {
            c,
            (*this)(get_header_tag{}).blockLength().value(),
            (*this)(end_ptr_tag{}),
            pos,
            count};
    }
 
    template<typename Byte2>
    using cursor_iterator = typename cursor_range_t<Byte2>::iterator;
 
    template<
        typename Byte2,
        typename = enable_if_cursor_compatible_t<Byte, Byte2>>
    SBEPP_CPP20_CONSTEXPR cursor_iterator<Byte2>
        cursor_begin(cursor<Byte2>& c) const noexcept
    {
        return cursor_range(c).begin();
    }
 
    template<
        typename Byte2,
        typename = enable_if_cursor_compatible_t<Byte, Byte2>>
    SBEPP_CPP20_CONSTEXPR cursor_iterator<Byte2>
        cursor_end(cursor<Byte2>& c) const noexcept
    {
        return cursor_range(c).end();
    }
 
    template<typename Visitor, typename Cursor>
    SBEPP_CPP14_CONSTEXPR bool
        operator()(visit_children_tag, Visitor& v, Cursor& c)
    {
        for(const auto entry : this->cursor_range(c))
        {
            if(v.on_entry(entry, c))
            {
                return true;
            }
        }
        return false;
    }
};
 
template<typename Byte, typename Entry, typename Dimension>
class nested_group_base : public byte_range<Byte>
{
public:
    using value_type = Entry;
    using reference = value_type;
    using sbe_size_type = typename std::decay<
        decltype(std::declval<Dimension>().numInGroup())>::type;
    using size_type = typename sbe_size_type::value_type;
    using difference_type = typename std::make_signed<size_type>::type;
 
    using iterator = forward_iterator<
        Byte,
        Entry,
        size_type,
        difference_type,
        typename std::decay<
            decltype(std::declval<Dimension>().blockLength().value())>::type>;
 
    using byte_range<Byte>::byte_range;
    using byte_range<Byte>::operator();
 
    SBEPP_CPP14_CONSTEXPR Dimension operator()(get_header_tag) const noexcept
    {
        Dimension header{(*this)(addressof_tag{}), (*this)(end_ptr_tag{})};
        SBEPP_SIZE_CHECK(
            (*this)(addressof_tag{}),
            (*this)(end_ptr_tag{}),
            0,
            sbepp::size_bytes(header));
        return header;
    }
 
    SBEPP_CPP20_CONSTEXPR std::size_t operator()(size_bytes_tag) const noexcept
    {
        std::size_t size{sbepp::size_bytes((*this)(get_header_tag{}))};
        for(const auto entry : *this)
        {
            size += sbepp::size_bytes(entry);
        }
 
        return size;
    }
 
    SBEPP_CPP20_CONSTEXPR sbe_size_type sbe_size() const noexcept
    {
        return (*this)(get_header_tag{}).numInGroup();
    }
 
    SBEPP_CPP20_CONSTEXPR size_type size() const noexcept
    {
        return sbe_size().value();
    }
 
    SBEPP_CPP20_CONSTEXPR void resize(const size_type count) const noexcept
    {
        (*this)(get_header_tag{}).numInGroup(count);
    }
 
    SBEPP_CPP17_NODISCARD SBEPP_CPP20_CONSTEXPR bool empty() const noexcept
    {
        return !size();
    }
 
    constexpr static size_type max_size() noexcept
    {
        return sbe_size_type::max_value();
    }
 
    SBEPP_CPP14_CONSTEXPR iterator begin() const noexcept
    {
        auto dimension = (*this)(get_header_tag{});
        return iterator{
            (*this)(addressof_tag{}) + sbepp::size_bytes(dimension),
            0,
            dimension.blockLength().value(),
            (*this)(end_ptr_tag{})};
    }
 
    constexpr iterator end() const noexcept
    {
        return iterator{
            nullptr,
            (*this)(get_header_tag{}).numInGroup().value(),
            (*this)(get_header_tag{}).blockLength().value(),
            (*this)(end_ptr_tag{})};
    }
 
    SBEPP_CPP14_CONSTEXPR reference front() const noexcept
    {
        SBEPP_ASSERT(!empty());
        return *begin();
    }
 
    SBEPP_CPP14_CONSTEXPR void clear() const noexcept
    {
        resize(0);
    }
 
    template<typename Byte2>
    using cursor_range_t = detail::cursor_range<
        value_type,
        size_type,
        cursor<Byte2>,
        typename std::decay<
            decltype(std::declval<Dimension>().blockLength().value())>::type,
        Byte>;
 
    template<
        typename Byte2,
        typename = enable_if_cursor_compatible_t<Byte, Byte2>>
    SBEPP_CPP20_CONSTEXPR cursor_range_t<Byte2>
        cursor_range(cursor<Byte2>& c) const noexcept
    {
        return {
            c,
            (*this)(get_header_tag{}).blockLength().value(),
            (*this)(end_ptr_tag{}),
            0,
            size()};
    }
 
    template<
        typename Byte2,
        typename = enable_if_cursor_compatible_t<Byte, Byte2>>
    SBEPP_CPP20_CONSTEXPR cursor_range_t<Byte2>
        cursor_subrange(cursor<Byte2>& c, const size_type pos) const noexcept
    {
        SBEPP_ASSERT(pos < size());
 
        return {
            c,
            (*this)(get_header_tag{}).blockLength().value(),
            (*this)(end_ptr_tag{}),
            pos,
            static_cast<size_type>(size() - pos)};
    }
 
    template<
        typename Byte2,
        typename = enable_if_cursor_compatible_t<Byte, Byte2>>
    SBEPP_CPP20_CONSTEXPR cursor_range_t<Byte2> cursor_subrange(
        cursor<Byte2>& c,
        const size_type pos,
        const size_type count) const noexcept
    {
        SBEPP_ASSERT(pos < size());
        SBEPP_ASSERT(count <= (size() - pos));
 
        return {
            c,
            (*this)(get_header_tag{}).blockLength().value(),
            (*this)(end_ptr_tag{}),
            pos,
            count};
    }
 
    template<typename Byte2>
    using cursor_iterator = typename cursor_range_t<Byte2>::iterator;
 
    template<
        typename Byte2,
        typename = enable_if_cursor_compatible_t<Byte, Byte2>>
    SBEPP_CPP20_CONSTEXPR cursor_iterator<Byte2>
        cursor_begin(cursor<Byte2>& c) const noexcept
    {
        return cursor_range(c).begin();
    }
 
    template<
        typename Byte2,
        typename = enable_if_cursor_compatible_t<Byte, Byte2>>
    SBEPP_CPP20_CONSTEXPR cursor_iterator<Byte2>
        cursor_end(cursor<Byte2>& c) const noexcept
    {
        return cursor_range(c).end();
    }
 
    template<typename Visitor, typename Cursor>
    SBEPP_CPP14_CONSTEXPR bool
        operator()(visit_children_tag, Visitor& v, Cursor& c)
    {
        for(const auto entry : this->cursor_range(c))
        {
            if(v.on_entry(entry, c))
            {
                return true;
            }
        }
        return false;
    }
};
 
template<typename T>
class bitset_base
{
public:
    bitset_base() = default;
 
    explicit constexpr bitset_base(T value) noexcept : bits{value}
    {
    }
 
    SBEPP_CPP14_CONSTEXPR T& operator*() noexcept
    {
        return bits;
    }
 
    constexpr T operator*() const noexcept
    {
        return bits;
    }
 
    constexpr bool
        operator()(get_bit_tag, const choice_index_t n) const noexcept
    {
        return bits & (1 << n);
    }
 
    SBEPP_CPP14_CONSTEXPR void
        operator()(set_bit_tag, const choice_index_t n, const bool b) noexcept
    {
        bits = ((bits & ~(1 << n)) | (b << n));
    }
 
    constexpr friend bool
        operator==(const bitset_base& lhs, const bitset_base& rhs) noexcept
    {
        return *lhs == *rhs;
    }
 
    constexpr friend bool
        operator!=(const bitset_base& lhs, const bitset_base& rhs) noexcept
    {
        return *lhs != *rhs;
    }
 
private:
    T bits{};
};
 
template<typename View, typename = void_t<>>
struct has_get_header : std::false_type
{
};
 
template<typename View>
struct has_get_header<
    View,
    void_t<decltype(sbepp::get_header(std::declval<View>()))>> : std::true_type
{
};
 
template<
    typename View,
    typename = detail::enable_if_t<detail::has_get_header<View>::value>>
constexpr std::size_t get_header_size(View view) noexcept
{
    return sbepp::size_bytes(sbepp::get_header(view));
}
 
template<
    typename View,
    typename = detail::enable_if_t<!detail::has_get_header<View>::value>,
    typename = int>
constexpr std::size_t get_header_size(View) noexcept
{
    return 0;
}
} // namespace detail
 
template<typename Enum>
constexpr typename std::underlying_type<Enum>::type
    to_underlying(Enum e) noexcept
{
    return static_cast<typename std::underlying_type<Enum>::type>(e);
}
 
template<typename View>
SBEPP_CPP14_CONSTEXPR cursor<byte_type_t<View>> init_cursor(View view) noexcept
{
    cursor<byte_type_t<View>> c;
    c.pointer() = sbepp::addressof(view) + detail::get_header_size(view);
    return c;
}
 
template<typename View>
SBEPP_CPP14_CONSTEXPR cursor<typename std::add_const<byte_type_t<View>>::type>
    init_const_cursor(View view) noexcept
{
    cursor<typename std::add_const<byte_type_t<View>>::type> c;
    c.pointer() = sbepp::addressof(view) + detail::get_header_size(view);
    return c;
}
 
struct default_init_t
{
    explicit default_init_t() = default;
};
 
SBEPP_CPP17_INLINE_VAR constexpr default_init_t default_init{};
 
enum class eos_null
{
    none,
    single,
    all
};
 
namespace detail
{
template<typename From, typename To>
struct copy_cv_qualifiers
{
    using copy_const_t = typename std::
        conditional<std::is_const<From>::value, const To, To>::type;
 
    using type = typename std::conditional<
        std::is_volatile<From>::value,
        volatile copy_const_t,
        copy_const_t>::type;
};
 
template<typename From, typename To>
using apply_cv_qualifiers_t = typename copy_cv_qualifiers<From, To>::type;
 
#if SBEPP_HAS_RANGES
template<typename R>
using is_range = std::bool_constant<std::ranges::range<R>>;
#else
template<typename R, typename = void_t<>>
struct is_range : std::false_type
{
};
 
template<typename R>
struct is_range<
    R,
    void_t<
        decltype(std::begin(std::declval<R>())),
        decltype(std::end(std::declval<R>()))>> : std::true_type
{
};
#endif
 
constexpr bool is_constant_evaluated() noexcept
{
    // it's possible to use `__builtin_is_constant_evaluated` with lower C++
    // versions but I see no reason for this since it's only used for
    // `assign_string` and other accessors are not be `constexpr` until C++20
#if SBEPP_HAS_IS_CONSTANT_EVALUATED
    return std::is_constant_evaluated();
#else
    return false;
#endif
}
 
inline SBEPP_CPP20_CONSTEXPR std::size_t string_length(const char* str) noexcept
{
    if(is_constant_evaluated())
    {
        std::size_t length{};
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
        for(; *str != '\0'; str++, length++)
        {
        }
 
        return length;
    }
    else
    {
        return std::strlen(str);
    }
}
 
template<typename Byte, typename Value, std::size_t N, typename Tag>
class static_array_ref : public detail::byte_range<Byte>
{
public:
    using element_type = detail::apply_cv_qualifiers_t<Byte, Value>;
    using value_type = Value;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = element_type&;
    using pointer = element_type*;
    using iterator = pointer;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using tag = Tag;
 
    using detail::byte_range<Byte>::byte_range;
    using detail::byte_range<Byte>::operator();
 
    constexpr std::size_t operator()(detail::size_bytes_tag) const noexcept
    {
        return size();
    }
 
    SBEPP_CPP14_CONSTEXPR reference operator[](size_type pos) const noexcept
    {
        SBEPP_ASSERT(pos < size());
        return data()[pos];
    }
 
    constexpr reference front() const noexcept
    {
        return *data();
    }
 
    constexpr reference back() const noexcept
    {
        return data()[size() - 1];
    }
 
    SBEPP_CPP14_CONSTEXPR pointer data() const noexcept
    {
        // it would be nice to use `reinterpret_cast` here but it's not allowed
        // in constexpr context
        SBEPP_SIZE_CHECK(
            (*this)(detail::addressof_tag{}),
            (*this)(detail::end_ptr_tag{}),
            0,
            N);
        return (pointer)(*this)(detail::addressof_tag{}); // NOLINT
    }
 
    SBEPP_CPP17_NODISCARD static constexpr bool empty() noexcept
    {
        return !size();
    }
 
    static constexpr size_type size() noexcept
    {
        return N;
    }
 
    static constexpr size_type max_size() noexcept
    {
        return size();
    }
 
    constexpr iterator begin() const noexcept
    {
        return data();
    }
 
    constexpr iterator end() const noexcept
    {
        return data() + size();
    }
 
    constexpr reverse_iterator rbegin() const noexcept
    {
        return reverse_iterator{end()};
    }
 
    constexpr reverse_iterator rend() const noexcept
    {
        return reverse_iterator{begin()};
    }
 
    constexpr static_array_ref<Byte, detail::remove_cv_t<Byte>, N, Tag>
        raw() const noexcept
    {
        return static_array_ref<Byte, detail::remove_cv_t<Byte>, N, Tag>{
            (*this)(detail::addressof_tag{}), (*this)(detail::end_ptr_tag{})};
    }
 
    SBEPP_CPP20_CONSTEXPR std::size_t strlen() const noexcept
    {
        if(is_constant_evaluated())
        {
            return string_length(data());
        }
        else
        {
            const auto first_null = static_cast<const value_type*>(
                std::memchr(data(), '\0', size()));
            if(first_null)
            {
                return first_null - data();
            }
 
            return size();
        }
    }
 
    SBEPP_CPP20_CONSTEXPR std::size_t strlen_r() const noexcept
    {
        const auto last_non_null = std::find_if(
            rbegin(),
            rend(),
            [](const value_type value)
            {
                return value != '\0';
            });
        return size() - (last_non_null - rbegin());
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR iterator assign_string(
        const char* str, const eos_null eos_mode = eos_null::all) const noexcept
    {
        SBEPP_ASSERT(str != nullptr);
        const auto length = string_length(str);
        SBEPP_ASSERT(length <= size());
        const auto eos_pos = std::copy_n(str, length, begin());
        pad(eos_mode, eos_pos);
        return eos_pos;
    }
 
    template<
        typename R,
        typename =
            enable_if_t<!std::is_const<Byte>::value && is_range<R>::value>>
    SBEPP_CPP20_CONSTEXPR iterator
        assign_string(R&& r, const eos_null eos_mode = eos_null::all) const
    {
        auto eos_pos = assign_range(std::forward<R>(r));
        pad(eos_mode, eos_pos);
        return eos_pos;
    }
 
    template<
        typename R,
        typename =
            enable_if_t<!std::is_const<Byte>::value && is_range<R>::value>>
    SBEPP_CPP20_CONSTEXPR iterator assign_range(R&& r) const
    {
#if SBEPP_HAS_RANGES
        auto res = std::ranges::copy(std::forward<R>(r), begin()).out;
#else
        auto res = std::copy(std::begin(r), std::end(r), begin());
#endif
        SBEPP_ASSERT(res <= end());
        return res;
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR void fill(const value_type value) const noexcept
    {
        std::fill_n(begin(), size(), value);
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR iterator
        assign(size_type count, const value_type value) const noexcept
    {
        SBEPP_ASSERT(count <= size());
        return std::fill_n(begin(), count, value);
    }
 
    template<typename InputIt, typename = enable_if_writable_t<Byte, InputIt>>
    SBEPP_CPP20_CONSTEXPR iterator assign(InputIt first, InputIt last) const
    {
        const auto last_out = std::copy(first, last, begin());
        SBEPP_ASSERT(static_cast<size_type>(last_out - begin()) <= size());
        return last_out;
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR iterator
        assign(std::initializer_list<value_type> ilist) const noexcept
    {
        SBEPP_ASSERT(ilist.size() <= size());
        return assign(std::begin(ilist), std::end(ilist));
    }
 
private:
    SBEPP_CPP20_CONSTEXPR void
        pad(const eos_null mode, iterator eos_pos) const noexcept
    {
        if(mode == eos_null::all)
        {
            std::fill(eos_pos, end(), '\0');
        }
        else if(mode == eos_null::single)
        {
            if(eos_pos != end())
            {
                *eos_pos = '\0';
            }
        }
        else
        {
            SBEPP_ASSERT(mode == eos_null::none);
            return;
        }
    }
};
 
template<typename Byte, typename Value, typename Length, endian E>
class dynamic_array_ref : public detail::byte_range<Byte>
{
public:
    static_assert(
        std::is_unsigned<typename Length::value_type>::value,
        "Length must be unsigned");
 
    using element_type = detail::apply_cv_qualifiers_t<Byte, Value>;
    using value_type = Value;
    using sbe_size_type = Length;
    using size_type = typename sbe_size_type::value_type;
    using difference_type = std::ptrdiff_t;
    using reference = element_type&;
    using pointer = element_type*;
    using iterator = pointer;
    using reverse_iterator = std::reverse_iterator<iterator>;
 
    using detail::byte_range<Byte>::byte_range;
    using detail::byte_range<Byte>::operator();
 
    constexpr iterator begin() const noexcept
    {
        return data_checked();
    }
 
    SBEPP_CPP20_CONSTEXPR iterator end() const noexcept
    {
        return begin() + size();
    }
 
    SBEPP_CPP20_CONSTEXPR reverse_iterator rbegin() const noexcept
    {
        return reverse_iterator{end()};
    }
 
    constexpr reverse_iterator rend() const noexcept
    {
        return reverse_iterator{begin()};
    }
 
    SBEPP_CPP14_CONSTEXPR reference front() const noexcept
    {
        SBEPP_ASSERT(!empty());
        return *data();
    }
 
    SBEPP_CPP20_CONSTEXPR reference back() const noexcept
    {
        SBEPP_ASSERT(!empty());
        return *(data() + size() - 1);
    }
 
    SBEPP_CPP14_CONSTEXPR pointer data() const noexcept
    {
        return data_checked();
    }
 
    SBEPP_CPP14_CONSTEXPR reference operator[](size_type pos) const noexcept
    {
        SBEPP_ASSERT(pos < size());
        return *(data() + pos);
    }
 
    SBEPP_CPP20_CONSTEXPR sbe_size_type sbe_size() const noexcept
    {
        return detail::get_value<size_type, size_type, E>(*this, 0);
    }
 
    SBEPP_CPP20_CONSTEXPR size_type size() const noexcept
    {
        return sbe_size().value();
    }
 
    SBEPP_CPP17_NODISCARD SBEPP_CPP20_CONSTEXPR bool empty() const noexcept
    {
        return !size();
    }
 
    constexpr static size_type max_size() noexcept
    {
        return sbe_size_type::max_value();
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR void clear() const noexcept
    {
        resize(0, default_init);
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR void resize(size_type count) const noexcept
    {
        const auto old_size = size();
        resize(count, default_init);
        if(count > old_size)
        {
            for(auto i = old_size; i != count; i++)
            {
                operator[](i) = {};
            }
        }
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR void
        resize(size_type count, value_type value) const noexcept
    {
        const auto old_size = size();
        resize(count, default_init);
        if(count > old_size)
        {
            for(auto i = old_size; i != count; i++)
            {
                operator[](i) = value;
            }
        }
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR void
        resize(size_type count, sbepp::default_init_t) const noexcept
    {
        // can't use `detail::set_value()` here because its size check checks
        // only `sizeof(T)`, here we need `sizeof(size_type) + count`
        SBEPP_SIZE_CHECK(
            (*this)(addressof_tag{}),
            (*this)(end_ptr_tag{}),
            0,
            sizeof(size_type) + count);
        set_primitive<E>((*this)(addressof_tag{}), count);
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR void push_back(value_type value) const noexcept
    {
        const auto current_size = size();
        resize(current_size + 1, default_init);
        (*this)[current_size] = value;
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR void pop_back() const noexcept
    {
        SBEPP_ASSERT(!empty());
        resize(size() - 1, default_init);
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR iterator erase(iterator pos) const noexcept
    {
        SBEPP_ASSERT(pos >= begin() && pos < end());
        std::copy(pos + 1, end(), pos);
        resize(size() - 1, default_init);
        return pos;
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR iterator
        erase(iterator first, iterator last) const noexcept
    {
        SBEPP_ASSERT(first >= begin() && last < end());
        std::copy(last, end(), first);
        resize(size() - (last - first), default_init);
        return first;
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR iterator
        insert(iterator pos, const value_type value) const noexcept
    {
        SBEPP_ASSERT(pos >= begin() && pos <= end());
        const auto old_end = end();
        resize(size() + 1, default_init);
        std::copy_backward(pos, old_end, end());
        *pos = value;
        return pos;
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR iterator insert(
        iterator pos, size_type count, const value_type value) const noexcept
    {
        SBEPP_ASSERT(pos >= begin() && pos <= end());
        const auto old_end = end();
        resize(size() + count, default_init);
        std::copy_backward(pos, old_end, end());
        std::fill_n(pos, count, value);
        return pos;
    }
 
    template<
        typename InputIt,
        typename = detail::enable_if_t<
            !std::is_const<Byte>::value
            && std::is_convertible<
                typename std::iterator_traits<InputIt>::iterator_category,
                std::input_iterator_tag>::value>>
    SBEPP_CPP14_CONSTEXPR iterator
        insert(iterator pos, InputIt first, InputIt last) const
    {
        SBEPP_ASSERT(pos >= begin() && pos <= end());
        using category_t =
            typename std::iterator_traits<InputIt>::iterator_category;
        return insert_impl(pos, first, last, category_t{});
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    constexpr iterator insert(
        iterator pos, std::initializer_list<value_type> ilist) const noexcept
    {
        return insert(pos, std::begin(ilist), std::end(ilist));
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR void
        assign(size_type count, const value_type value) const noexcept
    {
        resize(count, default_init);
        std::fill_n(begin(), count, value);
    }
 
    template<typename InputIt, typename = enable_if_writable_t<Byte, InputIt>>
    SBEPP_CPP20_CONSTEXPR void assign(InputIt first, InputIt last) const
    {
        auto begin = data_unchecked();
        const auto new_end = std::copy(first, last, begin);
        resize(new_end - begin, default_init);
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR void
        assign(std::initializer_list<value_type> ilist) const noexcept
    {
        SBEPP_SIZE_CHECK(
            (*this)(detail::addressof_tag{}),
            (*this)(detail::end_ptr_tag{}),
            0,
            sizeof(size_type) + ilist.size());
        assign(std::begin(ilist), std::end(ilist));
    }
 
    constexpr dynamic_array_ref<Byte, detail::remove_cv_t<Byte>, Length, E>
        raw() const noexcept
    {
        return dynamic_array_ref<Byte, detail::remove_cv_t<Byte>, Length, E>{
            (*this)(detail::addressof_tag{}), (*this)(detail::end_ptr_tag{})};
    }
 
    SBEPP_CPP20_CONSTEXPR std::size_t
        operator()(detail::size_bytes_tag) const noexcept
    {
        return sizeof(size_type) + size();
    }
 
    template<typename T = void, typename = enable_if_writable_t<Byte, T>>
    SBEPP_CPP20_CONSTEXPR void assign_string(const char* str) const noexcept
    {
        SBEPP_ASSERT(str != nullptr);
        const auto length = string_length(str);
        resize(length, default_init);
        std::copy_n(str, length, begin());
    }
 
    template<
        typename R,
        typename =
            enable_if_t<!std::is_const<Byte>::value && is_range<R>::value>>
    SBEPP_CPP20_CONSTEXPR void assign_range(R&& r) const
    {
        const auto begin = data_unchecked();
#if SBEPP_HAS_RANGES
        const auto new_end = std::ranges::copy(std::forward<R>(r), begin).out;
#else
        const auto new_end = std::copy(std::begin(r), std::end(r), begin);
#endif
        resize(new_end - begin, default_init);
    }
 
private:
    SBEPP_CPP14_CONSTEXPR pointer data_checked() const noexcept
    {
        SBEPP_SIZE_CHECK(
            (*this)(detail::addressof_tag{}),
            (*this)(detail::end_ptr_tag{}),
            0,
            sizeof(size_type) + size());
        return data_unchecked();
    }
 
    SBEPP_CPP14_CONSTEXPR pointer data_unchecked() const noexcept
    {
        SBEPP_SIZE_CHECK(
            (*this)(detail::addressof_tag{}),
            (*this)(detail::end_ptr_tag{}),
            0,
            sizeof(size_type));
        // cast is conditionally required here when `Byte` is different type
        // from `Value`. `reinterpret_cast` is not allowed in constexpr context
        // even when it's an identity cast. On the other hand, C-style cast
        // is allowed in constexpr context when it renders to an identity cast
        // which effectively makes this and other functions conditionally
        // `constexpr` when `Byte` is equal to `Value`.
        // NOLINTNEXTLINE: see above
        return (pointer)((*this)(detail::addressof_tag{}) + sizeof(size_type));
    }
 
    template<typename It>
    SBEPP_CPP14_CONSTEXPR iterator insert_impl(
        iterator pos, It first, It last, std::input_iterator_tag) const
    {
        auto out = pos;
        for(; first != last; ++first, ++out)
        {
            insert(out, *first);
        }
 
        return pos;
    }
 
    template<typename It>
    SBEPP_CPP20_CONSTEXPR iterator insert_impl(
        iterator pos, It first, It last, std::forward_iterator_tag) const
    {
        const auto in_size = std::distance(first, last);
        auto old_end = end();
        resize(size() + in_size, default_init);
        std::copy_backward(pos, old_end, end());
        std::copy(first, last, pos);
        return pos;
    }
};
} // namespace detail
 
struct nullopt_t
{
    explicit constexpr nullopt_t(int)
    {
    }
};
 
SBEPP_CPP17_INLINE_VAR constexpr nullopt_t nullopt{0};
 
namespace detail
{
// see `optional_base` note about explicit `alignas`
template<typename T, typename Derived>
class alignas(T) required_base
{
public:
    using value_type = T;
 
    required_base() = default;
 
    // NOLINTNEXTLINE: it should be implicit
    constexpr required_base(value_type val) noexcept : val{val}
    {
    }
 
    constexpr value_type value() const noexcept
    {
        return **this;
    }
 
    SBEPP_CPP14_CONSTEXPR value_type& operator*() noexcept
    {
        return val;
    }
 
    constexpr value_type operator*() const noexcept
    {
        return val;
    }
 
    constexpr bool in_range() const noexcept
    {
        return (Derived::min_value() <= val) && (val <= Derived::max_value());
    }
 
#ifdef SBEPP_DOXYGEN
    friend auto
        operator<=>(const required_base&, const required_base&) = default;
#endif
 
#if SBEPP_HAS_THREE_WAY_COMPARISON
    friend auto
        operator<=>(const required_base&, const required_base&) = default;
#else
    constexpr friend bool
        operator==(const required_base& lhs, const required_base& rhs) noexcept
    {
        return *lhs == *rhs;
    }
 
    constexpr friend bool
        operator!=(const required_base& lhs, const required_base& rhs) noexcept
    {
        return *lhs != *rhs;
    }
 
    constexpr friend bool
        operator<(const required_base& lhs, const required_base& rhs) noexcept
    {
        return *lhs < *rhs;
    }
 
    constexpr friend bool
        operator<=(const required_base& lhs, const required_base& rhs) noexcept
    {
        return *lhs <= *rhs;
    }
 
    constexpr friend bool
        operator>(const required_base& lhs, const required_base& rhs) noexcept
    {
        return *lhs > *rhs;
    }
 
    constexpr friend bool
        operator>=(const required_base& lhs, const required_base& rhs) noexcept
    {
        return *lhs >= *rhs;
    }
#endif
 
private:
    value_type val{};
};
 
// old compilers might generate wrong alignment for classes which contain
// `double` member. To overcome this, explicit alignment is provided.
template<typename T, typename Derived>
class alignas(T) optional_base
{
public:
    using value_type = T;
 
    optional_base() = default;
 
    // NOLINTNEXTLINE: it's intentionally implicit
    constexpr optional_base(nullopt_t) noexcept : optional_base{}
    {
    }
 
    // NOLINTNEXTLINE: it's intentionally implicit
    constexpr optional_base(value_type val) noexcept : val{val}
    {
    }
 
    constexpr value_type value() const noexcept
    {
        return **this;
    }
 
    SBEPP_CPP14_CONSTEXPR value_type& operator*() noexcept
    {
        return val;
    }
 
    constexpr value_type operator*() const noexcept
    {
        return val;
    }
 
    constexpr bool in_range() const noexcept
    {
        return (Derived::min_value() <= val) && (val <= Derived::max_value());
    }
 
    SBEPP_CPP14_CONSTEXPR value_type value_or(T default_value) const noexcept
    {
        if(*this)
        {
            return value();
        }
        return default_value;
    }
 
    constexpr bool has_value() const noexcept
    {
        return (val != Derived::null_value());
    }
 
    constexpr explicit operator bool() const noexcept
    {
        return has_value();
    }
 
 
    constexpr friend bool
        operator==(const optional_base& lhs, const optional_base& rhs) noexcept
    {
        return *lhs == *rhs;
    }
 
#ifdef SBEPP_DOXYGEN
    constexpr friend std::strong_ordering operator<=>(
        const optional_base& lhs, const optional_base& rhs) noexcept;
#endif
 
#if SBEPP_HAS_THREE_WAY_COMPARISON
    constexpr friend std::strong_ordering
        operator<=>(const optional_base& lhs, const optional_base& rhs) noexcept
    {
        if(lhs && rhs)
        {
            return *lhs <=> *rhs;
        }
        return lhs.has_value() <=> rhs.has_value();
    }
#else
 
    constexpr friend bool
        operator!=(const optional_base& lhs, const optional_base& rhs) noexcept
    {
        return *lhs != *rhs;
    }
 
    constexpr friend bool
        operator<(const optional_base& lhs, const optional_base& rhs) noexcept
    {
        return rhs && (!lhs || (*lhs < *rhs));
    }
 
    constexpr friend bool
        operator<=(const optional_base& lhs, const optional_base& rhs) noexcept
    {
        return !lhs || (rhs && (*lhs <= *rhs));
    }
 
    constexpr friend bool
        operator>(const optional_base& lhs, const optional_base& rhs) noexcept
    {
        return lhs && (!rhs || (*lhs > *rhs));
    }
 
    constexpr friend bool
        operator>=(const optional_base& lhs, const optional_base& rhs) noexcept
    {
        return !rhs || (lhs && (*lhs >= *rhs));
    }
#endif
 
private:
    value_type val{Derived::null_value()};
};
} // namespace detail
 
template<typename Message>
constexpr auto fill_message_header(Message m) noexcept
    -> decltype(m(detail::fill_message_header_tag{}))
{
    return m(detail::fill_message_header_tag{});
}
 
template<typename Group, typename Size>
constexpr auto fill_group_header(Group g, Size num_in_group) noexcept
    -> decltype(g(detail::fill_group_header_tag{}, num_in_group))
{
    return g(detail::fill_group_header_tag{}, num_in_group);
}
 
template<typename T>
class type_traits;
 
#ifdef SBEPP_DOXYGEN
template<typename T>
class type_traits
{
public:
    using primitive_type = PrimitiveType;
 
    using value_type = ValueType;
 
    template<typename Byte>
    using value_type = ArrayType<Byte>;
 
    static constexpr const char* name() noexcept;
 
    static constexpr const char* description() noexcept;
 
    static constexpr field_presence presence() noexcept;
 
    static constexpr primitive_type min_value() noexcept;
 
    static constexpr primitive_type max_value() noexcept;
 
    static constexpr primitive_type null_value() noexcept;
 
    static constexpr length_t length() noexcept;
 
    static constexpr offset_t offset() noexcept;
 
    static constexpr const char* semantic_type() noexcept;
 
    static constexpr version_t since_version() noexcept;
 
    static constexpr version_t deprecated() noexcept;
 
    static constexpr const char* character_encoding() noexcept;
};
#endif
 
template<typename T>
class schema_traits;
 
#ifdef SBEPP_DOXYGEN
template<typename T>
class schema_traits
{
public:
    static constexpr const char* package() noexcept;
    static constexpr schema_id_t id() noexcept;
    static constexpr version_t version() noexcept;
    static constexpr const char* semantic_version() noexcept;
    static constexpr endian byte_order() noexcept;
    static constexpr const char* description() noexcept;
    template<typename Byte>
    using header_type = HeaderComposite<Byte>;
    using header_type_tag = HeaderTypeTag;
};
#endif
 
template<typename T>
class enum_traits;
 
#ifdef SBEPP_DOXYGEN
template<typename T>
class enum_traits
{
public:
    static constexpr const char* name() noexcept;
    static constexpr const char* description() noexcept;
    using encoding_type = EncodingType;
    static constexpr offset_t offset() noexcept;
    static constexpr version_t since_version() noexcept;
    static constexpr version_t deprecated() noexcept;
    using value_type = ScopedEnumType;
};
#endif
 
template<typename T>
class enum_value_traits;
 
#ifdef SBEPP_DOXYGEN
template<typename T>
class enum_value_traits
{
public:
    static constexpr const char* name() noexcept;
    static constexpr const char* description() noexcept;
    static constexpr version_t since_version() noexcept;
    static constexpr version_t deprecated() noexcept;
    static constexpr ScopedEnumType value() noexcept;
};
#endif
 
template<typename T>
class set_traits;
 
#ifdef SBEPP_DOXYGEN
template<typename T>
class set_traits
{
public:
    static constexpr const char* name() noexcept;
    static constexpr const char* description() noexcept;
    static constexpr version_t since_version() noexcept;
    static constexpr version_t deprecated() noexcept;
    using encoding_type = EncodingType;
    static constexpr offset_t offset() noexcept;
    using value_type = SetType;
};
#endif
 
template<typename T>
class set_choice_traits;
 
#ifdef SBEPP_DOXYGEN
template<typename T>
class set_choice_traits
{
public:
    static constexpr const char* name() noexcept;
    static constexpr const char* description() noexcept;
    static constexpr version_t since_version() noexcept;
    static constexpr version_t deprecated() noexcept;
    static constexpr choice_index_t index() noexcept;
};
#endif
 
template<typename T>
class composite_traits;
 
#ifdef SBEPP_DOXYGEN
template<typename T>
class composite_traits
{
public:
    static constexpr const char* name() noexcept;
    static constexpr const char* description() noexcept;
    static constexpr offset_t offset() noexcept;
    static constexpr const char* semantic_type() noexcept;
    static constexpr version_t since_version() noexcept;
    // !schema
    static constexpr version_t deprecated() noexcept;
    template<typename Byte>
    using value_type = CompositeType<Byte>;
    static constexpr std::size_t size_bytes() noexcept;
};
#endif
 
template<typename T>
class message_traits;
 
#ifdef SBEPP_DOXYGEN
template<typename T>
class message_traits
{
public:
    static constexpr const char* name() noexcept;
    static constexpr const char* description() noexcept;
    static constexpr message_id_t id() noexcept;
    static constexpr block_length_t block_length() noexcept;
    static constexpr const char* semantic_type() noexcept;
    static constexpr version_t since_version() noexcept;
    static constexpr version_t deprecated() noexcept;
    template<typename Byte>
    using value_type = MessageType<Byte>;
    using schema_tag = SchemaTag;
 
    static constexpr std::size_t size_bytes(...) noexcept;
};
#endif
 
template<typename T>
class field_traits;
 
#ifdef SBEPP_DOXYGEN
template<typename T>
class field_traits
{
public:
    static constexpr const char* name() noexcept;
    static constexpr member_id_t id() noexcept;
    static constexpr const char* description() noexcept;
    static constexpr field_presence presence() noexcept;
    static constexpr offset_t offset() noexcept;
    static constexpr version_t since_version() noexcept;
    static constexpr version_t deprecated() noexcept;
    using value_type = ValueType;
    template<typename Byte>
    using value_type = Type<Byte>;
    using value_type_tag = TypeTag;
};
#endif
 
template<typename T>
class group_traits;
 
#ifdef SBEPP_DOXYGEN
template<typename T>
class group_traits
{
public:
    static constexpr const char* name() noexcept;
    static constexpr const char* description() noexcept;
    static constexpr member_id_t id() noexcept;
    static constexpr block_length_t block_length() noexcept;
    static constexpr const char* semantic_type() noexcept;
    static constexpr version_t since_version() noexcept;
    static constexpr version_t deprecated() noexcept;
    template<typename Byte>
    using value_type = GroupType<Byte>;
    template<typename Byte>
    using dimension_type = HeaderType<Byte>;
    using dimension_type_tag = HeaderTag;
    template<typename Byte>
    using entry_type = EntryType<Byte>;
    static constexpr std::size_t
        size_bytes(const NumInGroupType num_in_group, ...) noexcept;
};
#endif
 
template<typename T>
class data_traits;
 
#ifdef SBEPP_DOXYGEN
template<typename T>
class data_traits
{
public:
    static constexpr const char* name() noexcept;
    static constexpr member_id_t id() noexcept;
    static constexpr const char* description() noexcept;
    static constexpr version_t since_version() noexcept;
    static constexpr version_t deprecated() noexcept;
    template<typename Byte>
    using value_type = DataType;
    using length_type = LengthType;
    using length_type_tag = LengthTypeTag;
    static constexpr std::size_t
        size_bytes(const length_type::value_type size) noexcept;
};
#endif
template<typename ValueType>
struct traits_tag;
 
#ifdef SBEPP_DOXYGEN
template<typename ValueType>
struct traits_tag
{
    using type = Tag;
};
#endif
 
template<typename ValueType>
using traits_tag_t = typename traits_tag<ValueType>::type;
 
template<typename Byte, typename Value, std::size_t N, typename Tag>
struct traits_tag<detail::static_array_ref<Byte, Value, N, Tag>>
{
    using type = Tag;
};
 
// NOLINTNEXTLINE: macro is required here
#define SBEPP_BUILT_IN_IMPL(NAME, TYPE, MIN, MAX, NULL)                   \
                           \
                             \
    class NAME##_t : public detail::required_base<TYPE, NAME##_t>         \
    {                                                                     \
    public:                                                               \
        using detail::required_base<TYPE, NAME##_t>::required_base;       \
                                                                          \
                        \
        static constexpr value_type min_value() noexcept                  \
        {                                                                 \
            return {MIN};                                                 \
        }                                                                 \
                                                                          \
                        \
        static constexpr value_type max_value() noexcept                  \
        {                                                                 \
            return {MAX};                                                 \
        }                                                                 \
    };                                                                    \
                                                                          \
 
      \
    class NAME##_opt_t : public detail::optional_base<TYPE, NAME##_opt_t> \
    {                                                                     \
    public:                                                               \
        using detail::optional_base<TYPE, NAME##_opt_t>::optional_base;   \
                                                                          \
                        \
        static constexpr value_type min_value() noexcept                  \
        {                                                                 \
            return {MIN};                                                 \
        }                                                                 \
                                                                          \
                        \
        static constexpr value_type max_value() noexcept                  \
        {                                                                 \
            return {MAX};                                                 \
        }                                                                 \
                                                                          \
                       \
        static constexpr value_type null_value() noexcept                 \
        {                                                                 \
            return {NULL};                                                \
        }                                                                 \
    };                                                                    \
                                                                          \
    template<>                                                            \
    class type_traits<NAME##_t>                                           \
    {                                                                     \
    public:                                                               \
        static constexpr const char* name() noexcept                      \
        {                                                                 \
            return #NAME;                                                 \
        }                                                                 \
                                                                          \
        static constexpr const char* description() noexcept               \
        {                                                                 \
            return "";                                                    \
        }                                                                 \
                                                                          \
        static constexpr field_presence presence() noexcept               \
        {                                                                 \
            return field_presence::required;                              \
        }                                                                 \
                                                                          \
        static constexpr TYPE min_value() noexcept                        \
        {                                                                 \
            return NAME##_t::min_value();                                 \
        }                                                                 \
                                                                          \
        static constexpr TYPE max_value() noexcept                        \
        {                                                                 \
            return NAME##_t::max_value();                                 \
        }                                                                 \
                                                                          \
        static constexpr length_t length() noexcept                       \
        {                                                                 \
            return 1;                                                     \
        }                                                                 \
                                                                          \
        static constexpr const char* semantic_type() noexcept             \
        {                                                                 \
            return "";                                                    \
        }                                                                 \
                                                                          \
        static constexpr version_t since_version() noexcept               \
        {                                                                 \
            return 0;                                                     \
        }                                                                 \
                                                                          \
        using value_type = NAME##_t;                                      \
        using primitive_type = value_type::value_type;                    \
    };                                                                    \
                                                                          \
    template<>                                                            \
    struct traits_tag<NAME##_t>                                           \
    {                                                                     \
        using type = NAME##_t;                                            \
    };                                                                    \
                                                                          \
    template<>                                                            \
    class type_traits<NAME##_opt_t>                                       \
    {                                                                     \
    public:                                                               \
        static constexpr const char* name() noexcept                      \
        {                                                                 \
            return #NAME;                                                 \
        }                                                                 \
                                                                          \
        static constexpr const char* description() noexcept               \
        {                                                                 \
            return "";                                                    \
        }                                                                 \
                                                                          \
        static constexpr field_presence presence() noexcept               \
        {                                                                 \
            return field_presence::optional;                              \
        }                                                                 \
                                                                          \
        static constexpr TYPE min_value() noexcept                        \
        {                                                                 \
            return NAME##_opt_t::min_value();                             \
        }                                                                 \
                                                                          \
        static constexpr TYPE max_value() noexcept                        \
        {                                                                 \
            return NAME##_opt_t::max_value();                             \
        }                                                                 \
                                                                          \
        static constexpr TYPE null_value() noexcept                       \
        {                                                                 \
            return NAME##_opt_t::null_value();                            \
        }                                                                 \
                                                                          \
        static constexpr length_t length() noexcept                       \
        {                                                                 \
            return 1;                                                     \
        }                                                                 \
                                                                          \
        static constexpr const char* semantic_type() noexcept             \
        {                                                                 \
            return "";                                                    \
        }                                                                 \
                                                                          \
        static constexpr version_t since_version() noexcept               \
        {                                                                 \
            return 0;                                                     \
        }                                                                 \
                                                                          \
        using value_type = NAME##_opt_t;                                  \
        using primitive_type = value_type::value_type;                    \
    };                                                                    \
                                                                          \
    template<>                                                            \
    struct traits_tag<NAME##_opt_t>                                       \
    {                                                                     \
        using type = NAME##_opt_t;                                        \
    }
 
SBEPP_BUILT_IN_IMPL(char, char, 0x20, 0x7E, 0);
SBEPP_BUILT_IN_IMPL(
    int8,
    std::int8_t,
    std::numeric_limits<std::int8_t>::min() + 1,
    std::numeric_limits<std::int8_t>::max(),
    std::numeric_limits<std::int8_t>::min());
SBEPP_BUILT_IN_IMPL(
    uint8,
    std::uint8_t,
    std::numeric_limits<std::uint8_t>::min(),
    std::numeric_limits<std::uint8_t>::max() - 1,
    std::numeric_limits<std::uint8_t>::max());
SBEPP_BUILT_IN_IMPL(
    int16,
    std::int16_t,
    std::numeric_limits<std::int16_t>::min() + 1,
    std::numeric_limits<std::int16_t>::max(),
    std::numeric_limits<std::int16_t>::min());
SBEPP_BUILT_IN_IMPL(
    uint16,
    std::uint16_t,
    std::numeric_limits<std::uint16_t>::min(),
    std::numeric_limits<std::uint16_t>::max() - 1,
    std::numeric_limits<std::uint16_t>::max());
SBEPP_BUILT_IN_IMPL(
    int32,
    std::int32_t,
    std::numeric_limits<std::int32_t>::min() + 1,
    std::numeric_limits<std::int32_t>::max(),
    std::numeric_limits<std::int32_t>::min());
SBEPP_BUILT_IN_IMPL(
    uint32,
    std::uint32_t,
    std::numeric_limits<std::uint32_t>::min(),
    std::numeric_limits<std::uint32_t>::max() - 1,
    std::numeric_limits<std::uint32_t>::max());
SBEPP_BUILT_IN_IMPL(
    int64,
    std::int64_t,
    std::numeric_limits<std::int64_t>::min() + 1,
    std::numeric_limits<std::int64_t>::max(),
    std::numeric_limits<std::int64_t>::min());
SBEPP_BUILT_IN_IMPL(
    uint64,
    std::uint64_t,
    std::numeric_limits<std::uint64_t>::min(),
    std::numeric_limits<std::uint64_t>::max() - 1,
    std::numeric_limits<std::uint64_t>::max());
SBEPP_BUILT_IN_IMPL(
    float,
    float,
    std::numeric_limits<float>::min(),
    std::numeric_limits<float>::max(),
    std::numeric_limits<float>::quiet_NaN());
SBEPP_BUILT_IN_IMPL(
    double,
    double,
    std::numeric_limits<double>::min(),
    std::numeric_limits<double>::max(),
    std::numeric_limits<double>::quiet_NaN());
 
#undef SBEPP_BUILT_IN_IMPL
 
template<template<typename> class View, typename Byte>
constexpr View<Byte> make_view(Byte* ptr, const std::size_t size) noexcept
{
    return {ptr, size};
}
 
template<template<typename> class View, typename Byte>
constexpr View<typename std::add_const<Byte>::type>
    make_const_view(Byte* ptr, const std::size_t size) noexcept
{
    return {ptr, size};
}
 
struct unknown_enum_value_tag
{
};
 
namespace detail
{
// taken from https://stackoverflow.com/a/34672753
template<template<typename...> class Base, typename Derived>
struct is_base_of_tmp_impl
{
    static constexpr std::false_type test(...);
 
    template<typename... Ts>
    static constexpr std::true_type test(Base<Ts...>*);
 
    using type = decltype(test(std::declval<Derived*>()));
};
 
template<template<typename...> class Base, typename Derived>
using is_base_of_tmp = typename is_base_of_tmp_impl<Base, Derived>::type;
 
#if SBEPP_HAS_CONCEPTS
template<typename Derived, template<typename...> class Base>
concept derived_from_tmp = is_base_of_tmp<Base, Derived>::value;
#endif
} // namespace detail
 
namespace detail
{
template<typename Derived>
struct is_array_type_impl
{
    static constexpr std::false_type test(...);
 
    template<typename T1, typename T2, std::size_t N, typename T3>
    static constexpr std::true_type
        test(detail::static_array_ref<T1, T2, N, T3>*);
 
    using type = decltype(test(std::declval<Derived*>()));
};
} // namespace detail
 
template<typename T>
using is_array_type = typename detail::is_array_type_impl<T>::type;
 
template<typename T>
using is_required_type = detail::is_base_of_tmp<detail::required_base, T>;
 
template<typename T>
using is_optional_type = detail::is_base_of_tmp<detail::optional_base, T>;
 
template<typename T>
using is_non_array_type = std::integral_constant<
    bool,
    is_required_type<T>::value || is_optional_type<T>::value>;
 
template<typename T>
using is_type = std::integral_constant<
    bool,
    is_required_type<T>::value || is_optional_type<T>::value
        || is_array_type<T>::value>;
 
template<typename T, typename = void>
struct is_enum : std::false_type
{
};
 
template<typename T>
struct is_enum<
    T,
    detail::void_t<decltype(tag_invoke(
        std::declval<detail::visit_tag>(),
        std::declval<T>(),
        std::declval<int&>()))>> : std::true_type
{
};
 
template<typename T>
using is_set = detail::is_base_of_tmp<detail::bitset_base, T>;
 
template<typename T>
using is_composite = detail::is_base_of_tmp<detail::composite_base, T>;
 
template<typename T>
using is_message = detail::is_base_of_tmp<detail::message_base, T>;
 
template<typename T>
using is_flat_group = detail::is_base_of_tmp<detail::flat_group_base, T>;
 
template<typename T>
using is_nested_group = detail::is_base_of_tmp<detail::nested_group_base, T>;
 
template<typename T>
using is_group = std::integral_constant<
    bool,
    is_flat_group<T>::value || is_nested_group<T>::value>;
 
template<typename T>
using is_group_entry = detail::is_base_of_tmp<detail::entry_base, T>;
 
namespace detail
{
template<typename Derived>
struct is_data_impl
{
    static constexpr std::false_type test(...);
 
    template<typename T1, typename T2, typename T3, endian E>
    static constexpr std::true_type
        test(detail::dynamic_array_ref<T1, T2, T3, E>*);
 
    using type = decltype(test(std::declval<Derived*>()));
};
} // namespace detail
 
template<typename T>
using is_data = typename detail::is_data_impl<T>::type;
 
#if SBEPP_HAS_INLINE_VARS
template<typename T>
inline constexpr auto is_array_type_v = is_array_type<T>::value;
 
template<typename T>
inline constexpr auto is_required_type_v = is_required_type<T>::value;
 
template<typename T>
inline constexpr auto is_optional_type_v = is_optional_type<T>::value;
 
template<typename T>
inline constexpr auto is_non_array_type_v = is_non_array_type<T>::value;
 
template<typename T>
inline constexpr auto is_type_v = is_type<T>::value;
 
template<typename T>
inline constexpr auto is_enum_v = is_enum<T>::value;
 
template<typename T>
inline constexpr auto is_set_v = is_set<T>::value;
 
template<typename T>
inline constexpr auto is_composite_v = is_composite<T>::value;
 
template<typename T>
inline constexpr auto is_message_v = is_message<T>::value;
 
template<typename T>
inline constexpr auto is_flat_group_v = is_flat_group<T>::value;
 
template<typename T>
inline constexpr auto is_nested_group_v = is_nested_group<T>::value;
 
template<typename T>
inline constexpr auto is_group_v = is_group<T>::value;
 
template<typename T>
inline constexpr auto is_data_v = is_data<T>::value;
#endif
 
#if SBEPP_HAS_CONCEPTS
template<typename T>
concept array_type = is_array_type_v<T>;
 
template<typename T>
concept required_type = is_required_type_v<T>;
 
template<typename T>
concept optional_type = is_optional_type_v<T>;
 
template<typename T>
concept non_array_type = is_non_array_type_v<T>;
 
template<typename T>
concept type = is_type_v<T>;
 
template<typename T>
concept enumeration = is_enum_v<T>;
 
template<typename T>
concept set = is_set_v<T>;
 
template<typename T>
concept composite = is_composite_v<T>;
 
template<typename T>
concept message = is_message_v<T>;
 
template<typename T>
concept flat_group = is_flat_group_v<T>;
 
template<typename T>
concept nested_group = is_nested_group_v<T>;
 
template<typename T>
concept group = is_group_v<T>;
 
template<typename T>
concept data = is_data_v<T>;
#endif
 
namespace detail
{
template<typename T>
using is_visitable_view = std::integral_constant<
    bool,
    is_message<T>::value || is_group<T>::value || is_group_entry<T>::value
        || is_composite<T>::value>;
}
 
template<
    typename Visitor,
    typename View,
    typename Cursor,
    typename = detail::enable_if_t<detail::is_visitable_view<View>::value>>
SBEPP_CPP14_CONSTEXPR Visitor&&
    visit(View view, Cursor& c, Visitor&& visitor = {})
{
    view(detail::visit_tag{}, visitor, c);
    return std::forward<Visitor>(visitor);
}
 
template<
    typename Visitor,
    typename View,
    typename = detail::enable_if_t<detail::is_visitable_view<View>::value>>
SBEPP_CPP14_CONSTEXPR Visitor&& visit(View view, Visitor&& visitor = {})
{
    auto c = sbepp::init_cursor(view);
    return sbepp::visit(view, c, std::forward<Visitor>(visitor));
}
 
#ifndef SBEPP_DOXYGEN
template<typename Visitor, typename Set>
SBEPP_CPP14_CONSTEXPR detail::enable_if_t<is_set<Set>::value, Visitor&&>
    visit(Set s, Visitor&& visitor = {})
{
    s(detail::visit_tag{}, visitor);
    return std::forward<Visitor>(visitor);
}
 
template<typename Visitor, typename Enum>
SBEPP_CPP14_CONSTEXPR detail::enable_if_t<is_enum<Enum>::value, Visitor&&>
    visit(Enum e, Visitor&& visitor = {})
{
    tag_invoke(detail::visit_tag{}, e, visitor);
    return std::forward<Visitor>(visitor);
}
 
#else
 
template<typename Visitor, typename Set>
SBEPP_CPP14_CONSTEXPR Visitor&& visit(Set s, Visitor&& visitor = {});
 
template<typename Visitor, typename Enum>
SBEPP_CPP14_CONSTEXPR Visitor&& visit(Enum e, Visitor&& visitor = {});
#endif
 
template<
    typename Visitor,
    typename View,
    typename Cursor,
    typename = detail::enable_if_t<detail::is_visitable_view<View>::value>>
SBEPP_CPP14_CONSTEXPR Visitor&&
    visit_children(View view, Cursor& c, Visitor&& visitor = {})
{
    view(detail::visit_children_tag{}, visitor, c);
    return std::forward<Visitor>(visitor);
}
 
template<
    typename Visitor,
    typename View,
    typename = detail::enable_if_t<detail::is_visitable_view<View>::value>>
SBEPP_CPP14_CONSTEXPR Visitor&&
    visit_children(View view, Visitor&& visitor = {})
{
    auto c = sbepp::init_cursor(view);
    return sbepp::visit_children(view, c, std::forward<Visitor>(visitor));
}
 
namespace detail
{
class enum_to_string_visitor
{
public:
    template<typename Enum, typename Tag>
    SBEPP_CPP14_CONSTEXPR void on_enum_value(Enum /*e*/, Tag) noexcept
    {
        name_value = sbepp::enum_value_traits<Tag>::name();
    }
 
    template<typename Enum>
    SBEPP_CPP14_CONSTEXPR void
        on_enum_value(Enum /*e*/, sbepp::unknown_enum_value_tag) noexcept
    {
        name_value = nullptr;
    }
 
    constexpr const char* name() const noexcept
    {
        return name_value;
    }
 
private:
    const char* name_value;
};
} // namespace detail
 
template<typename E, typename = detail::enable_if_t<is_enum<E>::value>>
SBEPP_DEPRECATED constexpr const char* enum_to_string(const E e) noexcept
{
    return visit<detail::enum_to_string_visitor>(e).name();
}
 
template<typename Set, typename Visitor>
SBEPP_DEPRECATED constexpr auto
    visit_set(const Set s, Visitor&& visitor) noexcept
    -> decltype(s(detail::visit_set_tag{}, std::forward<Visitor>(visitor)))
{
    return s(detail::visit_set_tag{}, std::forward<Visitor>(visitor));
}
 
namespace detail
{
class size_bytes_checked_visitor
{
public:
    constexpr explicit size_bytes_checked_visitor(
        const std::size_t size) noexcept
        : size{size}
    {
    }
 
    template<typename T, typename Cursor, typename Tag>
    SBEPP_CPP14_CONSTEXPR void on_message(T m, Cursor& c, Tag) noexcept
    {
        const auto header = sbepp::get_header(m);
        const auto header_size = sbepp::size_bytes(header);
        if(!validate_and_subtract(header_size))
        {
            return;
        }
 
        if(!validate_and_subtract(*header.blockLength()))
        {
            return;
        }
 
        sbepp::visit_children(m, c, *this);
    }
 
    template<typename T, typename Cursor, typename Tag>
    SBEPP_CPP14_CONSTEXPR bool on_group(T g, Cursor& c, Tag) noexcept
    {
        const auto header = sbepp::get_header(g);
        const auto header_size = sbepp::size_bytes(header);
        if(!validate_and_subtract(header_size))
        {
            return true;
        }
 
        const auto prev_block_length =
            set_group_block_length(*header.blockLength());
        sbepp::visit_children(g, c, *this);
        set_group_block_length(prev_block_length);
 
        return !is_valid();
    }
 
    template<typename T, typename Cursor>
    SBEPP_CPP14_CONSTEXPR bool on_entry(T e, Cursor& c) noexcept
    {
        if(!validate_and_subtract(group_block_length))
        {
            return true;
        }
 
        return !sbepp::visit_children(e, c, *this).is_valid();
    }
 
    template<typename T, typename Tag>
    SBEPP_CPP14_CONSTEXPR bool on_data(T d, Tag) noexcept
    {
        return !validate_and_subtract(sbepp::size_bytes(d));
    }
 
    // ignore them all because we validate `blockLength`
    template<typename T, typename Tag>
    constexpr bool on_field(T, Tag) const noexcept
    {
        return {};
    }
 
    constexpr bool is_valid() const noexcept
    {
        return valid;
    }
 
    // returns previous value
    SBEPP_CPP14_CONSTEXPR std::size_t
        set_group_block_length(const std::size_t block_length) noexcept
    {
        auto prev = group_block_length;
        group_block_length = block_length;
        return prev;
    }
 
    constexpr std::size_t get_size() const noexcept
    {
        return size;
    }
 
private:
    std::size_t size;
    bool valid{true};
    // current group's blockLength, used to validate entry
    std::size_t group_block_length{};
 
    SBEPP_CPP14_CONSTEXPR bool
        validate_and_subtract(const std::size_t n) noexcept
    {
        if(size < n)
        {
            valid = false;
        }
        else
        {
            size -= n;
        }
 
        return valid;
    }
};
} // namespace detail
 
struct size_bytes_checked_result
{
    bool valid;
    std::size_t size;
};
 
// can be used with message/group
template<typename View>
SBEPP_CPP20_CONSTEXPR size_bytes_checked_result
    size_bytes_checked(View view, std::size_t size) noexcept
{
    // `init_cursor` skips header, we need to ensure there's enough space for it
    if(!sbepp::addressof(view) || (size < detail::get_header_size(view)))
    {
        return {};
    }
 
    detail::size_bytes_checked_visitor visitor{size};
    auto c = sbepp::init_cursor(view);
    sbepp::visit(view, c, visitor);
    if(visitor.is_valid())
    {
        return {true, size - visitor.get_size()};
    }
    return {};
}
} // namespace sbepp
 
#if SBEPP_HAS_RANGES && SBEPP_HAS_CONCEPTS
 
template<typename Byte, typename Value, std::size_t N, typename Tag>
inline constexpr bool std::ranges::enable_borrowed_range<
    sbepp::detail::static_array_ref<Byte, Value, N, Tag>> = true;
 
template<typename Byte, typename Value, typename Length, sbepp::endian E>
inline constexpr bool std::ranges::enable_borrowed_range<
    sbepp::detail::dynamic_array_ref<Byte, Value, Length, E>> = true;
 
template<sbepp::detail::derived_from_tmp<sbepp::detail::flat_group_base> T>
inline constexpr bool std::ranges::enable_borrowed_range<T> = true;
 
template<sbepp::detail::derived_from_tmp<sbepp::detail::nested_group_base> T>
inline constexpr bool std::ranges::enable_borrowed_range<T> = true;
#endif
 
#undef SBEPP_CPP17_INLINE_VAR
#undef SBEPP_DEPRECATED
#undef SBEPP_CPLUSPLUS
 
SBEPP_WARNINGS_ON();