1#ifndef BOOST_BIND_MEM_FN_HPP_INCLUDED
2#define BOOST_BIND_MEM_FN_HPP_INCLUDED
3
4// MS compatible compilers support #pragma once
5
6#if defined(_MSC_VER) && (_MSC_VER >= 1020)
7# pragma once
8#endif
9
10//
11// mem_fn.hpp - a generalization of std::mem_fun[_ref]
12//
13// Copyright 2001-2005, 2024 Peter Dimov
14// Copyright 2001 David Abrahams
15//
16// Distributed under the Boost Software License, Version 1.0. (See
17// accompanying file LICENSE_1_0.txt or copy at
18// http://www.boost.org/LICENSE_1_0.txt)
19//
20// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
21//
22
23#include <boost/get_pointer.hpp>
24#include <boost/config.hpp>
25#include <boost/config/workaround.hpp>
26#include <type_traits>
27
28namespace boost
29{
30
31namespace _mfi
32{
33
34template<class T> struct remove_cvref: std::remove_cv< typename std::remove_reference<T>::type >
35{
36};
37
38template<class Pm, class R, class T, class... A> class mf
39{
40public:
41
42 typedef R result_type;
43
44private:
45
46 Pm pm_;
47
48public:
49
50 mf( Pm pm ): pm_( pm ) {}
51
52 template<class U,
53 class Ud = typename _mfi::remove_cvref<U>::type,
54 class En = typename std::enable_if<
55 std::is_same<T, Ud>::value || std::is_base_of<T, Ud>::value
56 >::type
57 >
58
59 R operator()( U&& u, A... a ) const
60 {
61 return (std::forward<U>( u ).*pm_)( std::forward<A>( a )... );
62 }
63
64 template<class U,
65 class Ud = typename _mfi::remove_cvref<U>::type,
66 class E1 = void,
67 class En = typename std::enable_if<
68 !(std::is_same<T, Ud>::value || std::is_base_of<T, Ud>::value)
69 >::type
70 >
71
72 R operator()( U&& u, A... a ) const
73 {
74 return (get_pointer( std::forward<U>( u ) )->*pm_)( std::forward<A>( a )... );
75 }
76
77 bool operator==( mf const & rhs ) const
78 {
79 return pm_ == rhs.pm_;
80 }
81
82 bool operator!=( mf const & rhs ) const
83 {
84 return pm_ != rhs.pm_;
85 }
86};
87
88} // namespace _mfi
89
90//
91
92template<class R, class T, class... A>
93auto mem_fn( R (T::*pmf) (A...) ) -> _mfi::mf<decltype(pmf), R, T, A...>
94{
95 return pmf;
96}
97
98template<class R, class T, class... A>
99auto mem_fn( R (T::*pmf) (A...) const ) -> _mfi::mf<decltype(pmf), R, T, A...>
100{
101 return pmf;
102}
103
104#if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED )
105
106template<class R, class T, class... A>
107auto mem_fn( R (T::*pmf) (A...) noexcept ) -> _mfi::mf<decltype(pmf), R, T, A...>
108{
109 return pmf;
110}
111
112template<class R, class T, class... A>
113auto mem_fn( R (T::*pmf) (A...) const noexcept ) -> _mfi::mf<decltype(pmf), R, T, A...>
114{
115 return pmf;
116}
117
118#endif // #if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED )
119
120#if defined(BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
121
122template<class R, class T, class... A>
123auto mem_fn( R (__cdecl T::*pmf) (A...) ) -> _mfi::mf<decltype(pmf), R, T, A...>
124{
125 return pmf;
126}
127
128template<class R, class T, class... A>
129auto mem_fn( R (__cdecl T::*pmf) (A...) const ) -> _mfi::mf<decltype(pmf), R, T, A...>
130{
131 return pmf;
132}
133
134#endif // #if defined(BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
135
136#if defined(BOOST_MEM_FN_ENABLE_STDCALL) && !defined(_M_X64)
137
138template<class R, class T, class... A>
139auto mem_fn( R (__stdcall T::*pmf) (A...) ) -> _mfi::mf<decltype(pmf), R, T, A...>
140{
141 return pmf;
142}
143
144template<class R, class T, class... A>
145auto mem_fn( R (__stdcall T::*pmf) (A...) const ) -> _mfi::mf<decltype(pmf), R, T, A...>
146{
147 return pmf;
148}
149
150#endif // #if defined(BOOST_MEM_FN_ENABLE_STDCALL) && !defined(_M_X64)
151
152#if defined(BOOST_MEM_FN_ENABLE_FASTCALL) && !defined(_M_X64)
153
154template<class R, class T, class... A>
155auto mem_fn( R (__fastcall T::*pmf) (A...) ) -> _mfi::mf<decltype(pmf), R, T, A...>
156{
157 return pmf;
158}
159
160template<class R, class T, class... A>
161auto mem_fn( R (__fastcall T::*pmf) (A...) const ) -> _mfi::mf<decltype(pmf), R, T, A...>
162{
163 return pmf;
164}
165
166#endif // #if defined(BOOST_MEM_FN_ENABLE_FASTCALL) && !defined(_M_X64)
167
168// data member support
169
170namespace _mfi
171{
172
173template<class R, class T> class dm
174{
175public:
176
177 typedef R const & result_type;
178 typedef T const * argument_type;
179
180private:
181
182 typedef R (T::*Pm);
183 Pm pm_;
184
185public:
186
187 dm( Pm pm ): pm_( pm ) {}
188
189 template<class U,
190 class Ud = typename _mfi::remove_cvref<U>::type,
191 class En = typename std::enable_if<
192 std::is_same<T, Ud>::value || std::is_base_of<T, Ud>::value
193 >::type
194 >
195
196 auto operator()( U&& u ) const -> decltype( std::forward<U>( u ).*pm_ )
197 {
198 return std::forward<U>( u ).*pm_;
199 }
200
201 template<class U,
202 class Ud = typename _mfi::remove_cvref<U>::type,
203 class E1 = void,
204 class En = typename std::enable_if<
205 !(std::is_same<T, Ud>::value || std::is_base_of<T, Ud>::value)
206 >::type
207 >
208
209 auto operator()( U&& u ) const -> decltype( get_pointer( std::forward<U>( u ) )->*pm_ )
210 {
211 return get_pointer( std::forward<U>( u ) )->*pm_;
212 }
213
214#if BOOST_WORKAROUND(BOOST_MSVC, < 1910)
215
216 template<class U>
217 R& operator()( U* u ) const
218 {
219 return u->*pm_;
220 }
221
222 template<class U>
223 R const& operator()( U const* u ) const
224 {
225 return u->*pm_;
226 }
227
228#endif
229
230 bool operator==( dm const & rhs ) const
231 {
232 return pm_ == rhs.pm_;
233 }
234
235 bool operator!=( dm const & rhs ) const
236 {
237 return pm_ != rhs.pm_;
238 }
239};
240
241} // namespace _mfi
242
243template<class R, class T,
244 class E = typename std::enable_if< !std::is_function<R>::value >::type
245>
246_mfi::dm<R, T> mem_fn( R T::*pm )
247{
248 return pm;
249}
250
251} // namespace boost
252
253#endif // #ifndef BOOST_BIND_MEM_FN_HPP_INCLUDED
254

source code of boost/libs/bind/include/boost/bind/mem_fn.hpp