test: epoc32/include/stdapis/boost/bind/storage.hpp@837f303aceeb

     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)

     7 # pragma once

     8 #endif

    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 //

    24 #include <boost/config.hpp>

    25 #include <boost/bind/arg.hpp>

    27 #ifdef BOOST_MSVC

    28 # pragma warning(push)

    29 # pragma warning(disable: 4512) // assignment operator could not be generated

    30 #endif

    32 namespace boost

    33 {

    35 namespace _bi

    36 {

    38 // 1

    40 template<class A1> struct storage1

    41 {

    42     explicit storage1( A1 a1 ): a1_( a1 ) {}

    44     template<class V> void accept(V & v) const

    45     {

    46         BOOST_BIND_VISIT_EACH(v, a1_, 0);

    47     }

    49     A1 a1_;

    50 };

    52 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( __BORLANDC__ )

    54 template<int I> struct storage1< boost::arg<I> >

    55 {

    56     explicit storage1( boost::arg<I> ) {}

    58     template<class V> void accept(V &) const { }

    60     static boost::arg<I> a1_() { return boost::arg<I>(); }

    61 };

    63 template<int I> struct storage1< boost::arg<I> (*) () >

    64 {

    65     explicit storage1( boost::arg<I> (*) () ) {}

    67     template<class V> void accept(V &) const { }

    69     static boost::arg<I> a1_() { return boost::arg<I>(); }

    70 };

    72 #endif

    74 // 2

    76 template<class A1, class A2> struct storage2: public storage1<A1>

    77 {

    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

    83     {

    84         inherited::accept(v);

    85         BOOST_BIND_VISIT_EACH(v, a2_, 0);

    86     }

    88     A2 a2_;

    89 };

    91 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )

    93 template<class A1, int I> struct storage2< A1, boost::arg<I> >: public storage1<A1>

    94 {

    95     typedef storage1<A1> inherited;

    97     storage2( A1 a1, boost::arg<I> ): storage1<A1>( a1 ) {}

    99     template<class V> void accept(V & v) const

   100     {

   101         inherited::accept(v);

   102     }

   104     static boost::arg<I> a2_() { return boost::arg<I>(); }

   105 };

   107 template<class A1, int I> struct storage2< A1, boost::arg<I> (*) () >: public storage1<A1>

   108 {

   109     typedef storage1<A1> inherited;

   111     storage2( A1 a1, boost::arg<I> (*) () ): storage1<A1>( a1 ) {}

   113     template<class V> void accept(V & v) const

   114     {

   115         inherited::accept(v);

   116     }

   118     static boost::arg<I> a2_() { return boost::arg<I>(); }

   119 };

   121 #endif

   123 // 3

   125 template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >

   126 {

   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

   132     {

   133         inherited::accept(v);

   134         BOOST_BIND_VISIT_EACH(v, a3_, 0);

   135     }

   137     A3 a3_;

   138 };

   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 >

   143 {

   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

   149     {

   150         inherited::accept(v);

   151     }

   153     static boost::arg<I> a3_() { return boost::arg<I>(); }

   154 };

   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;

   160     storage3( A1 a1, A2 a2, boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {}

   162     template<class V> void accept(V & v) const

   163     {

   164         inherited::accept(v);

   165     }

   167     static boost::arg<I> a3_() { return boost::arg<I>(); }

   168 };

   170 #endif

   172 // 4

   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;

   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

   181     {

   182         inherited::accept(v);

   183         BOOST_BIND_VISIT_EACH(v, a4_, 0);

   184     }

   186     A4 a4_;

   187 };

   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 >

   192 {

   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

   198     {

   199         inherited::accept(v);

   200     }

   202     static boost::arg<I> a4_() { return boost::arg<I>(); }

   203 };

   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;

   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

   212     {

   213         inherited::accept(v);

   214     }

   216     static boost::arg<I> a4_() { return boost::arg<I>(); }

   217 };

   219 #endif

   221 // 5

   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;

   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

   230     {

   231         inherited::accept(v);

   232         BOOST_BIND_VISIT_EACH(v, a5_, 0);

   233     }

   235     A5 a5_;

   236 };

   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 >

   241 {

   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

   247     {

   248         inherited::accept(v);

   249     }

   251     static boost::arg<I> a5_() { return boost::arg<I>(); }

   252 };

   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;

   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

   261     {

   262         inherited::accept(v);

   263     }

   265     static boost::arg<I> a5_() { return boost::arg<I>(); }

   266 };

   268 #endif

   270 // 6

   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;

   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

   279     {

   280         inherited::accept(v);

   281         BOOST_BIND_VISIT_EACH(v, a6_, 0);

   282     }

   284     A6 a6_;

   285 };

   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 >

   290 {

   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

   296     {

   297         inherited::accept(v);

   298     }

   300     static boost::arg<I> a6_() { return boost::arg<I>(); }

   301 };

   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;

   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

   310     {

   311         inherited::accept(v);

   312     }

   314     static boost::arg<I> a6_() { return boost::arg<I>(); }

   315 };

   317 #endif

   319 // 7

   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;

   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

   328     {

   329         inherited::accept(v);

   330         BOOST_BIND_VISIT_EACH(v, a7_, 0);

   331     }

   333     A7 a7_;

   334 };

   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 >

   339 {

   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

   345     {

   346         inherited::accept(v);

   347     }

   349     static boost::arg<I> a7_() { return boost::arg<I>(); }

   350 };

   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;

   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

   359     {

   360         inherited::accept(v);

   361     }

   363     static boost::arg<I> a7_() { return boost::arg<I>(); }

   364 };

   366 #endif

   368 // 8

   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;

   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

   377     {

   378         inherited::accept(v);

   379         BOOST_BIND_VISIT_EACH(v, a8_, 0);

   380     }

   382     A8 a8_;

   383 };

   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 >

   388 {

   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

   394     {

   395         inherited::accept(v);

   396     }

   398     static boost::arg<I> a8_() { return boost::arg<I>(); }

   399 };

   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;

   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

   408     {

   409         inherited::accept(v);

   410     }

   412     static boost::arg<I> a8_() { return boost::arg<I>(); }

   413 };

   415 #endif

   417 // 9

   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;

   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

   426     {

   427         inherited::accept(v);

   428         BOOST_BIND_VISIT_EACH(v, a9_, 0);

   429     }

   431     A9 a9_;

   432 };

   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 >

   437 {

   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

   443     {

   444         inherited::accept(v);

   445     }

   447     static boost::arg<I> a9_() { return boost::arg<I>(); }

   448 };

   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;

   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

   457     {

   458         inherited::accept(v);

   459     }

   461     static boost::arg<I> a9_() { return boost::arg<I>(); }

   462 };

   464 #endif

   466 } // namespace _bi

   468 } // namespace boost

   470 #ifdef BOOST_MSVC

   471 # pragma warning(default: 4512) // assignment operator could not be generated

   472 # pragma warning(pop)

   473 #endif

   475 #endif // #ifndef BOOST_BIND_STORAGE_HPP_INCLUDED

author	William Roberts <williamr@symbian.org>
	Wed, 31 Mar 2010 12:33:34 +0100
branch	Symbian3
changeset 4	837f303aceeb
permissions	-rw-r--r--