1// Boost.TypeErasure library
2//
3// Copyright 2012-2013 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$
10
11#ifndef BOOST_TYPE_ERASURE_MEMBER_HPP_INCLUDED
12#define BOOST_TYPE_ERASURE_MEMBER_HPP_INCLUDED
13
14#include <boost/type_erasure/detail/member11.hpp>
15
16#ifndef BOOST_TYPE_ERASURE_MEMBER
17
18#include <boost/detail/workaround.hpp>
19#include <boost/preprocessor/cat.hpp>
20#include <boost/preprocessor/dec.hpp>
21#include <boost/preprocessor/comma_if.hpp>
22#include <boost/preprocessor/repetition/enum.hpp>
23#include <boost/preprocessor/repetition/enum_trailing.hpp>
24#include <boost/preprocessor/repetition/enum_params.hpp>
25#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
26#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
27#include <boost/preprocessor/seq/size.hpp>
28#include <boost/preprocessor/seq/elem.hpp>
29#include <boost/preprocessor/tuple/elem.hpp>
30#include <boost/type_erasure/detail/macro.hpp>
31#include <boost/type_erasure/detail/const.hpp>
32#include <boost/type_erasure/rebind_any.hpp>
33#include <boost/type_erasure/placeholder.hpp>
34#include <boost/type_erasure/call.hpp>
35#include <boost/type_erasure/concept_interface.hpp>
36
37/** INTERNAL ONLY */
38#define BOOST_TYPE_ERASURE_MEMBER_ARG(z, n, data) \
39 typename ::boost::type_erasure::as_param<Base, BOOST_PP_CAT(A, n)>::type BOOST_PP_CAT(a, n)
40
41#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || \
42 defined(BOOST_TYPE_ERASURE_DOXYGEN) || \
43 BOOST_WORKAROUND(BOOST_MSVC, == 1800)
44
45/** INTERNAL ONLY */
46#define BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(seq, N) \
47 BOOST_TYPE_ERASURE_QUALIFIED_NAME(seq)<R(BOOST_PP_ENUM_PARAMS(N, A)), T>
48
49/** INTERNAL ONLY */
50#define BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, X) BOOST_PP_ENUM_TRAILING_PARAMS(N, X)
51/** INTERNAL ONLY */
52#define BOOST_TYPE_ERASURE_MEMBER_ENUM_PARAMS(N, X) BOOST_PP_ENUM_PARAMS(N, X)
53
54#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
55
56/** INTERNAL ONLY */
57#define BOOST_TYPE_ERASURE_MEMBER_FORWARD(z, n, data) ::std::forward<BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, data), n)>(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 1, data), n))
58/** INTERNAL ONLY */
59#define BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, X, x) BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_MEMBER_FORWARD, (X, x))
60/** INTERNAL ONLY*/
61#define BOOST_TYPE_ERASURE_FORWARD_REBIND1(z, n, data) ::std::forward<typename ::boost::type_erasure::as_param<Base, BOOST_PP_CAT(A, n)>::type>(BOOST_PP_CAT(a, n))
62/** INTERNAL ONLY*/
63#define BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N) BOOST_PP_ENUM_TRAILING(N, BOOST_TYPE_ERASURE_FORWARD_REBIND1, ~)
64
65#else
66
67/** INTERNAL ONLY */
68#define BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, X, x) BOOST_PP_ENUM_PARAMS(N, x)
69/** INTERNAL ONLY*/
70#define BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N) BOOST_PP_ENUM_TRAILING_PARAMS(N, a)
71
72#endif
73
74/** INTERNAL ONLY */
75#define BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_PARAMS(N, X) BOOST_PP_ENUM_TRAILING_PARAMS(N, X)
76/** INTERNAL ONLY */
77#define BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_BINARY_PARAMS(N, X, x) BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, X, x)
78/** INTERNAL ONLY */
79#define BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N) BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_MEMBER_ARG, ~)
80
81#ifdef BOOST_TYPE_ERASURE_DOXYGEN
82
83/**
84 * \brief Defines a primitive concept for a member function.
85 *
86 * \param concept_name is the name of the concept to declare.
87 * If it is omitted it defaults to <code>has_ ## member</code>
88 * \param member is the name of the member function.
89 *
90 * The declaration of the concept is
91 * \code
92 * template<class Sig, class T = _self>
93 * struct concept_name;
94 * \endcode
95 * where @c Sig is a function type giving the
96 * signature of the member function, and @c T is the
97 * object type. @c T may be const-qualified for
98 * const member functions. @c concept_name<R(A...) const, T>
99 * is an alias for @c concept_name<R(A...), const T>.
100 *
101 * This macro can only be used at namespace scope.
102 *
103 * Example:
104 *
105 * \code
106 * namespace boost {
107 * BOOST_TYPE_ERASURE_MEMBER(push_back)
108 * }
109 * typedef boost::has_push_back<void(int)> push_back_concept;
110 * \endcode
111 *
112 * The concept defined by this function may be specialized to
113 * provide a concept_map. The class object will be passed by
114 * reference as the first parameter.
115 *
116 * \code
117 * template<>
118 * struct has_push_back<void(int), std::list<int> > {
119 * static void apply(std::list<int>& l, int i) { l.push_back(i); }
120 * };
121 * \endcode
122 *
123 * In C++03, the macro can only be used in the global namespace and
124 * is defined as:
125 *
126 * \code
127 * #define BOOST_TYPE_ERASURE_MEMBER(qualified_name, member, N)
128 * \endcode
129 *
130 * Example:
131 *
132 * \code
133 * BOOST_TYPE_ERASURE_MEMBER((boost)(has_push_back), push_back, 1)
134 * typedef boost::has_push_back<void(int), _self> push_back_concept;
135 * \endcode
136 *
137 * For backwards compatibility, this form is always accepted.
138 */
139#define BOOST_TYPE_ERASURE_MEMBER(concept_name, member) /**/
140
141#else
142
143#define BOOST_TYPE_ERASURE_MEMBER(qualified_name, member, N) \
144 BOOST_TYPE_ERASURE_MEMBER_I( \
145 qualified_name, \
146 BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(qualified_name)), qualified_name), \
147 member, \
148 N)
149
150#endif
151
152#else
153
154/** INTERNAL ONLY */
155#define BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(seq, N) \
156 BOOST_TYPE_ERASURE_QUALIFIED_NAME(seq)<R(A...), T>
157
158#define BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, X) , class... A
159#define BOOST_TYPE_ERASURE_MEMBER_ENUM_PARAMS(N, X) X...
160#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
161# define BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, X, x) ::std::forward<X>(x)...
162# define BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N) , ::std::forward<typename ::boost::type_erasure::as_param<Base, A>::type>(a)...
163#else
164# define BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, X, x) x...
165# define BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N) , a...
166#endif
167#define BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_PARAMS(N, X) , X...
168#define BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_BINARY_PARAMS(N, X, x) , X... x
169#define BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N) typename ::boost::type_erasure::as_param<Base, A>::type... a
170
171
172#define BOOST_TYPE_ERASURE_MEMBER(qualified_name, member, ...) \
173 BOOST_TYPE_ERASURE_MEMBER_I( \
174 qualified_name, \
175 BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(qualified_name)), qualified_name), \
176 member, \
177 N)
178
179#endif
180
181/** INTERNAL ONLY */
182#define BOOST_TYPE_ERASURE_MEMBER_II(qual_name, concept_name, member, N) \
183 BOOST_TYPE_ERASURE_OPEN_NAMESPACE(qual_name) \
184 template<class Sig, class T = ::boost::type_erasure::_self> \
185 struct concept_name; \
186 template<class R BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A), class T> \
187 struct concept_name<R(BOOST_TYPE_ERASURE_MEMBER_ENUM_PARAMS(N, A)), T> { \
188 static R apply(T& t BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_BINARY_PARAMS(N, A, a)) \
189 { return t.member(BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, A, a)); } \
190 }; \
191 template<class T BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A)> \
192 struct concept_name<void(BOOST_TYPE_ERASURE_MEMBER_ENUM_PARAMS(N, A)), T> { \
193 static void apply(T& t BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_BINARY_PARAMS(N, A, a)) \
194 { t.member(BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, A, a)); } \
195 }; \
196 BOOST_TYPE_ERASURE_CLOSE_NAMESPACE(qual_name) \
197 namespace boost { \
198 namespace type_erasure { \
199 template< \
200 class R BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A), \
201 class T, class Base, class Enable> \
202 struct concept_interface< \
203 BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N), \
204 Base, \
205 typename ::boost::enable_if< \
206 ::boost::type_erasure::detail::should_be_non_const<T, Base>, \
207 typename ::boost::remove_const<T>::type \
208 >::type, \
209 Enable \
210 > : Base \
211 { \
212 typedef void BOOST_PP_CAT(_boost_type_erasure_has_member, member); \
213 typename rebind_any<Base, R>::type member( \
214 BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N)) \
215 { \
216 return ::boost::type_erasure::call( \
217 BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N)(), \
218 *this BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N)); \
219 } \
220 }; \
221 template< \
222 class R BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A), \
223 class T, class Base, class Enable> \
224 struct concept_interface< \
225 BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N), \
226 Base, \
227 typename ::boost::enable_if< \
228 ::boost::type_erasure::detail::should_be_const<T, Base>, \
229 typename ::boost::remove_const<T>::type \
230 >::type, \
231 Enable \
232 > : Base \
233 { \
234 typedef void BOOST_PP_CAT(_boost_type_erasure_has_member, member); \
235 typename rebind_any<Base, R>::type member( \
236 BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N)) const \
237 { \
238 return ::boost::type_erasure::call( \
239 BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N)(), \
240 *this BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N)); \
241 } \
242 }; \
243 template<class R BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A), class T, class Base> \
244 struct concept_interface< \
245 BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N), \
246 Base, \
247 typename ::boost::enable_if< \
248 ::boost::type_erasure::detail::should_be_non_const<T, Base>, \
249 typename ::boost::remove_const<T>::type \
250 >::type, \
251 typename Base::BOOST_PP_CAT(_boost_type_erasure_has_member, member)> : Base \
252 { \
253 using Base::member; \
254 typename rebind_any<Base, R>::type member( \
255 BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N)) \
256 { \
257 return ::boost::type_erasure::call( \
258 BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N)(), \
259 *this BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N)); \
260 } \
261 }; \
262 template<class R BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A), class T, class Base> \
263 struct concept_interface< \
264 BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N), \
265 Base, \
266 typename ::boost::enable_if< \
267 ::boost::type_erasure::detail::should_be_const<T, Base>, \
268 typename ::boost::remove_const<T>::type \
269 >::type, \
270 typename Base::BOOST_PP_CAT(_boost_type_erasure_has_member, member)> : Base \
271 { \
272 using Base::member; \
273 typename rebind_any<Base, R>::type member( \
274 BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N)) const \
275 { \
276 return ::boost::type_erasure::call( \
277 BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N)(), \
278 *this BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N)); \
279 } \
280 }; \
281 }}
282
283/** INTERNAL ONLY */
284#define BOOST_TYPE_ERASURE_MEMBER_I(namespace_name, concept_name, member, N)\
285 BOOST_TYPE_ERASURE_MEMBER_II(namespace_name, concept_name, member, N)
286
287#endif
288
289#endif
290

source code of boost/libs/type_erasure/include/boost/type_erasure/member.hpp