Line data Source code
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 0 : 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 2394554 : 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 11972500 : template<class A1, class A2> struct storage2: public storage1<A1>
77 : {
78 : typedef storage1<A1> inherited;
79 :
80 2394554 : 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 0 : 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 9578040 : template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >
126 : {
127 : typedef storage2<A1, A2> inherited;
128 :
129 7183530 : 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 0 : 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 0 : 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 0 : 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
|
