epoc32/include/stdapis/boost/bind/storage.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:33:34 +0100
branchSymbian3
changeset 4 837f303aceeb
permissions -rw-r--r--
Current Symbian^3 public API header files (from PDK 3.0.h)
This is the epoc32/include tree with the "platform" subtrees removed, and
all but a selected few mbg and rsg files removed.
     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