meta-serializer-livecoding/Serializable.hpp at master · LabKoala/meta-serializer-livecoding · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#pragma once

#include <tuple>
#include <memory>

template<typename Derived>
struct BaseImpl
{
    virtual void serialize(std::ostream &s, const Derived &) = 0;
};

struct Output
{
    template<typename Obj>
    static void serializeMember(std::ostream &s, const Obj &member)
    {
        s << member << std::endl;
    }
};

template<typename OutputPolicy, typename Derived, typename Tuple, size_t ...I>
void printAttrs(std::ostream &s, std::index_sequence<I...>, const Tuple &tuple, const Derived &obj);

template<typename OutputPolicy, typename Derived, typename Tuple>
void printAttrs(std::ostream &, std::index_sequence<>, const Tuple &, const Derived &)
{}

template<typename OutputPolicy, typename Derived, typename Tuple, size_t I, size_t ...Rest>
void printAttrs(std::ostream &s, std::index_sequence<I, Rest...>, const Tuple &tuple, const Derived &obj)
{
    auto memberPointer = std::get<I>(tuple);

    OutputPolicy::serializeMember(s, obj.*memberPointer);

    printAttrs<OutputPolicy>(s, std::index_sequence<Rest...>(), tuple, obj);
}

template<typename Derived, typename OutputPolicy = Output>
class Serializable
{
    template<typename ...A>
    struct Impl : BaseImpl<Derived>
    {
        Impl(A...attrs)
                :
                _tuple(attrs...) {}

        void serialize(std::ostream &s, const Derived &obj) final
        {
            printAttrs<OutputPolicy>(s, std::index_sequence_for<A...>(), _tuple, obj);
        }

        std::tuple<A...> _tuple;
    };

public:
    template<typename ...MemberPointers>
    Serializable(const MemberPointers &...attrs)
            : _impl(
            new Impl<MemberPointers...>(
                    attrs...))
    {
    }

    friend std::ostream &operator<<(std::ostream &s, const Serializable &obj)
    {
        obj._impl->serialize(s, static_cast<const Derived &>(obj));
        return s;
    }

private:
    std::shared_ptr<BaseImpl<Derived>> _impl;
};