serdes.h

Go to the documentation of this file.

#ifndef _SERDES_H_
#define _SERDES_H_
 
// clang-format off
#include <cstring>
#include "bitcpy.h"
#include "bitliterals.h"
#include "serdes_errors.h"
#include "serdes_formatter.h"
#include "serdes_validator.h"
#include "serdes_format_modifiers.h"
#include "serdes_fwd_declarations.h"
#include "serdes_byte_iterator.h"
 
// define configCPP_SERDES_LIB_EXCLUDE_CPP_CRC to skip including "cppcrc.h"
// NOTE: cppcrc.h relies on C++14 or greater constexpr support
#if !defined(configCPP_SERDES_LIB_EXCLUDE_CPP_CRC) && BITCPY_CONSTEXPR_SUPPORTED
#include "cppcrc.h"
#endif
 
// if inlining is increasing your binary size too much, you can disable them using configCPP_SERDES_LIB_INLINE_PACKET_API_AGGRESSION=0
//
// level 0 disables all unnecessary inline statements (functions that aren't templatized still need inline)
// level 1 leaves inline on very small or important functions (functions that just wrap bitcpy for example)
// level 2 puts inline on pretty much everything
#ifndef configCPP_SERDES_LIB_INLINE_PACKET_API_AGGRESSION
#define configCPP_SERDES_LIB_INLINE_PACKET_API_AGGRESSION 1
#endif
#if configCPP_SERDES_LIB_INLINE_PACKET_API_AGGRESSION < 0 || configCPP_SERDES_LIB_INLINE_PACKET_API_AGGRESSION > 2
#error "configCPP_SERDES_LIB_INLINE_PACKET_API_AGGRESSION must be 0, 1, or 2"
#endif
#if configCPP_SERDES_LIB_INLINE_PACKET_API_AGGRESSION == 0
#define CPP_SERDES_LIB_PACKET_API_INLINE1
#define CPP_SERDES_LIB_PACKET_API_INLINE2
#elif configCPP_SERDES_LIB_INLINE_PACKET_API_AGGRESSION == 1
#define CPP_SERDES_LIB_PACKET_API_INLINE1 inline
#define CPP_SERDES_LIB_PACKET_API_INLINE2
#elif configCPP_SERDES_LIB_INLINE_PACKET_API_AGGRESSION == 2
#define CPP_SERDES_LIB_PACKET_API_INLINE1 inline
#define CPP_SERDES_LIB_PACKET_API_INLINE2 inline
#endif
 
namespace serdes
{
    struct packet
    {
        serdes::sized_pointer<void> buffer;   
        size_t bit_offset;                    
        mode_e mode;                          
        status_e status = status_e::NO_ERROR; 
        const size_t bit_capacity;            
 
        inline void reset() noexcept
        {
            status     = status_e::NO_ERROR;
            bit_offset = 0;
        }
 
        template <typename T_pointer, typename std::enable_if<std::is_pointer<T_pointer>::value, int *>::type = nullptr>
        packet(T_pointer array_init, size_t max_elements = ~size_t(0), size_t b_offset = 0, mode_e m = mode_e::UNSPECIFIED)
            : buffer{array_init, max_elements},
              bit_offset{b_offset},
              mode{m},
              bit_capacity{buffer.bit_capacity()} {}
 
        template <typename T_array, size_t N>
        packet(T_array (&array_init)[N], size_t max_elements = ~size_t(0), size_t b_offset = 0, mode_e m = mode_e::UNSPECIFIED)
            : buffer{array_init, max_elements < N ? max_elements : N},
              bit_offset{b_offset},
              mode{m},
              bit_capacity{buffer.bit_capacity()} {}
 
        template <typename T_sized_pointer, typename std::enable_if<serdes::detail::is_sized_pointer<T_sized_pointer>::value, int *>::type = nullptr>
        packet(T_sized_pointer array_init, size_t b_offset = 0, mode_e m = mode_e::UNSPECIFIED)
            : buffer(array_init),
              bit_offset{b_offset},
              mode{m},
              bit_capacity{buffer.bit_capacity()} {}
 
        template <typename T_array, detail::requires_data_and_size<T_array>* = nullptr>
        packet(T_array &array_init, size_t max_elements = ~size_t(0), size_t b_offset = 0, mode_e m = mode_e::UNSPECIFIED)
            : buffer{array_init.data(), max_elements < array_init.size() ? max_elements : array_init.size()},
              bit_offset{b_offset},
              mode{m},
              bit_capacity{buffer.bit_capacity()} {}
 
        inline void pad(const size_t bits) noexcept
        {
            if (status == status_e::NO_ERROR)
                pad_assuming_no_prior_errors(bits);
        }
 
        inline void align(size_t bits) noexcept
        {
            if (status == status_e::NO_ERROR)
                align_assuming_no_prior_errors(bits);
        }
 
        //
        // LOAD SECTION (load from serial = deserialize)
        //
 
        template <typename T, size_t N>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void load(T (&value)[N], size_t bits = detail::default_bitsize<T>::value)
        {
            array<T, size_t> temp_arr(value, N);
            load(temp_arr, bits);
        }
 
        template <typename T, typename std::enable_if<
            detail::has_data_and_size<typename detail::remove_cvref_cpp11<T>::type>::value &&
            !detail::has_custom_type_override<typename detail::remove_cvref_cpp11<T>::type>::value
            , int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(T &&value, size_t bits = detail::default_bitsize<typename detail::has_data_and_size<typename detail::remove_cvref_cpp11<T>::type>::elem_type>::value)
        {
            if (status != status_e::NO_ERROR)
                return;
            size_t size = value.size();
            if (size == 0u) // no space to load
            {
                if (bits > 0u)
                    status = status_e::ARRAY_SIZE_OVER_MAX;
                return;
            }
            using elem_type = typename detail::has_data_and_size<typename detail::remove_cvref_cpp11<T>::type>::elem_type;
            array<elem_type, size_t> temp_arr(&value.data()[0], size, size);
            load(temp_arr, bits);
        }
 
        template <typename T, typename std::enable_if<
            !detail::is_format_modifier<typename detail::remove_cvref_cpp11<T>::type>::value &&
            detail::supported_by_bitcpy<typename detail::remove_cvref_cpp11<T>::type>::value,
                                       int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void load(T &value, size_t bits = detail::default_bitsize<T>::value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            const size_t bits_touched = bitcpy(value, buffer, bit_offset, bits);
            bit_offset += bits_touched;
            if (bits_touched < bits)
                status = status_e::EXCEEDED_SERIAL_SIZE;
        }
 
        template <typename T, typename std::enable_if<
            detail::has_custom_type_with_bit_support<typename detail::remove_cvref_cpp11<T>::type>::value 
            && (
                // and has an override
                detail::has_custom_type_override<typename detail::remove_cvref_cpp11<T>::type>::value ||
                // or, not already supported by another overload
                (
                    !detail::is_format_modifier<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::supported_by_bitcpy<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !std::is_array<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::has_load_and_store<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::has_data_and_size<typename detail::remove_cvref_cpp11<T>::type>::value
                )
            ), int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(T &&value, size_t bits = custom_type<typename detail::remove_cvref_cpp11<T>::type>::default_bits)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            custom_type<typename detail::remove_cvref_cpp11<T>::type>::format(*this, std::forward<T>(value), bits);
        }
 
        template <typename T, typename std::enable_if<
            detail::has_custom_type_without_bit_support<typename detail::remove_cvref_cpp11<T>::type>::value 
            && (
                // and has an override
                detail::has_custom_type_override<typename detail::remove_cvref_cpp11<T>::type>::value ||
                // or, not already supported by another overload
                (
                    !detail::is_format_modifier<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::supported_by_bitcpy<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !std::is_array<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::has_load_and_store<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::has_data_and_size<typename detail::remove_cvref_cpp11<T>::type>::value
                )
            ), int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(T &&value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            custom_type<typename detail::remove_cvref_cpp11<T>::type>::format(*this, std::forward<T>(value));
        }
 
        template <typename T, typename std::enable_if<detail::has_format_method<T>::value, int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(T &&value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            std::forward<T>(value).format(*this);
        }
 
        template <typename T, typename std::enable_if<detail::has_load_and_store<typename detail::remove_cvref_cpp11<T>::type>::value, int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void load(T &&value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            typename detail::get_inner_wrapped_type<typename detail::remove_cvref_cpp11<T>::type>::type temp_value{};
            load(temp_value);
            if (status != status_e::NO_ERROR)
                value.store(temp_value);
        }
 
        template <typename T, typename std::enable_if<
            std::is_rvalue_reference<T &&>::value
            // don't set this NO_LOAD_TO_RVALUE warning for any complex types whose rvalue
            // could wrap a valid lvalue variable such as "packet >> serdes::array(data);"
            && detail::supported_by_bitcpy<T>::value,
            int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(T &&value, size_t bits = detail::default_bitsize<T>::value)
        {
            (void)value;
            (void)bits;
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            status = status_e::NO_LOAD_TO_RVALUE;
        }
 
        template<typename T, typename std::enable_if<
            detail::is_formatter<typename detail::remove_cvref_cpp11<T>::type>::value,
            int *>::type* = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(T &&value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            if (value.formatter_lambda == nullptr)
            {
                status = status_e::FORMATTER_NOT_SET;
                return;
            }
            value.formatter_lambda(*this);
        }
 
        template <typename T, typename std::enable_if<!detail::is_format_modifier<typename delimited_array<T>::elem_type>::value, int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(delimited_array<T> &value, size_t bits = detail::default_bitsize<typename delimited_array<T>::elem_type>::value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            using elem_type = typename delimited_array<T>::elem_type;
            constexpr size_t bits_per_element = sizeof(elem_type) * 8;
 
            // shortcut for memory aligned situations
            if (bits == bits_per_element && buffer.element_size == sizeof(elem_type) && bit_offset % bits_per_element == 0)
            {
                if (bit_capacity < bits_per_element)
                {
                    status = status_e::EXCEEDED_SERIAL_SIZE;
                    return;
                }
                const size_t max_bit_offset_minus_one_element = bit_capacity - bits_per_element;
                const elem_type *buffer_head = &reinterpret_cast<const elem_type *>(buffer.value)[bit_offset / bits_per_element];
                for (size_t i = 0; i < value.max_size; i++)
                {
                    if (bit_offset > max_bit_offset_minus_one_element)
                    {
                        status = status_e::EXCEEDED_SERIAL_SIZE;
                        return;
                    }
                    const elem_type &source_value = *buffer_head;
                    value.value[i] = source_value;
                    bit_offset += bits;
                    if (source_value == value.delimiter)
                        return;
                    ++buffer_head;
                }
            }
            else
            {
                for (size_t i = 0; i < value.max_size; i++)
                {
                    const size_t bits_touched = bitcpy(value.value[i], buffer, bit_offset, bits);
                    bit_offset += bits_touched;
                    if (bits_touched < bits)
                    {
                        status = status_e::EXCEEDED_SERIAL_SIZE;
                        return;
                    }
                    if (value.value[i] == value.delimiter)
                        return;
                }
            }
            status = status_e::DELIMITER_NOT_FOUND;
        }
 
        template <typename T, typename std::enable_if<detail::has_format_method<typename delimited_array<T>::elem_type>::value, int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(delimited_array<T> &value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            for (size_t i = 0; i < value.max_size; i++)
            {
                value.value[i].format(*this);
                if (value.value[i] == value.delimiter || status != status_e::NO_ERROR)
                    return;
            }
            status = status_e::DELIMITER_NOT_FOUND;
        }
 
        template <typename T>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void load(delimited_array<T> &&value)
        {
            load(value);
        }
 
        template <typename T, typename T2, typename std::enable_if<
            !detail::is_format_modifier<typename serdes::array<T, T2>::elem_type>::value &&
            detail::supported_by_bitcpy<typename serdes::array<T, T2>::elem_type>::value
            , int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(serdes::array<T, T2> &value, size_t bits = detail::default_bitsize<typename serdes::array<T, T2>::elem_type>::value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
 
            // here the "size" reference is finally copied, in case it changed after the reference bind occurred
            size_t array_size = static_cast<size_t>(value.size);
            if (array_size > value.max_size)
            {
                array_size = value.max_size;
                status     = status_e::ARRAY_SIZE_OVER_MAX;
            }
            const size_t total_bits = array_size * sizeof(typename serdes::array<T, T2>::elem_type) * 8;
            // shortcut for memory aligned situations
            if (sizeof(typename serdes::array<T, T2>::elem_type) == 1 && bits == 8 && buffer.element_size == 1 && (bit_offset & 7u) == 0u && bit_capacity - bit_offset >= total_bits)
            {
                std::memcpy(&value.value[0], &reinterpret_cast<uint8_t *>(buffer.value)[bit_offset >> 3], array_size);
                bit_offset += total_bits;
                return;
            }
            for (size_t i = 0; i < array_size; i++)
            {
                const size_t bits_touched = bitcpy(value.value[i], buffer, bit_offset, bits);
                bit_offset += bits_touched;
                if (bits_touched < bits)
                {
                    status = status_e::EXCEEDED_SERIAL_SIZE;
                    return;
                }
            }
        }
 
        template <typename T, typename T2, typename std::enable_if<
            !detail::is_format_modifier<typename serdes::array<T, T2>::elem_type>::value &&
            !detail::supported_by_bitcpy<typename serdes::array<T, T2>::elem_type>::value
            , int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(serdes::array<T, T2> &value, size_t bits = detail::default_bitsize<typename serdes::array<T, T2>::elem_type>::value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
 
            // here the "size" reference is finally copied, in case it changed after the reference bind occurred
            size_t array_size = static_cast<size_t>(value.size);
            if (array_size > value.max_size)
            {
                array_size = value.max_size;
                status     = status_e::ARRAY_SIZE_OVER_MAX;
            }
            for (size_t i = 0; i < array_size && status != status_e::NO_ERROR; i++)
                load(value.value[i], bits);
        }
 
        template <typename T, typename T2, typename std::enable_if<detail::has_format_method<typename serdes::array<T, T2>::elem_type>::value, int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(serdes::array<T, T2> &value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
 
            // here the "size" reference is finally copied, in case it changed after the reference bind occurred
            size_t array_size = static_cast<size_t>(value.size);
            if (array_size > value.max_size)
            {
                status = status_e::ARRAY_SIZE_OVER_MAX;
                return;
            }
            for (size_t i = 0; i < array_size; i++)
            {
                value.value[i].format(*this);
                if (status != status_e::NO_ERROR)
                    return;
            }
        }
 
        template <typename T, typename T2>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void load(serdes::array<T, T2> &&value)
        {
            load(value);
        }
 
        template <typename ST>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(const serdes::pad<ST> padding)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            pad_assuming_no_prior_errors(padding.value);
        }
 
        template <typename ST>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void load(const serdes::align<ST> alignment)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            align_assuming_no_prior_errors(alignment.value);
        }
 
        template <typename T, typename ST>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void load(bitpack<T, ST> &&value)
        {
            load(value.value, value.bits);
        }
 
        template <typename T, typename ST>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void load(bitpack<T, ST> &value)
        {
            load(value.value, value.bits);
        }
 
        inline void load(packet_base &value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_load();
            value.format(*this);
        }
 
        inline void load(packet_base &&value)
        {
            load(value);
        }
 
        //
        // STORE SECTION (store into serial = serialize)
        //
 
        template <typename T, typename std::enable_if<
            !detail::is_format_modifier<typename detail::remove_cvref_cpp11<T>::type>::value &&
            detail::supported_by_bitcpy<typename detail::remove_cvref_cpp11<T>::type>::value,
                                  int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void store(const T &value, size_t bits = detail::default_bitsize<T>::value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
            const size_t bits_touched = bitcpy(buffer, value, bit_offset, bits);
            bit_offset += bits_touched;
            if (bits_touched < bits)
                status = status_e::EXCEEDED_SERIAL_SIZE;
        }
 
        template <typename T, typename std::enable_if<
            detail::has_custom_type_with_bit_support<typename detail::remove_cvref_cpp11<T>::type>::value 
            &&
            (
                // and has an override
                detail::has_custom_type_override<typename detail::remove_cvref_cpp11<T>::type>::value ||
                // or, not already supported by another overload
                (
                    !detail::is_format_modifier<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::supported_by_bitcpy<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !std::is_array<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::has_load_and_store<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::has_data_and_size<typename detail::remove_cvref_cpp11<T>::type>::value
                )
            ), int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void store(T &&value, size_t bits = custom_type<typename detail::remove_cvref_cpp11<T>::type>::default_bits)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
            custom_type<typename detail::remove_cvref_cpp11<T>::type>::format(*this, std::forward<T>(value), bits);
        }
 
        template <typename T, typename std::enable_if<
            detail::has_custom_type_without_bit_support<typename detail::remove_cvref_cpp11<T>::type>::value 
            &&
            (
                // and has an override
                detail::has_custom_type_override<typename detail::remove_cvref_cpp11<T>::type>::value ||
                // or, not already supported by another overload
                (
                    !detail::is_format_modifier<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::supported_by_bitcpy<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !std::is_array<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::has_load_and_store<typename detail::remove_cvref_cpp11<T>::type>::value &&
                    !detail::has_data_and_size<typename detail::remove_cvref_cpp11<T>::type>::value
                )
            ), int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void store(T &&value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
            custom_type<typename detail::remove_cvref_cpp11<T>::type>::format(*this, std::forward<T>(value));
        }
 
        template <typename T, typename std::enable_if<detail::has_format_method<T>::value, int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void store(T &&value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
            std::forward<T>(value).format(*this);
        }
 
        template <typename T, typename std::enable_if<detail::has_load_and_store<
            typename detail::remove_cvref_cpp11<T>::type>::value, int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void store(T &&value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
            store(value.load());
        }
 
        template <typename T, size_t N>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void store(const T (&value)[N], size_t bits = detail::default_bitsize<T>::value)
        {
            store(array<const T, size_t>(value, N), bits);
        }
 
        template <typename T, typename std::enable_if<
            detail::has_data_and_size<typename detail::remove_cvref_cpp11<T>::type>::value &&
            !detail::has_custom_type_override<typename detail::remove_cvref_cpp11<T>::type>::value
            , int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void store(T &&value, size_t bits = detail::default_bitsize<typename detail::has_data_and_size<typename detail::remove_cvref_cpp11<T>::type>::elem_type>::value)
        {
            size_t size = value.size();
            if (size == 0u)
                return; // nothing to store
            using elem_type = typename detail::has_data_and_size<typename detail::remove_cvref_cpp11<T>::type>::elem_type;
            array<elem_type, size_t> temp_arr(&value.data()[0], size, size);
            store(temp_arr, bits);
        }
 
        template <typename T, size_t N>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void store(const T (&&value)[N], size_t bits = detail::default_bitsize<T>::value)
        {
            store(array<const T, size_t>(value, N), bits);
        }
 
        template <typename T, typename std::enable_if<!detail::is_format_modifier<typename delimited_array<T>::elem_type>::value, int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void store(const delimited_array<T> &value, size_t bits = detail::default_bitsize<typename delimited_array<T>::elem_type>::value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
            using elem_type = typename detail::remove_cvref_cpp11<typename delimited_array<T>::elem_type>::type;
            constexpr size_t bits_per_element = sizeof(elem_type) * 8;
            // shortcut for memory aligned situations
            if (bits == bits_per_element && buffer.element_size == sizeof(elem_type) && bit_offset % bits_per_element == 0)
            {
                if (bit_capacity < bits_per_element)
                {
                    status = status_e::EXCEEDED_SERIAL_SIZE;
                    return;
                }
                const size_t max_bit_offset_minus_one_element = bit_capacity - bits_per_element;
                elem_type *buffer_head = &reinterpret_cast<elem_type *>(buffer.value)[bit_offset / bits_per_element];
                for (size_t i = 0; i < value.max_size; i++)
                {
                    if (bit_offset > max_bit_offset_minus_one_element)
                    {
                        status = status_e::EXCEEDED_SERIAL_SIZE;
                        return;
                    }
                    const elem_type &source_value = value.value[i];
                    *buffer_head = source_value;
                    bit_offset += bits;
                    if (source_value == value.delimiter)
                        return;
                    ++buffer_head;
                }
            }
            else
            {
                for (size_t i = 0; i < value.max_size; i++)
                {
                    const size_t bits_touched = bitcpy(buffer, value.value[i], bit_offset, bits);
                    bit_offset += bits_touched;
                    if (bits_touched < bits)
                    {
                        status = status_e::EXCEEDED_SERIAL_SIZE;
                        return;
                    }
                    if (value.value[i] == value.delimiter)
                        return;
                }
            }
            status = status_e::DELIMITER_NOT_FOUND;
        }
 
        template <typename T, typename std::enable_if<detail::has_format_method<typename delimited_array<T>::elem_type>::value, int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void store(const delimited_array<T> &value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
            for (size_t i = 0; i < value.max_size; i++)
            {
                value.value[i].format(*this);
                if (value.value[i] == value.delimiter || status != status_e::NO_ERROR)
                    return;
            }
            status = status_e::DELIMITER_NOT_FOUND;
        }
 
        template <typename T>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void store(const delimited_array<T> &&value)
        {
            store(value);
        }
 
        template <typename T, typename T2, typename std::enable_if<
            !detail::is_format_modifier<typename serdes::array<T, T2>::elem_type>::value &&
            detail::supported_by_bitcpy<typename serdes::array<T, T2>::elem_type>::value
            , int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void store(const serdes::array<T, T2> &value, size_t bits = detail::default_bitsize<typename serdes::array<T, T2>::elem_type>::value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
 
            // here the "size" reference is finally copied, in case it changed after the reference bind occurred
            size_t array_size = static_cast<size_t>(value.size);
            if (array_size > value.max_size)
            {
                array_size = value.max_size;
                status     = status_e::ARRAY_SIZE_OVER_MAX;
            }
            const size_t total_bits = array_size * sizeof(typename serdes::array<T, T2>::elem_type) * 8;
            // shortcut for memory aligned situations
            if (sizeof(typename serdes::array<T, T2>::elem_type) == 1 && bits == 8 && buffer.element_size == 1 && (bit_offset & 7u) == 0u && bit_capacity - bit_offset >= total_bits)
            {
                std::memcpy(&reinterpret_cast<uint8_t *>(buffer.value)[bit_offset >> 3], &value.value[0], array_size);
                bit_offset += total_bits;
                return;
            }
            for (size_t i = 0; i < array_size; i++)
            {
                const size_t bits_touched = bitcpy(buffer, value.value[i], bit_offset, bits);
                bit_offset += bits_touched;
                if (bits_touched < bits)
                {
                    status = status_e::EXCEEDED_SERIAL_SIZE;
                    return;
                }
            }
        }
 
        template <typename T, typename T2, typename std::enable_if<
            !detail::is_format_modifier<typename serdes::array<T, T2>::elem_type>::value &&
            !detail::supported_by_bitcpy<typename serdes::array<T, T2>::elem_type>::value
            , int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void store(const serdes::array<T, T2> &value, size_t bits = detail::default_bitsize<typename serdes::array<T, T2>::elem_type>::value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
 
            // here the "size" reference is finally copied, in case it changed after the reference bind occurred
            size_t array_size = static_cast<size_t>(value.size);
            if (array_size > value.max_size)
            {
                array_size = value.max_size;
                status     = status_e::ARRAY_SIZE_OVER_MAX;
            }
            for (size_t i = 0; i < array_size && status != status_e::NO_ERROR; i++)
                store(value.value[i], bits);
        }
 
        template <typename T, typename T2, typename std::enable_if<detail::has_format_method<typename serdes::array<T, T2>::elem_type>::value, int *>::type = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void store(const serdes::array<T, T2> &value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
 
            // here the "size" reference is finally copied, in case it changed after the reference bind occurred
            size_t array_size = static_cast<size_t>(value.size);
            if (array_size > value.max_size)
            {
                status = status_e::ARRAY_SIZE_OVER_MAX;
                return;
            }
            for (size_t i = 0; i < array_size; i++)
            {
                value.value[i].format(*this);
                if (status != status_e::NO_ERROR)
                    return;
            }
        }
 
        template <typename T, typename T2>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void store(const array<T, T2> &&value)
        {
            store(value);
        }
 
        template<typename T, typename std::enable_if<
            detail::is_formatter<typename detail::remove_cvref_cpp11<T>::type>::value,
            int *>::type* = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE2 void store(T &&value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
            if (value.formatter_lambda == nullptr)
            {
                status = status_e::FORMATTER_NOT_SET;
                return;
            }
            value.formatter_lambda(*this);
        }
 
        template <typename ST>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void store(const serdes::pad<ST> padding)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
            pad_assuming_no_prior_errors(padding.value);
        }
 
        template <typename ST>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void store(const serdes::align<ST> alignment)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
            align(alignment.value);
        }
 
        template <typename T, typename ST>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void store(const bitpack<T, ST> &&value)
        {
            store(value.value, value.bits);
        }
 
        template <typename T, typename ST>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void store(const bitpack<T, ST> &value)
        {
            store(value.value, value.bits);
        }
 
        inline void store(const packet_base &value)
        {
            if (status != status_e::NO_ERROR)
                return;
            ensure_store();
            const_cast<packet_base &>(value).format(*this);
        }
 
        inline void store(const packet_base &&value)
        {
            store(value);
        }
 
        //
        // stream operator SECTION (<< is store, >> is load)
        //
 
        template <typename T>
        CPP_SERDES_LIB_PACKET_API_INLINE1 packet &operator>>(T &&x)
        {
            load(std::forward<T>(x));
            return *this;
        }
 
        template <typename T>
        CPP_SERDES_LIB_PACKET_API_INLINE1 packet &operator<<(T &&x)
        {
            store(std::forward<T>(x));
            return *this;
        }
 
        //
        // add() SECTION (same as "+", either store or load)
        //
 
        template <typename T>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void add(T &&x, size_t bits)
        {
            if (mode == mode_e::LOADING)
                load(std::forward<T>(x), bits);
            else if (mode == mode_e::STORING)
                store(std::forward<T>(x), bits);
        }
 
        template <typename T, size_t N>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void add(T (&x)[N], size_t bits)
        {
            if (mode == mode_e::LOADING)
                for (size_t i = 0; i < N; i++)
                    load(x[i], bits);
            else if (mode == mode_e::STORING)
                for (size_t i = 0; i < N; i++)
                    store(x[i], bits);
        }
 
        template <typename T, typename std::enable_if<
            !detail::is_validator<typename detail::remove_cvref_cpp11<T>::type>::value,
            int *>::type* = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void add(T &&x)
        {
            if (mode == mode_e::LOADING)
                load(std::forward<T>(x));
            else if (mode == mode_e::STORING)
                store(std::forward<T>(x));
        }
 
        template <typename T, size_t N>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void add(T (&x)[N])
        {
            if (mode == mode_e::LOADING)
                for (size_t i = 0; i < N; i++)
                    load(x[i]);
            else if (mode == mode_e::STORING)
                for (size_t i = 0; i < N; i++)
                    store(x[i]);
        }
 
        template <typename T, typename F>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void add(T &&value, F &&validation)
        {
            if (status != status_e::NO_ERROR)
                return;
            if (mode == mode_e::LOADING)
                load(std::forward<T>(value));
            if (!std::forward<F>(validation)())
                status = status_e::INVALID_FIELD;
            else if (mode == mode_e::STORING)
                store(std::forward<T>(value));
        }
 
        template <typename T, typename std::enable_if<
            detail::is_validator<typename detail::remove_cvref_cpp11<T>::type>::value,
            int *>::type* = nullptr>
        CPP_SERDES_LIB_PACKET_API_INLINE1 void add(T &&value)
        {
            add(value.field, value.validation);
        }
 
        //
        // "+" steam operator SECTION (same as add(), either store or load)
        //
 
#if (defined(__GNUC__) && !defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
        template <typename T>
        CPP_SERDES_LIB_PACKET_API_INLINE1 packet &operator+(T &&value)
        {
            add(std::forward<T>(value));
            return *this;
        }
#if (defined(__GNUC__) && !defined(__clang__))
#pragma GCC diagnostic pop
#endif
 
        inline byte_iterator_type byte_iterator(starting_byte_index start, number_of_bytes size)
        {
            if (status != status_e::NO_ERROR)
                return {buffer, 0u, 0u};
            const size_t max_num_bytes           = buffer.size * buffer.element_size;
            const size_t end_byte_index_plus_one = start.value + size.value;
            if (end_byte_index_plus_one >= max_num_bytes)
            {
                status = status_e::NUM_BYTES_OVER_MAX;
                return {buffer, 0u, 0u};
            }
            return {buffer, start.value, end_byte_index_plus_one};
        }
 
        inline byte_iterator_type previous_bytes(starting_byte_index start)
        {
            if (status != status_e::NO_ERROR)
                return {buffer, 0u, 0u};
            const size_t max_num_bytes = bit_offset / 8u;
            if (start.value >= max_num_bytes)
            {
                status = status_e::START_BYTE_PAST_CURRENT;
                return {buffer, 0u, 0u};
            }
            return byte_iterator(start, number_of_bytes{max_num_bytes - start.value});
        }
 
        inline byte_iterator_type previous_bytes()
        {
            if (status != status_e::NO_ERROR)
                return byte_iterator(starting_byte_index{0u}, number_of_bytes{0u});
            return byte_iterator(starting_byte_index{0u}, number_of_bytes{bit_offset / 8u});
        }
 
#if !defined(configCPP_SERDES_LIB_EXCLUDE_CPP_CRC) && BITCPY_CONSTEXPR_SUPPORTED
        template <typename cpp_crc_type>
        CPP_SERDES_LIB_PACKET_API_INLINE2 typename cpp_crc_type::type calculate_crc(typename cpp_crc_type::type *crc_field = nullptr)
        {
            auto crc_calculated = cpp_crc_type::null_crc;
            for (auto &segment : previous_bytes())
                crc_calculated = cpp_crc_type::calc(segment.bytes, segment.num_bytes, crc_calculated);
            if (crc_field != nullptr && mode == serdes::mode_e::STORING)
                *crc_field = crc_calculated;
            return crc_calculated;
        }
#endif
 
    private:
        inline void pad_assuming_no_prior_errors(const size_t bits) noexcept
        {
            const size_t next_bit_offset = bit_offset + bits;
            if (next_bit_offset > bit_capacity)
            {
                status = status_e::EXCEEDED_SERIAL_SIZE;
                return;
            }
            bit_offset = next_bit_offset;
        }
 
        inline void align_assuming_no_prior_errors(size_t bits) noexcept
        {
            const size_t alignment = bit_offset % bits;
            if (alignment > 0)
            {
                const size_t next_bit_offset = bit_offset + bits - alignment;
                if (next_bit_offset > bit_capacity)
                {
                    status = status_e::EXCEEDED_SERIAL_SIZE;
                    return;
                }
                bit_offset = next_bit_offset;
            }
        }
 
        inline void ensure_load() noexcept
        {
            if (mode != mode_e::LOADING)
            {
                if (mode == mode_e::STORING)
                    reset();
                mode = mode_e::LOADING;
            }
        }
 
        inline void ensure_store() noexcept
        {
            if (mode != mode_e::STORING)
            {
                if (mode == mode_e::LOADING)
                    reset();
                mode = mode_e::STORING;
            }
        }
    };
 
    template <typename T_array, size_t N>
    status_t packet_base::store(T_array (&target_buffer)[N], size_t max_elements, size_t bit_offset)
    {
        if (N < max_elements)
            max_elements = N;
        packet pkt_obj(serdes::sized_pointer<T_array>(&target_buffer[0], max_elements), bit_offset, mode_e::STORING);
        format(pkt_obj);
        return {pkt_obj.status, pkt_obj.bit_offset};
    }
 
    template <typename T_pointer, typename std::enable_if<std::is_pointer<T_pointer>::value, int *>::type>
    status_t packet_base::store(T_pointer target_buffer, size_t max_elements, size_t bit_offset)
    {
        packet pkt_obj(serdes::sized_pointer<typename std::remove_pointer<T_pointer>::type>(target_buffer, max_elements), bit_offset, mode_e::STORING);
        format(pkt_obj);
        return {pkt_obj.status, pkt_obj.bit_offset};
    }
 
    template <typename T_sized_pointer, typename std::enable_if<serdes::detail::is_sized_pointer<T_sized_pointer>::value, int *>::type>
    status_t packet_base::store(T_sized_pointer target_buffer, size_t bit_offset)
    {
        packet pkt_obj(target_buffer, bit_offset, mode_e::STORING);
        format(pkt_obj);
        return {pkt_obj.status, pkt_obj.bit_offset};
    }
    template <typename T_array, size_t N>
    status_t packet_base::load(const T_array (&source_buffer)[N], size_t max_elements, size_t bit_offset)
    {
        if (N < max_elements)
            max_elements = N;
        packet pkt_obj(serdes::sized_pointer<const T_array>(&source_buffer[0], N), bit_offset, mode_e::LOADING);
        format(pkt_obj);
        return {pkt_obj.status, pkt_obj.bit_offset};
    }
    template <typename T_pointer, typename std::enable_if<std::is_pointer<T_pointer>::value, int *>::type>
    status_t packet_base::load(const T_pointer source_buffer, size_t max_elements, size_t bit_offset)
    {
        packet pkt_obj(serdes::sized_pointer<const typename std::remove_pointer<T_pointer>::type>(source_buffer, max_elements), bit_offset, mode_e::LOADING);
        format(pkt_obj);
        return {pkt_obj.status, pkt_obj.bit_offset};
    }
    template <typename T_sized_pointer, typename std::enable_if<serdes::detail::is_sized_pointer<T_sized_pointer>::value, int *>::type>
    status_t packet_base::load(const T_sized_pointer target_buffer, size_t bit_offset)
    {
        packet pkt_obj(target_buffer, bit_offset, mode_e::LOADING);
        format(pkt_obj);
        return {pkt_obj.status, pkt_obj.bit_offset};
    }
    template <typename T>
    CPP_SERDES_LIB_PACKET_API_INLINE1 status_t packet_base::operator>>(T &&value)
    {
        return store(std::forward<T>(value));
    }
    template <typename T>
    CPP_SERDES_LIB_PACKET_API_INLINE1 status_t packet_base::operator<<(T &&value)
    {
        return load(std::forward<T>(value));
    }
 
    CONSTEXPR_ABOVE_CPP11_OR_INLINE size_t remaining_bits(const packet &_pkt)
    {
        const size_t total_buff_bits = _pkt.buffer.size * _pkt.buffer.element_size * 8u;
        if (total_buff_bits > _pkt.bit_offset)
            return total_buff_bits - _pkt.bit_offset;
        return 0u;
    }
 
    CONSTEXPR_ABOVE_CPP11_OR_INLINE size_t remaining_bytes(const packet &_pkt)
    {
        return remaining_bits(_pkt) / 8u;
    }
} // namespace serdes
 
// clang-format on
#endif // _SERDES_H_