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;
};
//=
|