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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
#include <vector>
template <typename ...Types>
struct TypeList
{
TypeList(TypeList const &) = delete;
enum { size = sizeof ...(Types) };
};
//VECTOR
template <class Type>
struct Vector: public std::vector<Type>
{
Vector(std::initializer_list<Type> iniValues)
:
std::vector<Type>(iniValues)
{}
};
//=
//UWRAP
template <size_t nr, typename Type>
struct UWrap: public Type
{
UWrap(Type const &type)
:
Type(type)
{}
};
//=
//MULTIBASE
template <size_t nr, typename ...PolicyTypes>
struct MultiBase;
//=
//MULTIBASEREC
template <size_t nr, typename PolicyT1, typename ...PolicyTypes>
struct MultiBase<nr, PolicyT1, PolicyTypes...> :
public UWrap<nr, PolicyT1>,
public MultiBase<nr + 1, PolicyTypes...>
{
using Type = PolicyT1;
using Base = MultiBase<nr + 1, PolicyTypes...>;
MultiBase(PolicyT1 && policyt1, PolicyTypes &&...policytypes)
:
UWrap<nr, PolicyT1>(std::forward<PolicyT1>(policyt1)),
MultiBase<nr + 1, PolicyTypes...>(
std::forward<PolicyTypes>(policytypes)...)
{}
};
//=
//MULTIBASEDONE
template <size_t nr>
struct MultiBase<nr>
{};
//=
//MULTI
template <template <typename> class Policy, typename ...Types>
struct Multi: public MultiBase<0, Policy<Types>...>
{
using PlainTypes = TypeList<Types...>;
using Base = MultiBase<0, Policy<Types>...>;
enum { size = PlainTypes::size };
Multi(Policy<Types> &&...types)
:
MultiBase<0, Policy<Types>...>(
std::forward<Policy<Types>>(types)...)
{}
};
//=
template <typename TP>
struct st
{
static_assert(sizeof(TP) == 0, "");
};
//TYPEAT
template <size_t index, typename Multi>
class typeAt
{
template <size_t idx, typename MultiBase>
struct PolType;
template <size_t idx,
size_t nr, typename PolicyT1, typename ...PolicyTypes>
struct PolType<idx, MultiBase<nr, PolicyT1, PolicyTypes...>>
{
using Type = typename PolType< idx - 1, MultiBase<nr + 1,
PolicyTypes...> >::Type;
};
template <size_t nr, typename PolicyT1, typename ...PolicyTypes>
struct PolType<0, MultiBase<nr, PolicyT1, PolicyTypes...>>
{
using Type = PolicyT1;
};
public:
typeAt(typeAt const &) = delete;
using Type = typename PolType<index, typename Multi::Base>::Type;
};
//=
//GET
template <size_t idx, typename Multi>
inline typename typeAt<idx, Multi>::Type &get(Multi &multi)
{
return static_cast<
UWrap<idx, typename typeAt<idx, Multi>::Type> &>(multi);
}
//=
//PLAINAT
template <size_t index, typename Multi>
class plainTypeAt
{
template <size_t idx, typename List>
struct At;
template <size_t idx, typename Head, typename ...Tail>
struct At<idx, TypeList<Head, Tail...>>
{
using Type = typename At<idx - 1, TypeList<Tail...>>::Type;
};
template <typename Head, typename ...Tail>
struct At<0, TypeList<Head, Tail...>>
{
using Type = Head;
};
public:
plainTypeAt(plainTypeAt const &) = delete;
using Type = typename At<index, typename Multi::PlainTypes>::Type;
};
//=
|
