ceph/src/boost/libs/bind/include/boost/bind/storage.hpp

   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