1//////////////////////////////////////////////////////////////////////////////
2//
3// (C) Copyright Pablo Halpern 2009. Distributed under the Boost
4// Software License, Version 1.0. (See accompanying file
5// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6//
7//////////////////////////////////////////////////////////////////////////////
8//
9// (C) Copyright Ion Gaztanaga 2011-2014. Distributed under the Boost
10// Software License, Version 1.0. (See accompanying file
11// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
12//
13// See http://www.boost.org/libs/intrusive for documentation.
14//
15//////////////////////////////////////////////////////////////////////////////
16
17#ifndef BOOST_INTRUSIVE_POINTER_TRAITS_HPP
18#define BOOST_INTRUSIVE_POINTER_TRAITS_HPP
19
20#include <boost/intrusive/detail/config_begin.hpp>
21#include <boost/intrusive/detail/workaround.hpp>
22#include <boost/intrusive/pointer_rebind.hpp>
23#include <boost/move/detail/pointer_element.hpp>
24#include <boost/intrusive/detail/mpl.hpp>
25#include <cstddef>
26
27#if defined(BOOST_HAS_PRAGMA_ONCE)
28# pragma once
29#endif
30
31namespace boost {
32namespace intrusive {
33namespace detail {
34
35#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1310)
36BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_pointer_to, pointer_to)
37BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_dynamic_cast_from, dynamic_cast_from)
38BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_static_cast_from, static_cast_from)
39BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_const_cast_from, const_cast_from)
40#else
41BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_pointer_to, pointer_to)
42BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_dynamic_cast_from, dynamic_cast_from)
43BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_static_cast_from, static_cast_from)
44BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_const_cast_from, const_cast_from)
45#endif
46
47BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(element_type)
48BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type)
49BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference)
50BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(value_traits_ptr)
51
52} //namespace detail {
53
54
55//! pointer_traits is the implementation of C++11 std::pointer_traits class with some
56//! extensions like castings.
57//!
58//! pointer_traits supplies a uniform interface to certain attributes of pointer-like types.
59//!
60//! <b>Note</b>: When defining a custom family of pointers or references to be used with BI
61//! library, make sure the public static conversion functions accessed through
62//! the `pointer_traits` interface (`*_cast_from` and `pointer_to`) can
63//! properly convert between const and nonconst referred member types
64//! <b>without the use of implicit constructor calls</b>. It is suggested these
65//! conversions be implemented as function templates, where the template
66//! argument is the type of the object being converted from.
67template <typename Ptr>
68struct pointer_traits
69{
70 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
71 //!The pointer type
72 //!queried by this pointer_traits instantiation
73 typedef Ptr pointer;
74
75 //!Ptr::element_type if such a type exists; otherwise, T if Ptr is a class
76 //!template instantiation of the form SomePointer<T, Args>, where Args is zero or
77 //!more type arguments ; otherwise , the specialization is ill-formed.
78 typedef unspecified_type element_type;
79
80 //!Ptr::difference_type if such a type exists; otherwise,
81 //!std::ptrdiff_t.
82 typedef unspecified_type difference_type;
83
84 //!Ptr::rebind<U> if such a type exists; otherwise, SomePointer<U, Args> if Ptr is
85 //!a class template instantiation of the form SomePointer<T, Args>, where Args is zero or
86 //!more type arguments ; otherwise, the instantiation of rebind is ill-formed.
87 //!
88 //!For portable code for C++03 and C++11, <pre>typename rebind_pointer<U>::type</pre>
89 //!shall be used instead of rebind<U> to obtain a pointer to U.
90 template <class U> using rebind = unspecified;
91
92 //!Ptr::reference if such a type exists (non-standard extension); otherwise, element_type &
93 //!
94 typedef unspecified_type reference;
95 #else
96 typedef Ptr pointer;
97 //
98 typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT
99 ( boost::intrusive::detail::, Ptr, element_type
100 , boost::movelib::detail::first_param<Ptr>) element_type;
101 //
102 typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
103 (boost::intrusive::detail::, Ptr, difference_type, std::ptrdiff_t) difference_type;
104
105 typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
106 (boost::intrusive::detail::, Ptr, reference, typename boost::intrusive::detail::unvoid_ref<element_type>::type) reference;
107 //
108 template <class U> struct rebind_pointer
109 {
110 typedef typename boost::intrusive::pointer_rebind<Ptr, U>::type type;
111 };
112
113 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
114 template <class U> using rebind = typename boost::intrusive::pointer_rebind<Ptr, U>::type;
115 #endif
116 #endif //#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
117
118 //! <b>Remark</b>: If element_type is (possibly cv-qualified) void, r type is unspecified; otherwise,
119 //! it is element_type &.
120 //!
121 //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling Ptr::pointer_to(reference).
122 //! Non-standard extension: If such function does not exist, returns pointer(addressof(r));
123 //!
124 //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
125 //! <code>pointer_to</code> is checked.
126 static pointer pointer_to(reference r)
127 {
128 //Non-standard extension, it does not require Ptr::pointer_to. If not present
129 //tries to converts &r to pointer.
130 const bool value = boost::intrusive::detail::
131 has_member_function_callable_with_pointer_to
132 <Ptr, Ptr (*)(reference)>::value;
133 boost::intrusive::detail::bool_<value> flag;
134 return pointer_traits::priv_pointer_to(flag, r);
135 }
136
137 //! <b>Remark</b>: Non-standard extension.
138 //!
139 //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling the static template function
140 //! Ptr::static_cast_from(UPpr/const UPpr &).
141 //! If such function does not exist, returns pointer_to(static_cast<element_type&>(*uptr))
142 //!
143 //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
144 //! <code>static_cast_from</code> is checked.
145 template<class UPtr>
146 static pointer static_cast_from(const UPtr &uptr)
147 {
148 typedef const UPtr &RefArg;
149 const bool value = boost::intrusive::detail::
150 has_member_function_callable_with_static_cast_from
151 <pointer, pointer(*)(RefArg)>::value
152 || boost::intrusive::detail::
153 has_member_function_callable_with_static_cast_from
154 <pointer, pointer(*)(UPtr)>::value;
155 return pointer_traits::priv_static_cast_from(boost::intrusive::detail::bool_<value>(), uptr);
156 }
157
158 //! <b>Remark</b>: Non-standard extension.
159 //!
160 //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling the static template function
161 //! Ptr::const_cast_from<UPtr>(UPpr/const UPpr &).
162 //! If such function does not exist, returns pointer_to(const_cast<element_type&>(*uptr))
163 //!
164 //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
165 //! <code>const_cast_from</code> is checked.
166 template<class UPtr>
167 static pointer const_cast_from(const UPtr &uptr)
168 {
169 typedef const UPtr &RefArg;
170 const bool value = boost::intrusive::detail::
171 has_member_function_callable_with_const_cast_from
172 <pointer, pointer(*)(RefArg)>::value
173 || boost::intrusive::detail::
174 has_member_function_callable_with_const_cast_from
175 <pointer, pointer(*)(UPtr)>::value;
176 return pointer_traits::priv_const_cast_from(boost::intrusive::detail::bool_<value>(), uptr);
177 }
178
179 //! <b>Remark</b>: Non-standard extension.
180 //!
181 //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling the static template function
182 //! Ptr::dynamic_cast_from<UPtr>(UPpr/const UPpr &).
183 //! If such function does not exist, returns pointer_to(*dynamic_cast<element_type*>(&*uptr))
184 //!
185 //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
186 //! <code>dynamic_cast_from</code> is checked.
187 template<class UPtr>
188 static pointer dynamic_cast_from(const UPtr &uptr)
189 {
190 typedef const UPtr &RefArg;
191 const bool value = boost::intrusive::detail::
192 has_member_function_callable_with_dynamic_cast_from
193 <pointer, pointer(*)(RefArg)>::value
194 || boost::intrusive::detail::
195 has_member_function_callable_with_dynamic_cast_from
196 <pointer, pointer(*)(UPtr)>::value;
197 return pointer_traits::priv_dynamic_cast_from(boost::intrusive::detail::bool_<value>(), uptr);
198 }
199
200 ///@cond
201 private:
202 //priv_to_raw_pointer
203 template <class T>
204 static T* to_raw_pointer(T* p)
205 { return p; }
206
207 template <class Pointer>
208 static typename pointer_traits<Pointer>::element_type*
209 to_raw_pointer(const Pointer &p)
210 { return pointer_traits::to_raw_pointer(p.operator->()); }
211
212 //priv_pointer_to
213 static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r)
214 { return Ptr::pointer_to(r); }
215
216 static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r)
217 { return pointer(boost::intrusive::detail::addressof(r)); }
218
219 //priv_static_cast_from
220 template<class UPtr>
221 static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
222 { return Ptr::static_cast_from(uptr); }
223
224 template<class UPtr>
225 static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
226 { return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer(); }
227
228 //priv_const_cast_from
229 template<class UPtr>
230 static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
231 { return Ptr::const_cast_from(uptr); }
232
233 template<class UPtr>
234 static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
235 { return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer(); }
236
237 //priv_dynamic_cast_from
238 template<class UPtr>
239 static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
240 { return Ptr::dynamic_cast_from(uptr); }
241
242 template<class UPtr>
243 static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
244 { return uptr ? pointer_to(dynamic_cast<element_type&>(*uptr)) : pointer(); }
245 ///@endcond
246};
247
248///@cond
249
250// Remove cv qualification from Ptr parameter to pointer_traits:
251template <typename Ptr>
252struct pointer_traits<const Ptr> : pointer_traits<Ptr> {};
253template <typename Ptr>
254struct pointer_traits<volatile Ptr> : pointer_traits<Ptr> { };
255template <typename Ptr>
256struct pointer_traits<const volatile Ptr> : pointer_traits<Ptr> { };
257// Remove reference from Ptr parameter to pointer_traits:
258template <typename Ptr>
259struct pointer_traits<Ptr&> : pointer_traits<Ptr> { };
260
261///@endcond
262
263//! Specialization of pointer_traits for raw pointers
264//!
265template <typename T>
266struct pointer_traits<T*>
267{
268 typedef T element_type;
269 typedef T* pointer;
270 typedef std::ptrdiff_t difference_type;
271
272 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
273 typedef T & reference;
274 //!typedef for <pre>U *</pre>
275 //!
276 //!For portable code for C++03 and C++11, <pre>typename rebind_pointer<U>::type</pre>
277 //!shall be used instead of rebind<U> to obtain a pointer to U.
278 template <class U> using rebind = U*;
279 #else
280 typedef typename boost::intrusive::detail::unvoid_ref<element_type>::type reference;
281 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
282 template <class U> using rebind = U*;
283 #endif
284 #endif
285
286 template <class U> struct rebind_pointer
287 { typedef U* type; };
288
289 //! <b>Returns</b>: addressof(r)
290 //!
291 BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r)
292 { return boost::intrusive::detail::addressof(r); }
293
294 //! <b>Returns</b>: static_cast<pointer>(uptr)
295 //!
296 template<class U>
297 BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(U *uptr)
298 { return static_cast<pointer>(uptr); }
299
300 //! <b>Returns</b>: const_cast<pointer>(uptr)
301 //!
302 template<class U>
303 BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(U *uptr)
304 { return const_cast<pointer>(uptr); }
305
306 //! <b>Returns</b>: dynamic_cast<pointer>(uptr)
307 //!
308 template<class U>
309 BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(U *uptr)
310 { return dynamic_cast<pointer>(uptr); }
311};
312
313} //namespace container {
314} //namespace boost {
315
316#include <boost/intrusive/detail/config_end.hpp>
317
318#endif // ! defined(BOOST_INTRUSIVE_POINTER_TRAITS_HPP)
319