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 476
