1 #ifndef BOOST_BIND_STORAGE_HPP_INCLUDED
2 #define BOOST_BIND_STORAGE_HPP_INCLUDED
4 // MS compatible compilers support #pragma once
6 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
13 // boost/bind.hpp support header, optimized storage
15 // Copyright (c) 2006 Peter Dimov
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
21 // See http://www.boost.org/libs/bind/bind.html for documentation.
24 #include <boost/config.hpp>
25 #include <boost/bind/arg.hpp>
28 # pragma warning(push)
29 # pragma warning(disable: 4512) // assignment operator could not be generated
40 template<class A1
> struct storage1
42 explicit storage1( A1 a1
): a1_( a1
) {}
44 template<class V
> void accept(V
& v
) const
46 BOOST_BIND_VISIT_EACH(v
, a1_
, 0);
52 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( __BORLANDC__ )
54 template<int I
> struct storage1
< boost::arg
<I
> >
56 explicit storage1( boost::arg
<I
> ) {}
58 template<class V
> void accept(V
&) const { }
60 static boost::arg
<I
> a1_() { return boost::arg
<I
>(); }
63 template<int I
> struct storage1
< boost::arg
<I
> (*) () >
65 explicit storage1( boost::arg
<I
> (*) () ) {}
67 template<class V
> void accept(V
&) const { }
69 static boost::arg
<I
> a1_() { return boost::arg
<I
>(); }
76 template<class A1
, class A2
> struct storage2
: public storage1
<A1
>
78 typedef storage1
<A1
> inherited
;
80 storage2( A1 a1
, A2 a2
): storage1
<A1
>( a1
), a2_( a2
) {}
82 template<class V
> void accept(V
& v
) const
85 BOOST_BIND_VISIT_EACH(v
, a2_
, 0);
91 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
93 template<class A1
, int I
> struct storage2
< A1
, boost::arg
<I
> >: public storage1
<A1
>
95 typedef storage1
<A1
> inherited
;
97 storage2( A1 a1
, boost::arg
<I
> ): storage1
<A1
>( a1
) {}
99 template<class V
> void accept(V
& v
) const
101 inherited::accept(v
);
104 static boost::arg
<I
> a2_() { return boost::arg
<I
>(); }
107 template<class A1
, int I
> struct storage2
< A1
, boost::arg
<I
> (*) () >: public storage1
<A1
>
109 typedef storage1
<A1
> inherited
;
111 storage2( A1 a1
, boost::arg
<I
> (*) () ): storage1
<A1
>( a1
) {}
113 template<class V
> void accept(V
& v
) const
115 inherited::accept(v
);
118 static boost::arg
<I
> a2_() { return boost::arg
<I
>(); }
125 template<class A1
, class A2
, class A3
> struct storage3
: public storage2
< A1
, A2
>
127 typedef storage2
<A1
, A2
> inherited
;
129 storage3( A1 a1
, A2 a2
, A3 a3
): storage2
<A1
, A2
>( a1
, a2
), a3_( a3
) {}
131 template<class V
> void accept(V
& v
) const
133 inherited::accept(v
);
134 BOOST_BIND_VISIT_EACH(v
, a3_
, 0);
140 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
142 template<class A1
, class A2
, int I
> struct storage3
< A1
, A2
, boost::arg
<I
> >: public storage2
< A1
, A2
>
144 typedef storage2
<A1
, A2
> inherited
;
146 storage3( A1 a1
, A2 a2
, boost::arg
<I
> ): storage2
<A1
, A2
>( a1
, a2
) {}
148 template<class V
> void accept(V
& v
) const
150 inherited::accept(v
);
153 static boost::arg
<I
> a3_() { return boost::arg
<I
>(); }
156 template<class A1
, class A2
, int I
> struct storage3
< A1
, A2
, boost::arg
<I
> (*) () >: public storage2
< A1
, A2
>
158 typedef storage2
<A1
, A2
> inherited
;
160 storage3( A1 a1
, A2 a2
, boost::arg
<I
> (*) () ): storage2
<A1
, A2
>( a1
, a2
) {}
162 template<class V
> void accept(V
& v
) const
164 inherited::accept(v
);
167 static boost::arg
<I
> a3_() { return boost::arg
<I
>(); }
174 template<class A1
, class A2
, class A3
, class A4
> struct storage4
: public storage3
< A1
, A2
, A3
>
176 typedef storage3
<A1
, A2
, A3
> inherited
;
178 storage4( A1 a1
, A2 a2
, A3 a3
, A4 a4
): storage3
<A1
, A2
, A3
>( a1
, a2
, a3
), a4_( a4
) {}
180 template<class V
> void accept(V
& v
) const
182 inherited::accept(v
);
183 BOOST_BIND_VISIT_EACH(v
, a4_
, 0);
189 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
191 template<class A1
, class A2
, class A3
, int I
> struct storage4
< A1
, A2
, A3
, boost::arg
<I
> >: public storage3
< A1
, A2
, A3
>
193 typedef storage3
<A1
, A2
, A3
> inherited
;
195 storage4( A1 a1
, A2 a2
, A3 a3
, boost::arg
<I
> ): storage3
<A1
, A2
, A3
>( a1
, a2
, a3
) {}
197 template<class V
> void accept(V
& v
) const
199 inherited::accept(v
);
202 static boost::arg
<I
> a4_() { return boost::arg
<I
>(); }
205 template<class A1
, class A2
, class A3
, int I
> struct storage4
< A1
, A2
, A3
, boost::arg
<I
> (*) () >: public storage3
< A1
, A2
, A3
>
207 typedef storage3
<A1
, A2
, A3
> inherited
;
209 storage4( A1 a1
, A2 a2
, A3 a3
, boost::arg
<I
> (*) () ): storage3
<A1
, A2
, A3
>( a1
, a2
, a3
) {}
211 template<class V
> void accept(V
& v
) const
213 inherited::accept(v
);
216 static boost::arg
<I
> a4_() { return boost::arg
<I
>(); }
223 template<class A1
, class A2
, class A3
, class A4
, class A5
> struct storage5
: public storage4
< A1
, A2
, A3
, A4
>
225 typedef storage4
<A1
, A2
, A3
, A4
> inherited
;
227 storage5( A1 a1
, A2 a2
, A3 a3
, A4 a4
, A5 a5
): storage4
<A1
, A2
, A3
, A4
>( a1
, a2
, a3
, a4
), a5_( a5
) {}
229 template<class V
> void accept(V
& v
) const
231 inherited::accept(v
);
232 BOOST_BIND_VISIT_EACH(v
, a5_
, 0);
238 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
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
>
242 typedef storage4
<A1
, A2
, A3
, A4
> inherited
;
244 storage5( A1 a1
, A2 a2
, A3 a3
, A4 a4
, boost::arg
<I
> ): storage4
<A1
, A2
, A3
, A4
>( a1
, a2
, a3
, a4
) {}
246 template<class V
> void accept(V
& v
) const
248 inherited::accept(v
);
251 static boost::arg
<I
> a5_() { return boost::arg
<I
>(); }
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
>
256 typedef storage4
<A1
, A2
, A3
, A4
> inherited
;
258 storage5( A1 a1
, A2 a2
, A3 a3
, A4 a4
, boost::arg
<I
> (*) () ): storage4
<A1
, A2
, A3
, A4
>( a1
, a2
, a3
, a4
) {}
260 template<class V
> void accept(V
& v
) const
262 inherited::accept(v
);
265 static boost::arg
<I
> a5_() { return boost::arg
<I
>(); }
272 template<class A1
, class A2
, class A3
, class A4
, class A5
, class A6
> struct storage6
: public storage5
< A1
, A2
, A3
, A4
, A5
>
274 typedef storage5
<A1
, A2
, A3
, A4
, A5
> inherited
;
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
) {}
278 template<class V
> void accept(V
& v
) const
280 inherited::accept(v
);
281 BOOST_BIND_VISIT_EACH(v
, a6_
, 0);
287 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
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
>
291 typedef storage5
<A1
, A2
, A3
, A4
, A5
> inherited
;
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
) {}
295 template<class V
> void accept(V
& v
) const
297 inherited::accept(v
);
300 static boost::arg
<I
> a6_() { return boost::arg
<I
>(); }
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
>
305 typedef storage5
<A1
, A2
, A3
, A4
, A5
> inherited
;
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
) {}
309 template<class V
> void accept(V
& v
) const
311 inherited::accept(v
);
314 static boost::arg
<I
> a6_() { return boost::arg
<I
>(); }
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
>
323 typedef storage6
<A1
, A2
, A3
, A4
, A5
, A6
> inherited
;
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
) {}
327 template<class V
> void accept(V
& v
) const
329 inherited::accept(v
);
330 BOOST_BIND_VISIT_EACH(v
, a7_
, 0);
336 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
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
>
340 typedef storage6
<A1
, A2
, A3
, A4
, A5
, A6
> inherited
;
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
) {}
344 template<class V
> void accept(V
& v
) const
346 inherited::accept(v
);
349 static boost::arg
<I
> a7_() { return boost::arg
<I
>(); }
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
>
354 typedef storage6
<A1
, A2
, A3
, A4
, A5
, A6
> inherited
;
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
) {}
358 template<class V
> void accept(V
& v
) const
360 inherited::accept(v
);
363 static boost::arg
<I
> a7_() { return boost::arg
<I
>(); }
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
>
372 typedef storage7
<A1
, A2
, A3
, A4
, A5
, A6
, A7
> inherited
;
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
) {}
376 template<class V
> void accept(V
& v
) const
378 inherited::accept(v
);
379 BOOST_BIND_VISIT_EACH(v
, a8_
, 0);
385 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
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
>
389 typedef storage7
<A1
, A2
, A3
, A4
, A5
, A6
, A7
> inherited
;
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
) {}
393 template<class V
> void accept(V
& v
) const
395 inherited::accept(v
);
398 static boost::arg
<I
> a8_() { return boost::arg
<I
>(); }
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
>
403 typedef storage7
<A1
, A2
, A3
, A4
, A5
, A6
, A7
> inherited
;
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
) {}
407 template<class V
> void accept(V
& v
) const
409 inherited::accept(v
);
412 static boost::arg
<I
> a8_() { return boost::arg
<I
>(); }
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
>
421 typedef storage8
<A1
, A2
, A3
, A4
, A5
, A6
, A7
, A8
> inherited
;
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
) {}
425 template<class V
> void accept(V
& v
) const
427 inherited::accept(v
);
428 BOOST_BIND_VISIT_EACH(v
, a9_
, 0);
434 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
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
>
438 typedef storage8
<A1
, A2
, A3
, A4
, A5
, A6
, A7
, A8
> inherited
;
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
) {}
442 template<class V
> void accept(V
& v
) const
444 inherited::accept(v
);
447 static boost::arg
<I
> a9_() { return boost::arg
<I
>(); }
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
>
452 typedef storage8
<A1
, A2
, A3
, A4
, A5
, A6
, A7
, A8
> inherited
;
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
) {}
456 template<class V
> void accept(V
& v
) const
458 inherited::accept(v
);
461 static boost::arg
<I
> a9_() { return boost::arg
<I
>(); }
471 # pragma warning(default: 4512) // assignment operator could not be generated
472 # pragma warning(pop)
475 #endif // #ifndef BOOST_BIND_STORAGE_HPP_INCLUDED