bind_template.hpp
Go to the documentation of this file.
1 //
2 // bind/bind_template.hpp
3 //
4 // Do not include this header directly.
5 //
6 // Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
7 //
8 // Distributed under the Boost Software License, Version 1.0. (See
9 // accompanying file LICENSE_1_0.txt or copy at
10 // http://www.boost.org/LICENSE_1_0.txt)
11 //
12 // See http://www.boost.org/libs/bind/bind.html for documentation.
13 //
14 
15  typedef typename result_traits<R, F>::type result_type;
16 
17  result_type operator()()
18  {
19  list0 a;
20  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
21  }
22 
23  result_type operator()() const
24  {
25  list0 a;
26  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
27  }
28 
29  template<class A1> result_type operator()(A1 & a1)
30  {
31  list1<A1 &> a(a1);
32  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
33  }
34 
35  template<class A1> result_type operator()(A1 & a1) const
36  {
37  list1<A1 &> a(a1);
38  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
39  }
40 
41 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
42  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
43 
44  template<class A1> result_type operator()(A1 const & a1)
45  {
46  list1<A1 const &> a(a1);
47  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
48  }
49 
50  template<class A1> result_type operator()(A1 const & a1) const
51  {
52  list1<A1 const &> a(a1);
53  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
54  }
55 
56 #endif
57 
58  template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
59  {
60  list2<A1 &, A2 &> a(a1, a2);
61  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
62  }
63 
64  template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
65  {
66  list2<A1 &, A2 &> a(a1, a2);
67  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
68  }
69 
70 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
71  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
72 
73  template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
74  {
75  list2<A1 const &, A2 &> a(a1, a2);
76  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
77  }
78 
79  template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
80  {
81  list2<A1 const &, A2 &> a(a1, a2);
82  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
83  }
84 
85 
86  template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
87  {
88  list2<A1 &, A2 const &> a(a1, a2);
89  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
90  }
91 
92  template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
93  {
94  list2<A1 &, A2 const &> a(a1, a2);
95  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
96  }
97 
98 
99  template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
100  {
101  list2<A1 const &, A2 const &> a(a1, a2);
102  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
103  }
104 
105  template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
106  {
107  list2<A1 const &, A2 const &> a(a1, a2);
108  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
109  }
110 
111 #endif
112 
113  template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
114  {
115  list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
116  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
117  }
118 
119  template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
120  {
121  list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
122  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
123  }
124 
125 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
126  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
127 
128  template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
129  {
130  list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
131  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
132  }
133 
134  template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
135  {
136  list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
137  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
138  }
139 
140 #endif
141 
142  template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
143  {
144  list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
145  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
146  }
147 
148  template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
149  {
150  list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
151  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
152  }
153 
154 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
155  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
156 
157  template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
158  {
159  list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
160  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
161  }
162 
163  template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
164  {
165  list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
166  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
167  }
168 
169 #endif
170 
171  template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
172  {
173  list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
174  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
175  }
176 
177  template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
178  {
179  list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
180  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
181  }
182 
183 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
184  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
185 
186  template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
187  {
188  list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
189  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
190  }
191 
192  template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
193  {
194  list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
195  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
196  }
197 
198 #endif
199 
200  template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
201  {
202  list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
203  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
204  }
205 
206  template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
207  {
208  list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
209  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
210  }
211 
212 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
213  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
214 
215  template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
216  {
217  list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
218  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
219  }
220 
221  template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
222  {
223  list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
224  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
225  }
226 
227 #endif
228 
229  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
230  {
231  list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
232  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
233  }
234 
235  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
236  {
237  list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
238  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
239  }
240 
241 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
242  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
243 
244  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
245  {
246  list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
247  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
248  }
249 
250  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
251  {
252  list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
253  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
254  }
255 
256 #endif
257 
258  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
259  {
260  list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
261  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
262  }
263 
264  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
265  {
266  list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
267  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
268  }
269 
270 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
271  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
272 
273  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
274  {
275  list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
276  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
277  }
278 
279  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
280  {
281  list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
282  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
283  }
284 
285 #endif
286 
287  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
288  {
289  list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
290  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
291  }
292 
293  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
294  {
295  list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
296  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
297  }
298 
299 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
300  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
301 
302  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
303  {
304  list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
305  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
306  }
307 
308  template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
309  {
310  list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
311  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
312  }
313 
314 #endif
315 
316  template<class A> result_type eval(A & a)
317  {
318  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
319  }
320 
321  template<class A> result_type eval(A & a) const
322  {
323  BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
324  }
325 
326  template<class V> void accept(V & v) const
327  {
328 #if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ )
329 
330  using boost::visit_each;
331 
332 #endif
333  BOOST_BIND_VISIT_EACH(v, f_, 0);
334  l_.accept(v);
335  }
336 
337  bool compare(this_type const & rhs) const
338  {
339  return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;
340  }
341 
342 private:
343 
344  F f_;
345  L l_;
accept
void accept(V &v) const
Definition: bind_template.hpp:326
A1
A1
Definition: mem_fn_cc.hpp:35
result_type
result_traits< R, F >::type result_type
Definition: bind_template.hpp:15
A7
A7
Definition: mem_fn_cc.hpp:95
A3
A3
Definition: mem_fn_cc.hpp:55
l_
L l_
Definition: bind_template.hpp:345
A5
A5
Definition: mem_fn_cc.hpp:75
f_
F f_
Definition: bind_template.hpp:344
boost::visit_each
void visit_each(Visitor &visitor, const T &t, long)
Definition: visit_each.hpp:15
eval
result_type eval(A &a)
Definition: bind_template.hpp:316
operator()
result_type operator()()
Definition: bind_template.hpp:17
A6
A6
Definition: mem_fn_cc.hpp:85
A4
A4
Definition: mem_fn_cc.hpp:65
boost::iterators::V
V
Definition: iterator_facade.hpp:955
compare
bool compare(this_type const &rhs) const
Definition: bind_template.hpp:337
boost::_bi::ref_compare
bool ref_compare(T const &a, T const &b, long)
Definition: bind/bind.hpp:87
A2
A2
Definition: mem_fn_cc.hpp:45
BOOST_BIND_VISIT_EACH
#define BOOST_BIND_VISIT_EACH
Definition: bind/bind.hpp:44

sick_visionary_ros
Author(s): SICK AG TechSupport 3D Snapshot
autogenerated on Thu Feb 8 2024 03:38:04