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