]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | #ifndef BOOST_BIND_STORAGE_HPP_INCLUDED |
2 | #define BOOST_BIND_STORAGE_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 | // bind/storage.hpp | |
12 | // | |
13 | // boost/bind.hpp support header, optimized storage | |
14 | // | |
15 | // Copyright (c) 2006 Peter Dimov | |
16 | // | |
17 | // Distributed under the Boost Software License, Version 1.0. | |
18 | // See accompanying file LICENSE_1_0.txt or copy at | |
19 | // http://www.boost.org/LICENSE_1_0.txt | |
20 | // | |
21 | // See http://www.boost.org/libs/bind/bind.html for documentation. | |
22 | // | |
23 | ||
24 | #include <boost/config.hpp> | |
25 | #include <boost/bind/arg.hpp> | |
26 | ||
27 | #ifdef BOOST_MSVC | |
28 | # pragma warning(push) | |
29 | # pragma warning(disable: 4512) // assignment operator could not be generated | |
30 | #endif | |
31 | ||
32 | namespace boost | |
33 | { | |
34 | ||
35 | namespace _bi | |
36 | { | |
37 | ||
38 | // 1 | |
39 | ||
40 | template<class A1> struct storage1 | |
41 | { | |
42 | explicit storage1( A1 a1 ): a1_( a1 ) {} | |
43 | ||
44 | template<class V> void accept(V & v) const | |
45 | { | |
46 | BOOST_BIND_VISIT_EACH(v, a1_, 0); | |
47 | } | |
48 | ||
49 | A1 a1_; | |
50 | }; | |
51 | ||
52 | #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( __BORLANDC__ ) | |
53 | ||
54 | template<int I> struct storage1< boost::arg<I> > | |
55 | { | |
56 | explicit storage1( boost::arg<I> ) {} | |
57 | ||
58 | template<class V> void accept(V &) const { } | |
59 | ||
60 | static boost::arg<I> a1_() { return boost::arg<I>(); } | |
61 | }; | |
62 | ||
63 | template<int I> struct storage1< boost::arg<I> (*) () > | |
64 | { | |
65 | explicit storage1( boost::arg<I> (*) () ) {} | |
66 | ||
67 | template<class V> void accept(V &) const { } | |
68 | ||
69 | static boost::arg<I> a1_() { return boost::arg<I>(); } | |
70 | }; | |
71 | ||
72 | #endif | |
73 | ||
74 | // 2 | |
75 | ||
76 | template<class A1, class A2> struct storage2: public storage1<A1> | |
77 | { | |
78 | typedef storage1<A1> inherited; | |
79 | ||
80 | storage2( A1 a1, A2 a2 ): storage1<A1>( a1 ), a2_( a2 ) {} | |
81 | ||
82 | template<class V> void accept(V & v) const | |
83 | { | |
84 | inherited::accept(v); | |
85 | BOOST_BIND_VISIT_EACH(v, a2_, 0); | |
86 | } | |
87 | ||
88 | A2 a2_; | |
89 | }; | |
90 | ||
91 | #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) | |
92 | ||
93 | template<class A1, int I> struct storage2< A1, boost::arg<I> >: public storage1<A1> | |
94 | { | |
95 | typedef storage1<A1> inherited; | |
96 | ||
97 | storage2( A1 a1, boost::arg<I> ): storage1<A1>( a1 ) {} | |
98 | ||
99 | template<class V> void accept(V & v) const | |
100 | { | |
101 | inherited::accept(v); | |
102 | } | |
103 | ||
104 | static boost::arg<I> a2_() { return boost::arg<I>(); } | |
105 | }; | |
106 | ||
107 | template<class A1, int I> struct storage2< A1, boost::arg<I> (*) () >: public storage1<A1> | |
108 | { | |
109 | typedef storage1<A1> inherited; | |
110 | ||
111 | storage2( A1 a1, boost::arg<I> (*) () ): storage1<A1>( a1 ) {} | |
112 | ||
113 | template<class V> void accept(V & v) const | |
114 | { | |
115 | inherited::accept(v); | |
116 | } | |
117 | ||
118 | static boost::arg<I> a2_() { return boost::arg<I>(); } | |
119 | }; | |
120 | ||
121 | #endif | |
122 | ||
123 | // 3 | |
124 | ||
125 | template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 > | |
126 | { | |
127 | typedef storage2<A1, A2> inherited; | |
128 | ||
129 | storage3( A1 a1, A2 a2, A3 a3 ): storage2<A1, A2>( a1, a2 ), a3_( a3 ) {} | |
130 | ||
131 | template<class V> void accept(V & v) const | |
132 | { | |
133 | inherited::accept(v); | |
134 | BOOST_BIND_VISIT_EACH(v, a3_, 0); | |
135 | } | |
136 | ||
137 | A3 a3_; | |
138 | }; | |
139 | ||
140 | #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) | |
141 | ||
142 | template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> >: public storage2< A1, A2 > | |
143 | { | |
144 | typedef storage2<A1, A2> inherited; | |
145 | ||
146 | storage3( A1 a1, A2 a2, boost::arg<I> ): storage2<A1, A2>( a1, a2 ) {} | |
147 | ||
148 | template<class V> void accept(V & v) const | |
149 | { | |
150 | inherited::accept(v); | |
151 | } | |
152 | ||
153 | static boost::arg<I> a3_() { return boost::arg<I>(); } | |
154 | }; | |
155 | ||
156 | template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> (*) () >: public storage2< A1, A2 > | |
157 | { | |
158 | typedef storage2<A1, A2> inherited; | |
159 | ||
160 | storage3( A1 a1, A2 a2, boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {} | |
161 | ||
162 | template<class V> void accept(V & v) const | |
163 | { | |
164 | inherited::accept(v); | |
165 | } | |
166 | ||
167 | static boost::arg<I> a3_() { return boost::arg<I>(); } | |
168 | }; | |
169 | ||
170 | #endif | |
171 | ||
172 | // 4 | |
173 | ||
174 | template<class A1, class A2, class A3, class A4> struct storage4: public storage3< A1, A2, A3 > | |
175 | { | |
176 | typedef storage3<A1, A2, A3> inherited; | |
177 | ||
178 | storage4( A1 a1, A2 a2, A3 a3, A4 a4 ): storage3<A1, A2, A3>( a1, a2, a3 ), a4_( a4 ) {} | |
179 | ||
180 | template<class V> void accept(V & v) const | |
181 | { | |
182 | inherited::accept(v); | |
183 | BOOST_BIND_VISIT_EACH(v, a4_, 0); | |
184 | } | |
185 | ||
186 | A4 a4_; | |
187 | }; | |
188 | ||
189 | #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) | |
190 | ||
191 | template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> >: public storage3< A1, A2, A3 > | |
192 | { | |
193 | typedef storage3<A1, A2, A3> inherited; | |
194 | ||
195 | storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {} | |
196 | ||
197 | template<class V> void accept(V & v) const | |
198 | { | |
199 | inherited::accept(v); | |
200 | } | |
201 | ||
202 | static boost::arg<I> a4_() { return boost::arg<I>(); } | |
203 | }; | |
204 | ||
205 | template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> (*) () >: public storage3< A1, A2, A3 > | |
206 | { | |
207 | typedef storage3<A1, A2, A3> inherited; | |
208 | ||
209 | storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {} | |
210 | ||
211 | template<class V> void accept(V & v) const | |
212 | { | |
213 | inherited::accept(v); | |
214 | } | |
215 | ||
216 | static boost::arg<I> a4_() { return boost::arg<I>(); } | |
217 | }; | |
218 | ||
219 | #endif | |
220 | ||
221 | // 5 | |
222 | ||
223 | template<class A1, class A2, class A3, class A4, class A5> struct storage5: public storage4< A1, A2, A3, A4 > | |
224 | { | |
225 | typedef storage4<A1, A2, A3, A4> inherited; | |
226 | ||
227 | storage5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ), a5_( a5 ) {} | |
228 | ||
229 | template<class V> void accept(V & v) const | |
230 | { | |
231 | inherited::accept(v); | |
232 | BOOST_BIND_VISIT_EACH(v, a5_, 0); | |
233 | } | |
234 | ||
235 | A5 a5_; | |
236 | }; | |
237 | ||
238 | #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) | |
239 | ||
240 | template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> >: public storage4< A1, A2, A3, A4 > | |
241 | { | |
242 | typedef storage4<A1, A2, A3, A4> inherited; | |
243 | ||
244 | storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {} | |
245 | ||
246 | template<class V> void accept(V & v) const | |
247 | { | |
248 | inherited::accept(v); | |
249 | } | |
250 | ||
251 | static boost::arg<I> a5_() { return boost::arg<I>(); } | |
252 | }; | |
253 | ||
254 | template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> (*) () >: public storage4< A1, A2, A3, A4 > | |
255 | { | |
256 | typedef storage4<A1, A2, A3, A4> inherited; | |
257 | ||
258 | storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {} | |
259 | ||
260 | template<class V> void accept(V & v) const | |
261 | { | |
262 | inherited::accept(v); | |
263 | } | |
264 | ||
265 | static boost::arg<I> a5_() { return boost::arg<I>(); } | |
266 | }; | |
267 | ||
268 | #endif | |
269 | ||
270 | // 6 | |
271 | ||
272 | template<class A1, class A2, class A3, class A4, class A5, class A6> struct storage6: public storage5< A1, A2, A3, A4, A5 > | |
273 | { | |
274 | typedef storage5<A1, A2, A3, A4, A5> inherited; | |
275 | ||
276 | storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ), a6_( a6 ) {} | |
277 | ||
278 | template<class V> void accept(V & v) const | |
279 | { | |
280 | inherited::accept(v); | |
281 | BOOST_BIND_VISIT_EACH(v, a6_, 0); | |
282 | } | |
283 | ||
284 | A6 a6_; | |
285 | }; | |
286 | ||
287 | #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) | |
288 | ||
289 | template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> >: public storage5< A1, A2, A3, A4, A5 > | |
290 | { | |
291 | typedef storage5<A1, A2, A3, A4, A5> inherited; | |
292 | ||
293 | storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {} | |
294 | ||
295 | template<class V> void accept(V & v) const | |
296 | { | |
297 | inherited::accept(v); | |
298 | } | |
299 | ||
300 | static boost::arg<I> a6_() { return boost::arg<I>(); } | |
301 | }; | |
302 | ||
303 | template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> (*) () >: public storage5< A1, A2, A3, A4, A5 > | |
304 | { | |
305 | typedef storage5<A1, A2, A3, A4, A5> inherited; | |
306 | ||
307 | storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {} | |
308 | ||
309 | template<class V> void accept(V & v) const | |
310 | { | |
311 | inherited::accept(v); | |
312 | } | |
313 | ||
314 | static boost::arg<I> a6_() { return boost::arg<I>(); } | |
315 | }; | |
316 | ||
317 | #endif | |
318 | ||
319 | // 7 | |
320 | ||
321 | template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct storage7: public storage6< A1, A2, A3, A4, A5, A6 > | |
322 | { | |
323 | typedef storage6<A1, A2, A3, A4, A5, A6> inherited; | |
324 | ||
325 | storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ), a7_( a7 ) {} | |
326 | ||
327 | template<class V> void accept(V & v) const | |
328 | { | |
329 | inherited::accept(v); | |
330 | BOOST_BIND_VISIT_EACH(v, a7_, 0); | |
331 | } | |
332 | ||
333 | A7 a7_; | |
334 | }; | |
335 | ||
336 | #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) | |
337 | ||
338 | template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 > | |
339 | { | |
340 | typedef storage6<A1, A2, A3, A4, A5, A6> inherited; | |
341 | ||
342 | storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {} | |
343 | ||
344 | template<class V> void accept(V & v) const | |
345 | { | |
346 | inherited::accept(v); | |
347 | } | |
348 | ||
349 | static boost::arg<I> a7_() { return boost::arg<I>(); } | |
350 | }; | |
351 | ||
352 | template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 > | |
353 | { | |
354 | typedef storage6<A1, A2, A3, A4, A5, A6> inherited; | |
355 | ||
356 | storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {} | |
357 | ||
358 | template<class V> void accept(V & v) const | |
359 | { | |
360 | inherited::accept(v); | |
361 | } | |
362 | ||
363 | static boost::arg<I> a7_() { return boost::arg<I>(); } | |
364 | }; | |
365 | ||
366 | #endif | |
367 | ||
368 | // 8 | |
369 | ||
370 | template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct storage8: public storage7< A1, A2, A3, A4, A5, A6, A7 > | |
371 | { | |
372 | typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited; | |
373 | ||
374 | storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ), a8_( a8 ) {} | |
375 | ||
376 | template<class V> void accept(V & v) const | |
377 | { | |
378 | inherited::accept(v); | |
379 | BOOST_BIND_VISIT_EACH(v, a8_, 0); | |
380 | } | |
381 | ||
382 | A8 a8_; | |
383 | }; | |
384 | ||
385 | #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) | |
386 | ||
387 | template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 > | |
388 | { | |
389 | typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited; | |
390 | ||
391 | storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {} | |
392 | ||
393 | template<class V> void accept(V & v) const | |
394 | { | |
395 | inherited::accept(v); | |
396 | } | |
397 | ||
398 | static boost::arg<I> a8_() { return boost::arg<I>(); } | |
399 | }; | |
400 | ||
401 | template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 > | |
402 | { | |
403 | typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited; | |
404 | ||
405 | storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> (*) () ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {} | |
406 | ||
407 | template<class V> void accept(V & v) const | |
408 | { | |
409 | inherited::accept(v); | |
410 | } | |
411 | ||
412 | static boost::arg<I> a8_() { return boost::arg<I>(); } | |
413 | }; | |
414 | ||
415 | #endif | |
416 | ||
417 | // 9 | |
418 | ||
419 | template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct storage9: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 > | |
420 | { | |
421 | typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited; | |
422 | ||
423 | storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ), a9_( a9 ) {} | |
424 | ||
425 | template<class V> void accept(V & v) const | |
426 | { | |
427 | inherited::accept(v); | |
428 | BOOST_BIND_VISIT_EACH(v, a9_, 0); | |
429 | } | |
430 | ||
431 | A9 a9_; | |
432 | }; | |
433 | ||
434 | #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) | |
435 | ||
436 | template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 > | |
437 | { | |
438 | typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited; | |
439 | ||
440 | storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {} | |
441 | ||
442 | template<class V> void accept(V & v) const | |
443 | { | |
444 | inherited::accept(v); | |
445 | } | |
446 | ||
447 | static boost::arg<I> a9_() { return boost::arg<I>(); } | |
448 | }; | |
449 | ||
450 | template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 > | |
451 | { | |
452 | typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited; | |
453 | ||
454 | storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> (*) () ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {} | |
455 | ||
456 | template<class V> void accept(V & v) const | |
457 | { | |
458 | inherited::accept(v); | |
459 | } | |
460 | ||
461 | static boost::arg<I> a9_() { return boost::arg<I>(); } | |
462 | }; | |
463 | ||
464 | #endif | |
465 | ||
466 | } // namespace _bi | |
467 | ||
468 | } // namespace boost | |
469 | ||
470 | #ifdef BOOST_MSVC | |
471 | # pragma warning(default: 4512) // assignment operator could not be generated | |
472 | # pragma warning(pop) | |
473 | #endif | |
474 | ||
475 | #endif // #ifndef BOOST_BIND_STORAGE_HPP_INCLUDED |