1 // Copyright 2015-2016 Klemens D. Morgenstern
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)
7 #ifndef BOOST_DLL_DETAIL_IMPORT_MANGLED_HELPERS_HPP_
8 #define BOOST_DLL_DETAIL_IMPORT_MANGLED_HELPERS_HPP_
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>
18 #ifdef BOOST_HAS_PRAGMA_ONCE
22 namespace boost { namespace dll { namespace experimental { namespace detail {
24 //the following could be done by fusion, though it's simple enough to just declare it here.
25 template<class ...Args>
28 template<class Value, class Seq> struct push_front;
29 template<class Value, class ...Args>
30 struct push_front<Value, sequence<Args...>>
32 typedef sequence<Value, Args...> type;
35 template<class Lhs, class Rhs>
36 struct unqalified_is_same :
38 typename boost::remove_cv<Lhs>::type,
39 typename boost::remove_cv<Rhs>::type
44 /* ********************************** function sequence type traits ******************************/
46 //determine if it's a sequence of functions.
47 template<class T> struct is_function_seq;
49 //type-trait for function overloads
50 template<class Class, class...Args> struct is_function_seq<sequence<Class, Args...>>
52 boost::is_function<Class>::value,
53 is_function_seq<sequence<Args...>>,
54 boost::false_type>::type
58 struct is_function_seq<sequence<Class>> : boost::is_function<Class>
63 struct is_function_seq<sequence<>> : boost::false_type
67 /* ********************************* Function Tuple *************************** */
69 //a tuple of plain functions.
70 template <class ...Ts>
71 struct function_tuple;
73 template <class Return, class...Args, class T2, class ...Ts>
74 struct function_tuple<Return(Args...), T2, Ts...> : function_tuple<T2, Ts...>
76 constexpr function_tuple(Return(* t)(Args...), T2* t2, Ts* ... ts) : function_tuple<T2, Ts...>(t2, ts...), _f(t) {};
79 Return operator()(Args...args)
81 return (*_f)(static_cast<Args>(args)...);
83 using function_tuple<T2, Ts...>::operator();
87 template <class Return, class...Args>
88 struct function_tuple<Return(Args...)>
90 constexpr function_tuple(Return(* t)(Args...)) : _f(t) {};
93 Return operator()(Args...args)
95 return (*_f)(static_cast<Args>(args)...);
100 /* ********************************** MemFn sequence type traits ******************************/
102 template<class Class, class Func>
105 typedef Class class_type;
106 typedef Func func_type;
107 typedef typename boost::dll::detail::get_mem_fn_type<Class, Func>::mem_fn mem_fn;
110 template<class ...Args>
111 struct make_mem_fn_seq;
113 // B: is T1 another version of T0?
114 template<bool, class T0, class T1, class T2>
115 struct make_mem_fn_seq_getter;
117 template<class T0, class T1, class T2>
118 struct make_mem_fn_seq_getter<true, T0, T1, T2>
120 typedef mem_fn_def<T1, T2> type;
123 template<class T0, class T1, class T2>
124 struct make_mem_fn_seq_getter<false, T0, T1, T2>
126 typedef mem_fn_def<T0, T1> type;
129 template<class Class, class Signature>
130 struct make_mem_fn_seq<Class, Signature>
132 typedef mem_fn_def<Class, Signature> mem_fn;
133 typedef sequence<mem_fn> type;
136 template<class Class>
137 struct make_mem_fn_seq<Class>
139 typedef sequence<> type;
142 template<class T0, class T1, class T2, class ... Args>
143 struct make_mem_fn_seq<T0, T1, T2, Args...>
145 /* Since we might have ovls, it might be :
146 * Class, void(int), void(int, int) //--> just us class for both
147 * Class, const Class, void(int)//--> ovl class.
150 static_assert(boost::is_object<T0>::value, "");
151 typedef typename make_mem_fn_seq_getter<
152 unqalified_is_same<T0, T1>::value, T0, T1, T2>::type mem_fn_type;
154 typedef typename boost::conditional<
155 unqalified_is_same<T0, T1>::value,
156 make_mem_fn_seq<T1, Args...>,
157 make_mem_fn_seq<T0, T2, Args...>> ::type next;
159 typedef typename push_front<mem_fn_type, typename next::type>::type type;
165 /* Ok, this needs to be documented, so here's some pseudo-code:
169 * bool unqalified_is_same(lhs, rhs)
171 * return remove_cv(lhs) == remove_cv(rhs);
174 * mem_fn make_mem_fn_seq_getter(b, cl, T2, T3)
176 * if (b) //b means, that T2 is another version of cl, i.e. qualified
177 * return get_mem_fn_type(T2, T3);
178 * else //means that T2 is a function.
179 * return get_mem_fn_type(cl, T2);
182 * sequence make_mem_fn_seq(type cl, type T2, type T3, types...)
184 * mem_fn = make_mem_fn_seq_getter(
185 * unqalified_is_same(cl, T2), cl, T2, T3);
187 * next = unqalified_is_same(cl, T2) ?
188 * make_mem_fn_seq(T2, types...) //because: T2 is another version of cl, hence i use this. T3 was already consumed.
190 * make_mem_fn_seq(Class, T3, types...) //because: T2 was a function, hence it is consumed and class remains unchanged.
192 * return push_front(mem_fn, next) ;
199 template<class T, class U, class ...Args>
200 struct is_mem_fn_seq_impl
202 typedef typename boost::conditional<
203 boost::is_function<U>::value || boost::dll::experimental::detail::unqalified_is_same<T, U>::value,
204 typename is_mem_fn_seq_impl<T, Args...>::type,
205 boost::false_type>::type type;
208 template<class T, class U>
209 struct is_mem_fn_seq_impl<T, U>
211 typedef typename boost::conditional<
212 boost::is_function<U>::value && boost::is_object<T>::value,
213 boost::true_type, boost::false_type>::type type;
216 template<class T, class U, class Last>
217 struct is_mem_fn_seq_impl<T, U, Last>
219 typedef typename boost::conditional<
220 (boost::is_function<U>::value || boost::dll::experimental::detail::unqalified_is_same<T, U>::value)
221 && boost::is_function<Last>::value,
222 boost::true_type, boost::false_type>::type type;
225 template<class T> struct is_mem_fn_seq : boost::false_type {};
227 //If only two arguments are provided at all.
228 template<class T, class U>
229 struct is_mem_fn_seq<sequence<T, U>> : boost::conditional<
230 boost::is_object<T>::value && boost::is_function<U>::value,
231 boost::true_type, boost::false_type>::type
236 template<class T, class Func, class ...Args>
237 struct is_mem_fn_seq<sequence<T, Func, Args...>> :
239 boost::is_class<T>::value && boost::is_function<Func>::value,
240 typename is_mem_fn_seq_impl<T, Args...>::type,
241 boost::false_type>::type {};
244 /* ********************************** mem fn sequence tuple ******************************/
246 /* A tuple of member functions
247 * Unlike for plain functions a sequence here might contain classes as well as functions.
249 template <class ...Ts>
252 template <class Class, class Return, class...Args, class T2, class ...Ts>
253 struct mem_fn_tuple<mem_fn_def<Class, Return(Args...)>, T2, Ts...> : mem_fn_tuple<T2, Ts...>
255 typedef typename boost::dll::detail::get_mem_fn_type<Class, Return(Args...)>::mem_fn mem_fn;
257 constexpr mem_fn_tuple(mem_fn f, typename T2::mem_fn t2, typename Ts::mem_fn ... ts)
258 : mem_fn_tuple<T2, Ts...>(t2, ts...), _f(f) {};
261 Return operator()(Class* const cl, Args...args)
263 return (cl->*_f)(static_cast<Args>(args)...);
265 using mem_fn_tuple<T2, Ts...>::operator();
269 template <class Class, class Return, class...Args>
270 struct mem_fn_tuple<mem_fn_def<Class, Return(Args...)>>
272 typedef typename boost::dll::detail::get_mem_fn_type<Class, Return(Args...)>::mem_fn mem_fn;
274 constexpr mem_fn_tuple(mem_fn f) : _f(f) {};
277 Return operator()(Class * const cl, Args...args)
279 return (cl->*_f)(static_cast<Args>(args)...);
284 #endif /* BOOST_DLL_DETAIL_IMPORT_MANGLED_HELPERS_HPP_ */