1// Copyright 2015-2018 Klemens D. Morgenstern
2//
3// Distributed under the Boost Software License, Version 1.0.
4// (See accompanying file LICENSE_1_0.txt
5// or copy at http://www.boost.org/LICENSE_1_0.txt)
6
7#ifndef BOOST_DLL_DETAIL_IMPORT_MANGLED_HELPERS_HPP_
8#define BOOST_DLL_DETAIL_IMPORT_MANGLED_HELPERS_HPP_
9
10
11#include <boost/type_traits/conditional.hpp>
12#include <boost/type_traits/is_same.hpp>
13#include <boost/type_traits/is_class.hpp>
14#include <boost/type_traits/is_function.hpp>
15#include <boost/type_traits/remove_cv.hpp>
16
17
18#ifdef BOOST_HAS_PRAGMA_ONCE
19# pragma once
20#endif
21
22namespace boost { namespace dll { namespace experimental { namespace detail {
23
24//the following could be done by fusion, though it's simple enough to just declare it here.
25template<class ...Args>
26struct sequence {};
27
28template<class Value, class Seq> struct push_front;
29template<class Value, class ...Args>
30struct push_front<Value, sequence<Args...>>
31{
32 typedef sequence<Value, Args...> type;
33};
34
35template<class Lhs, class Rhs>
36struct unqalified_is_same :
37 boost::is_same<
38 typename boost::remove_cv<Lhs>::type,
39 typename boost::remove_cv<Rhs>::type
40 >
41{
42};
43
44/* ********************************** function sequence type traits ******************************/
45
46//determine if it's a sequence of functions.
47template<class T> struct is_function_seq;
48
49//type-trait for function overloads
50template<class Class, class...Args> struct is_function_seq<sequence<Class, Args...>>
51 : boost::conditional<
52 boost::is_function<Class>::value,
53 is_function_seq<sequence<Args...>>,
54 boost::false_type>::type
55{};
56
57template<class Class>
58struct is_function_seq<sequence<Class>> : boost::is_function<Class>
59{
60};
61
62template<>
63struct is_function_seq<sequence<>> : boost::false_type
64{
65};
66
67/* ********************************* Function Tuple *************************** */
68
69//a tuple of plain functions.
70template <class ...Ts>
71struct function_tuple;
72
73template <class Return, class...Args, class T2, class ...Ts>
74struct function_tuple<Return(Args...), T2, Ts...>
75 : function_tuple<T2, Ts...>
76{
77 Return(*f_)(Args...);
78
79 constexpr function_tuple(Return(* t)(Args...), T2* t2, Ts* ... ts)
80 : function_tuple<T2, Ts...>(t2, ts...)
81 , f_(t)
82 {}
83
84 Return operator()(Args...args) const {
85 return (*f_)(static_cast<Args>(args)...);
86 }
87 using function_tuple<T2, Ts...>::operator();
88};
89
90template <class Return, class...Args>
91struct function_tuple<Return(Args...)> {
92 Return(*f_)(Args...);
93
94 constexpr function_tuple(Return(* t)(Args...))
95 : f_(t)
96 {}
97
98 Return operator()(Args...args) const {
99 return (*f_)(static_cast<Args>(args)...);
100 }
101};
102
103
104/* ********************************** MemFn sequence type traits ******************************/
105
106template<class Class, class Func>
107struct mem_fn_def
108{
109 typedef Class class_type;
110 typedef Func func_type;
111 typedef typename boost::dll::detail::get_mem_fn_type<Class, Func>::mem_fn mem_fn;
112};
113
114template<class ...Args>
115struct make_mem_fn_seq;
116
117// B: is T1 another version of T0?
118template<bool, class T0, class T1, class T2>
119struct make_mem_fn_seq_getter;
120
121template<class T0, class T1, class T2>
122struct make_mem_fn_seq_getter<true, T0, T1, T2>
123{
124 typedef mem_fn_def<T1, T2> type;
125};
126
127template<class T0, class T1, class T2>
128struct make_mem_fn_seq_getter<false, T0, T1, T2>
129{
130 typedef mem_fn_def<T0, T1> type;
131};
132
133template<class Class, class Signature>
134struct make_mem_fn_seq<Class, Signature>
135{
136 typedef mem_fn_def<Class, Signature> mem_fn;
137 typedef sequence<mem_fn> type;
138};
139
140template<class Class>
141struct make_mem_fn_seq<Class>
142{
143 typedef sequence<> type;
144};
145
146template<class T0, class T1, class T2, class ... Args>
147struct make_mem_fn_seq<T0, T1, T2, Args...>
148{
149 /* Since we might have ovls, it might be :
150 * Class, void(int), void(int, int) //--> just us class for both
151 * Class, const Class, void(int)//--> ovl class.
152 *
153 */
154 static_assert(boost::is_object<T0>::value, "");
155 typedef typename make_mem_fn_seq_getter<
156 unqalified_is_same<T0, T1>::value, T0, T1, T2>::type mem_fn_type;
157
158 typedef typename boost::conditional<
159 unqalified_is_same<T0, T1>::value,
160 make_mem_fn_seq<T1, Args...>,
161 make_mem_fn_seq<T0, T2, Args...>> ::type next;
162
163 typedef typename push_front<mem_fn_type, typename next::type>::type type;
164};
165
166
167
168
169/* Ok, this needs to be documented, so here's some pseudo-code:
170 *
171 * @code
172 *
173 * bool unqalified_is_same(lhs, rhs)
174 * {
175 * return remove_cv(lhs) == remove_cv(rhs);
176 * }
177 *
178 * mem_fn make_mem_fn_seq_getter(b, cl, T2, T3)
179 * {
180 * if (b) //b means, that T2 is another version of cl, i.e. qualified
181 * return get_mem_fn_type(T2, T3);
182 * else //means that T2 is a function.
183 * return get_mem_fn_type(cl, T2);
184 * }
185 *
186 * sequence make_mem_fn_seq(type cl, type T2, type T3, types...)
187 * {
188 * mem_fn = make_mem_fn_seq_getter(
189 * unqalified_is_same(cl, T2), cl, T2, T3);
190 *
191 * next = unqalified_is_same(cl, T2) ?
192 * make_mem_fn_seq(T2, types...) //because: T2 is another version of cl, hence i use this. T3 was already consumed.
193 * :
194 * make_mem_fn_seq(Class, T3, types...) //because: T2 was a function, hence it is consumed and class remains unchanged.
195 * ;
196 * return push_front(mem_fn, next) ;
197 * };
198 * @endcode
199 */
200
201
202
203template<class T, class U, class ...Args>
204struct is_mem_fn_seq_impl
205{
206 typedef typename boost::conditional<
207 boost::is_function<U>::value || boost::dll::experimental::detail::unqalified_is_same<T, U>::value,
208 typename is_mem_fn_seq_impl<T, Args...>::type,
209 boost::false_type>::type type;
210};
211
212template<class T, class U>
213struct is_mem_fn_seq_impl<T, U>
214{
215 typedef typename boost::conditional<
216 boost::is_function<U>::value && boost::is_object<T>::value,
217 boost::true_type, boost::false_type>::type type;
218};
219
220template<class T, class U, class Last>
221struct is_mem_fn_seq_impl<T, U, Last>
222{
223 typedef typename boost::conditional<
224 (boost::is_function<U>::value || boost::dll::experimental::detail::unqalified_is_same<T, U>::value)
225 && boost::is_function<Last>::value,
226 boost::true_type, boost::false_type>::type type;
227};
228
229template<class T> struct is_mem_fn_seq : boost::false_type {};
230
231//If only two arguments are provided at all.
232template<class T, class U>
233struct is_mem_fn_seq<sequence<T, U>> : boost::conditional<
234 boost::is_object<T>::value && boost::is_function<U>::value,
235 boost::true_type, boost::false_type>::type
236{
237};
238
239
240template<class T, class Func, class ...Args>
241struct is_mem_fn_seq<sequence<T, Func, Args...>> :
242 boost::conditional<
243 boost::is_class<T>::value && boost::is_function<Func>::value,
244 typename is_mem_fn_seq_impl<T, Args...>::type,
245 boost::false_type>::type {};
246
247
248/* ********************************** mem fn sequence tuple ******************************/
249
250/* A tuple of member functions
251 * Unlike for plain functions a sequence here might contain classes as well as functions.
252 */
253template <class ...Ts>
254struct mem_fn_tuple;
255
256template <class Class, class Return, class...Args, class T2, class ...Ts>
257struct mem_fn_tuple<mem_fn_def<Class, Return(Args...)>, T2, Ts...>
258 : mem_fn_tuple<T2, Ts...>
259{
260 typedef typename boost::dll::detail::get_mem_fn_type<Class, Return(Args...)>::mem_fn mem_fn;
261 mem_fn f_;
262
263 constexpr mem_fn_tuple(mem_fn f, typename T2::mem_fn t2, typename Ts::mem_fn ... ts)
264 : mem_fn_tuple<T2, Ts...>(t2, ts...)
265 , f_(f)
266 {}
267
268 Return operator()(Class* const cl, Args...args) const {
269 return (cl->*f_)(static_cast<Args>(args)...);
270 }
271 using mem_fn_tuple<T2, Ts...>::operator();
272
273};
274
275template <class Class, class Return, class...Args>
276struct mem_fn_tuple<mem_fn_def<Class, Return(Args...)>> {
277 typedef typename boost::dll::detail::get_mem_fn_type<Class, Return(Args...)>::mem_fn mem_fn;
278 mem_fn f_;
279
280 constexpr mem_fn_tuple(mem_fn f)
281 : f_(f)
282 {}
283
284 Return operator()(Class * const cl, Args...args) const {
285 return (cl->*f_)(static_cast<Args>(args)...);
286 }
287};
288
289}}}}
290#endif /* BOOST_DLL_DETAIL_IMPORT_MANGLED_HELPERS_HPP_ */
291

source code of boost/libs/dll/include/boost/dll/detail/import_mangled_helpers.hpp