stc/exp/ml_stc_linux_make_v1.0/include/boost/bind/storage.hpp

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