]>
Commit | Line | Data |
---|---|---|
1 | #ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED | |
2 | #define BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED | |
3 | ||
4 | // | |
5 | // make_adaptable.hpp | |
6 | // | |
7 | // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. | |
8 | // | |
9 | // Distributed under the Boost Software License, Version 1.0. (See | |
10 | // accompanying file LICENSE_1_0.txt or copy at | |
11 | // http://www.boost.org/LICENSE_1_0.txt) | |
12 | // | |
13 | ||
14 | namespace boost | |
15 | { | |
16 | ||
17 | namespace _bi | |
18 | { | |
19 | ||
20 | template<class R, class F> class af0 | |
21 | { | |
22 | public: | |
23 | ||
24 | typedef R result_type; | |
25 | ||
26 | explicit af0(F f): f_(f) | |
27 | { | |
28 | } | |
29 | ||
30 | result_type operator()() | |
31 | { | |
32 | return f_(); | |
33 | } | |
34 | ||
35 | result_type operator()() const | |
36 | { | |
37 | return f_(); | |
38 | } | |
39 | ||
40 | private: | |
41 | ||
42 | F f_; | |
43 | }; | |
44 | ||
45 | template<class R, class A1, class F> class af1 | |
46 | { | |
47 | public: | |
48 | ||
49 | typedef R result_type; | |
50 | typedef A1 argument_type; | |
51 | typedef A1 arg1_type; | |
52 | ||
53 | explicit af1(F f): f_(f) | |
54 | { | |
55 | } | |
56 | ||
57 | result_type operator()(A1 a1) | |
58 | { | |
59 | return f_(a1); | |
60 | } | |
61 | ||
62 | result_type operator()(A1 a1) const | |
63 | { | |
64 | return f_(a1); | |
65 | } | |
66 | ||
67 | private: | |
68 | ||
69 | F f_; | |
70 | }; | |
71 | ||
72 | template<class R, class A1, class A2, class F> class af2 | |
73 | { | |
74 | public: | |
75 | ||
76 | typedef R result_type; | |
77 | typedef A1 first_argument_type; | |
78 | typedef A2 second_argument_type; | |
79 | typedef A1 arg1_type; | |
80 | typedef A2 arg2_type; | |
81 | ||
82 | explicit af2(F f): f_(f) | |
83 | { | |
84 | } | |
85 | ||
86 | result_type operator()(A1 a1, A2 a2) | |
87 | { | |
88 | return f_(a1, a2); | |
89 | } | |
90 | ||
91 | result_type operator()(A1 a1, A2 a2) const | |
92 | { | |
93 | return f_(a1, a2); | |
94 | } | |
95 | ||
96 | private: | |
97 | ||
98 | F f_; | |
99 | }; | |
100 | ||
101 | template<class R, class A1, class A2, class A3, class F> class af3 | |
102 | { | |
103 | public: | |
104 | ||
105 | typedef R result_type; | |
106 | typedef A1 arg1_type; | |
107 | typedef A2 arg2_type; | |
108 | typedef A3 arg3_type; | |
109 | ||
110 | explicit af3(F f): f_(f) | |
111 | { | |
112 | } | |
113 | ||
114 | result_type operator()(A1 a1, A2 a2, A3 a3) | |
115 | { | |
116 | return f_(a1, a2, a3); | |
117 | } | |
118 | ||
119 | result_type operator()(A1 a1, A2 a2, A3 a3) const | |
120 | { | |
121 | return f_(a1, a2, a3); | |
122 | } | |
123 | ||
124 | private: | |
125 | ||
126 | F f_; | |
127 | }; | |
128 | ||
129 | template<class R, class A1, class A2, class A3, class A4, class F> class af4 | |
130 | { | |
131 | public: | |
132 | ||
133 | typedef R result_type; | |
134 | typedef A1 arg1_type; | |
135 | typedef A2 arg2_type; | |
136 | typedef A3 arg3_type; | |
137 | typedef A4 arg4_type; | |
138 | ||
139 | explicit af4(F f): f_(f) | |
140 | { | |
141 | } | |
142 | ||
143 | result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4) | |
144 | { | |
145 | return f_(a1, a2, a3, a4); | |
146 | } | |
147 | ||
148 | result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4) const | |
149 | { | |
150 | return f_(a1, a2, a3, a4); | |
151 | } | |
152 | ||
153 | private: | |
154 | ||
155 | F f_; | |
156 | }; | |
157 | ||
158 | } // namespace _bi | |
159 | ||
160 | template<class R, class F> _bi::af0<R, F> make_adaptable(F f) | |
161 | { | |
162 | return _bi::af0<R, F>(f); | |
163 | } | |
164 | ||
165 | template<class R, class A1, class F> _bi::af1<R, A1, F> make_adaptable(F f) | |
166 | { | |
167 | return _bi::af1<R, A1, F>(f); | |
168 | } | |
169 | ||
170 | template<class R, class A1, class A2, class F> _bi::af2<R, A1, A2, F> make_adaptable(F f) | |
171 | { | |
172 | return _bi::af2<R, A1, A2, F>(f); | |
173 | } | |
174 | ||
175 | template<class R, class A1, class A2, class A3, class F> _bi::af3<R, A1, A2, A3, F> make_adaptable(F f) | |
176 | { | |
177 | return _bi::af3<R, A1, A2, A3, F>(f); | |
178 | } | |
179 | ||
180 | template<class R, class A1, class A2, class A3, class A4, class F> _bi::af4<R, A1, A2, A3, A4, F> make_adaptable(F f) | |
181 | { | |
182 | return _bi::af4<R, A1, A2, A3, A4, F>(f); | |
183 | } | |
184 | ||
185 | } // namespace boost | |
186 | ||
187 | #endif // #ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED |