← Back to branch summary

~ai.tron/armagetronad/0.4-winlibs-updated

« back to all changes in this revision

Viewing changes to boost/includes/boost/type_erasure/detail/vtable.hpp

  • Committer: Nik K.
  • Date: 2013-11-07 16:58:35 UTC
  • Revision ID: nik.karbaum@gmail.com-20131107165835-kq99jz23drfj4dkh
Forgot to add some files; here they are

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/includes/boost/type_erasure/detail/vtable.hpp
 
1
// Boost.TypeErasure library
 
2
//
 
3
// Copyright 2011 Steven Watanabe
 
4
//
 
5
// Distributed under the Boost Software License Version 1.0. (See
 
6
// accompanying file LICENSE_1_0.txt or copy at
 
7
// http://www.boost.org/LICENSE_1_0.txt)
 
8
//
 
9
// $Id: vtable.hpp 83248 2013-03-02 18:15:06Z steven_watanabe $
 
10
 
 
11
#if !defined(BOOST_PP_IS_ITERATING)
 
12
 
 
13
#ifndef BOOST_TYPE_ERASURE_DETAIL_VTABLE_HPP_INCLUDED
 
14
#define BOOST_TYPE_ERASURE_DETAIL_VTABLE_HPP_INCLUDED
 
15
 
 
16
#include <boost/config.hpp>
 
17
#include <boost/mpl/at.hpp>
 
18
#include <boost/mpl/size.hpp>
 
19
#include <boost/preprocessor/cat.hpp>
 
20
#include <boost/preprocessor/iteration/iterate.hpp>
 
21
#include <boost/preprocessor/repetition/enum.hpp>
 
22
#include <boost/preprocessor/repetition/enum_params.hpp>
 
23
#include <boost/preprocessor/repetition/enum_trailing.hpp>
 
24
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
 
25
#include <boost/preprocessor/repetition/repeat.hpp>
 
26
#include <boost/type_erasure/detail/rebind_placeholders.hpp>
 
27
#include <boost/type_erasure/config.hpp>
 
28
 
 
29
namespace boost {
 
30
namespace type_erasure {
 
31
namespace detail {
 
32
 
 
33
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CONSTEXPR) && !defined(BOOST_NO_DEFAULTED_FUNCTIONS)
 
34
 
 
35
template<class... T>
 
36
struct stored_arg_pack;
 
37
 
 
38
template<class It, class End, class... T>
 
39
struct make_arg_pack_impl
 
40
{
 
41
    typedef typename make_arg_pack_impl<
 
42
        typename ::boost::mpl::next<It>::type,
 
43
        End,
 
44
        T...,
 
45
        typename ::boost::mpl::deref<It>::type
 
46
    >::type type;
 
47
};
 
48
 
 
49
template<class End, class... T>
 
50
struct make_arg_pack_impl<End, End, T...>
 
51
{
 
52
    typedef stored_arg_pack<T...> type;
 
53
};
 
54
 
 
55
template<class Seq>
 
56
struct make_arg_pack
 
57
{
 
58
    typedef typename make_arg_pack_impl<
 
59
        typename ::boost::mpl::begin<Seq>::type,
 
60
        typename ::boost::mpl::end<Seq>::type
 
61
    >::type type;
 
62
};
 
63
 
 
64
template<class Args>
 
65
struct make_vtable_impl;
 
66
 
 
67
template<class Seq>
 
68
struct make_vtable
 
69
{
 
70
    typedef typename ::boost::type_erasure::detail::make_vtable_impl<
 
71
        typename ::boost::type_erasure::detail::make_arg_pack<Seq>::type
 
72
    >::type type;
 
73
};
 
74
 
 
75
template<class Table, class Args>
 
76
struct make_vtable_init_impl;
 
77
 
 
78
template<class Seq, class Table>
 
79
struct make_vtable_init
 
80
{
 
81
    typedef typename make_vtable_init_impl<
 
82
        Table,
 
83
        typename ::boost::type_erasure::detail::make_arg_pack<Seq>::type
 
84
    >::type type;
 
85
};
 
86
 
 
87
template<class T>
 
88
struct vtable_entry
 
89
{
 
90
    typename T::type value;
 
91
    vtable_entry() = default;
 
92
    constexpr vtable_entry(typename T::type arg) : value(arg) {}
 
93
};
 
94
 
 
95
template<class... T>
 
96
struct compare_vtable;
 
97
 
 
98
template<>
 
99
struct compare_vtable<> {
 
100
    template<class S>
 
101
    static bool apply(const S& s1, const S& s2)
 
102
    {
 
103
        return true;
 
104
    }
 
105
};
 
106
 
 
107
template<class T0, class... T>
 
108
struct compare_vtable<T0, T...> {
 
109
    template<class S>
 
110
    static bool apply(const S& s1, const S& s2)
 
111
    {
 
112
        return static_cast<const vtable_entry<T0>&>(s1).value ==
 
113
            static_cast<const vtable_entry<T0>&>(s2).value &&
 
114
            compare_vtable<T...>::apply(s1, s2);
 
115
    }
 
116
};
 
117
 
 
118
template<class... T>
 
119
struct vtable_storage : vtable_entry<T>...
 
120
{
 
121
    vtable_storage() = default;
 
122
 
 
123
    constexpr vtable_storage(typename T::type... arg)
 
124
        : vtable_entry<T>(arg)... {}
 
125
 
 
126
    template<class Bindings, class Src>
 
127
    void convert_from(const Src& src)
 
128
    {
 
129
        *this = vtable_storage(
 
130
            src.lookup(
 
131
                (typename ::boost::type_erasure::detail::rebind_placeholders<
 
132
                T, Bindings
 
133
            >::type*)0)...);
 
134
    }
 
135
 
 
136
    bool operator==(const vtable_storage& other) const
 
137
    { return compare_vtable<T...>::apply(*this, other); }
 
138
 
 
139
    template<class U>
 
140
    typename U::type lookup(U*) const
 
141
    {
 
142
        return static_cast<const vtable_entry<U>*>(this)->value;
 
143
    }
 
144
};
 
145
 
 
146
// Provide this specialization manually.
 
147
// gcc 4.7.2 fails to instantiate the primary template.
 
148
template<>
 
149
struct vtable_storage<>
 
150
{
 
151
    vtable_storage() = default;
 
152
 
 
153
    template<class Bindings, class Src>
 
154
    void convert_from(const Src& src) {}
 
155
 
 
156
    bool operator==(const vtable_storage& other) const
 
157
    { return true; }
 
158
};
 
159
 
 
160
template<class... T>
 
161
struct make_vtable_impl<stored_arg_pack<T...> >
 
162
{
 
163
    typedef vtable_storage<T...> type;
 
164
};
 
165
 
 
166
template<class Table, class... T>
 
167
struct vtable_init
 
168
{
 
169
    static constexpr Table value = Table(T::value...);
 
170
};
 
171
 
 
172
template<class Table, class... T>
 
173
constexpr Table vtable_init<Table, T...>::value;
 
174
 
 
175
template<class Table, class... T>
 
176
struct make_vtable_init_impl<Table, stored_arg_pack<T...> >
 
177
{
 
178
    typedef vtable_init<Table, T...> type;
 
179
};
 
180
 
 
181
#else
 
182
 
 
183
template<int N>
 
184
struct make_vtable_impl;
 
185
 
 
186
template<class Seq>
 
187
struct make_vtable
 
188
{
 
189
    typedef typename make_vtable_impl<
 
190
        (::boost::mpl::size<Seq>::value)>::template apply<Seq>::type type;
 
191
};
 
192
 
 
193
template<int N>
 
194
struct make_vtable_init_impl;
 
195
 
 
196
template<class Seq, class Table>
 
197
struct make_vtable_init
 
198
{
 
199
    typedef typename make_vtable_init_impl<
 
200
        (::boost::mpl::size<Seq>::value)>::template apply<Seq, Table>::type type;
 
201
};
 
202
 
 
203
#define BOOST_PP_FILENAME_1 <boost/type_erasure/detail/vtable.hpp>
 
204
#define BOOST_PP_ITERATION_LIMITS (0, BOOST_TYPE_ERASURE_MAX_FUNCTIONS)
 
205
#include BOOST_PP_ITERATE()
 
206
 
 
207
#endif
 
208
 
 
209
}
 
210
}
 
211
}
 
212
 
 
213
#endif
 
214
 
 
215
#else
 
216
 
 
217
#define N BOOST_PP_ITERATION()
 
218
 
 
219
#define BOOST_TYPE_ERASURE_VTABLE_ENTRY(z, n, data)                     \
 
220
    typename BOOST_PP_CAT(T, n)::type BOOST_PP_CAT(t, n);               \
 
221
    typename BOOST_PP_CAT(T, n)::type lookup(BOOST_PP_CAT(T, n)*) const \
 
222
    {                                                                   \
 
223
        return BOOST_PP_CAT(t, n);                                      \
 
224
    }
 
225
 
 
226
#define BOOST_TYPE_ERASURE_VTABLE_COMPARE(z, n, data)                   \
 
227
    && BOOST_PP_CAT(t, n) == other.BOOST_PP_CAT(t, n)
 
228
 
 
229
#define BOOST_TYPE_ERASURE_VTABLE_INIT(z, n, data)  \
 
230
    BOOST_PP_CAT(data, n)::value
 
231
 
 
232
#define BOOST_TYPE_ERASURE_AT(z, n, data)       \
 
233
    typename ::boost::mpl::at_c<data, n>::type
 
234
 
 
235
#define BOOST_TYPE_ERASURE_CONVERT_ELEMENT(z, n, data)                  \
 
236
    BOOST_PP_CAT(t, n) = src.lookup(                                    \
 
237
        (typename ::boost::type_erasure::detail::rebind_placeholders<   \
 
238
            BOOST_PP_CAT(T, n), Bindings                                \
 
239
        >::type*)0                                                      \
 
240
    );
 
241
 
 
242
#if N != 0
 
243
template<BOOST_PP_ENUM_PARAMS(N, class T)>
 
244
#else
 
245
template<class D = void>
 
246
#endif
 
247
struct BOOST_PP_CAT(vtable_storage, N)
 
248
{
 
249
    BOOST_PP_REPEAT(N, BOOST_TYPE_ERASURE_VTABLE_ENTRY, ~)
 
250
 
 
251
    template<class Bindings, class Src>
 
252
    void convert_from(const Src& src)
 
253
    {
 
254
        BOOST_PP_REPEAT(N, BOOST_TYPE_ERASURE_CONVERT_ELEMENT, ~)
 
255
    }
 
256
 
 
257
    bool operator==(const BOOST_PP_CAT(vtable_storage, N)& other) const
 
258
    { return true BOOST_PP_REPEAT(N, BOOST_TYPE_ERASURE_VTABLE_COMPARE, ~); }
 
259
};
 
260
 
 
261
template<>
 
262
struct make_vtable_impl<N>
 
263
{
 
264
    template<class Seq>
 
265
    struct apply
 
266
    {
 
267
        typedef ::boost::type_erasure::detail::BOOST_PP_CAT(vtable_storage, N)<
 
268
            BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_AT, Seq)
 
269
        > type;
 
270
    };
 
271
};
 
272
template<class Table BOOST_PP_ENUM_TRAILING_PARAMS(N, class T)>
 
273
struct BOOST_PP_CAT(vtable_init, N)
 
274
{
 
275
    static const Table value;
 
276
};
 
277
 
 
278
template<class Table BOOST_PP_ENUM_TRAILING_PARAMS(N, class T)>
 
279
const Table BOOST_PP_CAT(vtable_init, N)<
 
280
    Table BOOST_PP_ENUM_TRAILING_PARAMS(N, T)>::value =
 
281
{
 
282
    BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_VTABLE_INIT, T)
 
283
};
 
284
 
 
285
template<>
 
286
struct make_vtable_init_impl<N>
 
287
{
 
288
    template<class Seq, class Table>
 
289
    struct apply
 
290
    {
 
291
        typedef ::boost::type_erasure::detail::BOOST_PP_CAT(vtable_init, N)<
 
292
            Table
 
293
            BOOST_PP_ENUM_TRAILING(N, BOOST_TYPE_ERASURE_AT, Seq)
 
294
        > type;
 
295
    };
 
296
};
 
297
 
 
298
#undef BOOST_TYPE_ERASURE_CONVERT_ELEMENT
 
299
#undef BOOST_TYPE_ERASURE_AT
 
300
#undef BOOST_TYPE_ERASURE_VTABLE_INIT
 
301
#undef BOOST_TYPE_ERASURE_VTABLE_COMPARE
 
302
#undef BOOST_TYPE_ERASURE_VTABLE_ENTRY
 
303
#undef N
 
304
 
 
305
#endif