New URL for NEMO forge!   http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.
bind_template.hpp in vendors/XIOS/current/extern/boost/include/boost/bind – NEMO

source: vendors/XIOS/current/extern/boost/include/boost/bind/bind_template.hpp @ 3428

Last change on this file since 3428 was 3428, checked in by rblod, 12 years ago

importing initial XIOS vendor drop
File size: 13.7 KB
Line 
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
342private:
343
344    F f_;
345    L l_;
Note: See TracBrowser for help on using the repository browser.