Variadic Serialization

test.cpp

#include <cassert>
#include <cstring>
#include <ctime>
#include <iostream>
#include <type_traits>
#include <tuple>


using namespace std;

////////////////////////////////////////////////////////////////////////////////
namespace pack {
template <typename _Tp, typename... _Vargs>
struct Struct {
    static constexpr size_t size = sizeof(_Tp) + Struct<_Vargs...>::size;
};

template <typename _Tp, typename _Tq>
struct Struct<_Tp, _Tq> {
    static constexpr size_t size = sizeof(_Tp) + sizeof(_Tq);
};

//----------------------------------------------------------------------------//

template <size_t _Count, size_t _Size>
struct PackedStruct {
    static constexpr size_t Count = _Count;
    static constexpr size_t Size  = _Size;

    std::array<std::uint8_t, _Count> serial;
    std::array<std::uint8_t, _Size > data;
};

template <typename _Struct>
void
copyToArray(size_t, _Struct&) {}

template <typename _Struct, typename _Tp, typename... _Args>
void
copyToArray(size_t offset, _Struct& ara, _Tp data, _Args... args) {
    std::copy(&data, &data+ sizeof(_Tp), &ara.data[offset]);
    ara.serial[_Struct::Count - sizeof...(args) - 1] = sizeof(data);
    copyToArray(offset + sizeof(_Tp), ara, args...);
}

template <typename... _Args>
auto
toPackedArray(_Args... args) 
    -> PackedStruct<sizeof...(_Args), Struct<_Args...>::size> 
{
    PackedStruct<sizeof...(_Args), Struct<_Args...>::size> data;
    copyToArray(0, data, args...);
    return data;
}
} // ns pack
////////////////////////////////////////////////////////////////////////////////

int
main() {
    using namespace pack;
    //cerr << Struct<float,long>::size << endl;
    
    char  j = 'a';
    float k = 0.0;
    char  l = 'b';
    char  m = 'c';

    auto data = toPackedArray(j, k, l, m);
    
    cerr << (data.data.size())
         << (char)data.data[0]
         << (char)data.data[5] 
         << (char)data.data[6] 
         << endl;

    for (size_t i = 0; i < data.serial.size(); ++i) 
        cerr << ": " << (int)data.serial[i] << endl;
}