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

source code of include/boost/bind/storage.hpp

Morty Proxy This is a proxified and sanitized view of the page, visit original site.