serdes_format_modifiers.h

Go to the documentation of this file.

#ifndef _SERDES_FORMAT_MODIFIERS_H_
#define _SERDES_FORMAT_MODIFIERS_H_
 
#include "bitcpy_common.h"
 
namespace serdes
{
    template <typename ST>
    struct align
    {
        const ST &value;
 
        constexpr align(const ST &bits) noexcept : value{bits} {}
 
        constexpr align(ST &&bits) noexcept : value{bits} {}
    };
 
    template <typename ST>
    struct pad
    {
        const ST &value;
 
        constexpr pad(const ST &bits) noexcept : value{bits} {}
 
        constexpr pad(ST &&bits) noexcept : value{bits} {}
    };
 
    template <typename T, typename ST>
    struct bitpack
    {
        T &value;
 
        const ST &bits;
 
        constexpr bitpack(T &&v, const ST &&b) noexcept : value{v}, bits{std::move(b)} {}
 
        constexpr bitpack(T &v, const ST &&b) noexcept : value{v}, bits{std::move(b)} {}
 
        constexpr bitpack(T &v, const ST &b) noexcept : value{v}, bits{b} {}
 
        constexpr bitpack(T &&v, const ST &b) noexcept : value{v}, bits{b} {}
    };
 
    template <typename T, typename ST>
    struct array
    {
        using elem_type = typename detail::has_data_and_size<T>::elem_type;
 
        elem_type *value;
 
        const ST rvalue_size;
 
        const ST &size;
 
        const size_t max_size;
 
        template <size_t max_elements>
        constexpr array(T (&v)[max_elements], const ST &s) noexcept : value{&v[0]}, rvalue_size{}, size{s}, max_size{max_elements} {}
 
        template <size_t max_elements>
        constexpr array(T (&v)[max_elements], const ST &&s) noexcept : value{&v[0]}, rvalue_size{s}, size{rvalue_size}, max_size(max_elements) {}
 
        constexpr array(T *v, ST &s, const ST max_elements) noexcept : value{&v[0]}, rvalue_size{}, size{s}, max_size{max_elements} {}
 
        constexpr array(T *v, const ST &&s, const ST max_elements) noexcept : value{&v[0]}, rvalue_size{s}, size{rvalue_size}, max_size{max_elements} {}
 
        array(T &v, const ST &s) noexcept : value{v.data()}, rvalue_size{}, size{s}, max_size(v.size()) {}
 
        array(T &v, const ST &&s) noexcept : value{v.data()}, rvalue_size{s}, size{rvalue_size}, max_size(v.size()) {}
 
        array(T &v) noexcept : value{v.data()}, rvalue_size{max_size}, size{rvalue_size}, max_size(v.size()) {}
    };
 
    template <typename T>
    struct delimited_array
    {
        using elem_type = typename detail::has_data_and_size<T>::elem_type;
 
        elem_type *value;
 
        const elem_type &delimiter;
 
        const size_t max_size;
 
        template <size_t max_elements>
        constexpr delimited_array(T (&v)[max_elements], const T &d) noexcept : value{&v[0]}, delimiter{d}, max_size{max_elements} {}
 
        template <size_t max_elements>
        constexpr delimited_array(T (&v)[max_elements], const T &&d) noexcept : value{&v[0]}, delimiter{std::move(d)}, max_size{max_elements} {}
 
        constexpr delimited_array(T *v, const T &d, size_t max_elements) noexcept : value{&v[0]}, delimiter{d}, max_size{max_elements} {}
 
        constexpr delimited_array(T *v, const T &&d, size_t max_elements) noexcept : value{&v[0]}, delimiter{std::move(d)}, max_size{max_elements} {}
 
        delimited_array(T &v, const elem_type &d) noexcept : value{v.data()}, delimiter{d}, max_size(v.size()) {}
 
        delimited_array(T &v, const elem_type &&d) noexcept : value{v.data()}, delimiter{std::move(d)}, max_size(v.size()) {}
    };
 
    struct packet_base;
    struct formatter;
    template <typename FieldType, typename FuncType>
    struct validator;
    namespace detail
    {
        template <typename T, typename ST>
        struct default_bitsize<bitpack<T, ST>>
        {
            static constexpr size_t value = 0u;
        };
        template <typename T, typename T2>
        struct default_bitsize<array<T, T2>>
        {
            static constexpr size_t value = sizeof(T) * 8u;
        };
        template <typename T>
        struct default_bitsize<delimited_array<T>>
        {
            static constexpr size_t value = sizeof(T) * 8u;
        };
        template <typename ST>
        struct default_bitsize<align<ST>>
        {
            static constexpr size_t value = 0u;
        };
        template <typename ST>
        struct default_bitsize<pad<ST>>
        {
            static constexpr size_t value = 0u;
        };
        template <typename T>
        struct is_formatter : std::false_type
        {
        };
        template <>
        struct is_formatter<formatter> : std::true_type
        {
        };
        template <typename T>
        struct is_validator : std::false_type
        {
        };
        template <typename FieldType, typename FuncType>
        struct is_validator<validator<FieldType, FuncType>> : std::true_type
        {
        };
        template <typename T>
        struct is_format_modifier
        {
            static constexpr bool value = has_format_method<T>::value;
        };
        template <>
        struct is_format_modifier<formatter> : std::true_type
        {
        };
        template <typename ST>
        struct is_format_modifier<pad<ST>> : std::true_type
        {
        };
        template <typename ST>
        struct is_format_modifier<align<ST>> : std::true_type
        {
        };
        template <typename T, typename ST>
        struct is_format_modifier<bitpack<T, ST>> : std::true_type
        {
        };
        template <typename T1, typename T2>
        struct is_format_modifier<array<T1, T2>> : std::true_type
        {
        };
        template <typename T>
        struct is_format_modifier<delimited_array<T>> : std::true_type
        {
        };
    }
}
 
#endif // _SERDES_FORMAT_MODIFIERS_H_