ceph/src/boost/libs/pool/include/boost/pool/detail/pool_construct.ipp

   1 // Copyright (C) 2000 Stephen Cleary
   2 //
   3 // Distributed under the Boost Software License, Version 1.0. (See accompany-
   4 // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5 //
   6 // See http://www.boost.org for updates, documentation, and revision history.
   7
   8 // This file was AUTOMATICALLY GENERATED from "stdin"
   9 //  Do NOT include directly!
  10 //  Do NOT edit!
  11
  12 template <typename T0>
  13 element_type * construct(T0 & a0)
  14 {
  15   element_type * const ret = (malloc)();
  16   if (ret == 0)
  17     return ret;
  18   try { new (ret) element_type(a0); }
  19   catch (...) { (free)(ret); throw; }
  20   return ret;
  21 }
  22 template <typename T0>
  23 element_type * construct(const T0 & a0)
  24 {
  25   element_type * const ret = (malloc)();
  26   if (ret == 0)
  27     return ret;
  28   try { new (ret) element_type(a0); }
  29   catch (...) { (free)(ret); throw; }
  30   return ret;
  31 }
  32 template <typename T0>
  33 element_type * construct(volatile T0 & a0)
  34 {
  35   element_type * const ret = (malloc)();
  36   if (ret == 0)
  37     return ret;
  38   try { new (ret) element_type(a0); }
  39   catch (...) { (free)(ret); throw; }
  40   return ret;
  41 }
  42 template <typename T0>
  43 element_type * construct(const volatile T0 & a0)
  44 {
  45   element_type * const ret = (malloc)();
  46   if (ret == 0)
  47     return ret;
  48   try { new (ret) element_type(a0); }
  49   catch (...) { (free)(ret); throw; }
  50   return ret;
  51 }
  52 template <typename T0, typename T1>
  53 element_type * construct(T0 & a0, T1 & a1)
  54 {
  55   element_type * const ret = (malloc)();
  56   if (ret == 0)
  57     return ret;
  58   try { new (ret) element_type(a0, a1); }
  59   catch (...) { (free)(ret); throw; }
  60   return ret;
  61 }
  62 template <typename T0, typename T1>
  63 element_type * construct(const T0 & a0, T1 & a1)
  64 {
  65   element_type * const ret = (malloc)();
  66   if (ret == 0)
  67     return ret;
  68   try { new (ret) element_type(a0, a1); }
  69   catch (...) { (free)(ret); throw; }
  70   return ret;
  71 }
  72 template <typename T0, typename T1>
  73 element_type * construct(volatile T0 & a0, T1 & a1)
  74 {
  75   element_type * const ret = (malloc)();
  76   if (ret == 0)
  77     return ret;
  78   try { new (ret) element_type(a0, a1); }
  79   catch (...) { (free)(ret); throw; }
  80   return ret;
  81 }
  82 template <typename T0, typename T1>
  83 element_type * construct(const volatile T0 & a0, T1 & a1)
  84 {
  85   element_type * const ret = (malloc)();
  86   if (ret == 0)
  87     return ret;
  88   try { new (ret) element_type(a0, a1); }
  89   catch (...) { (free)(ret); throw; }
  90   return ret;
  91 }
  92 template <typename T0, typename T1>
  93 element_type * construct(T0 & a0, const T1 & a1)
  94 {
  95   element_type * const ret = (malloc)();
  96   if (ret == 0)
  97     return ret;
  98   try { new (ret) element_type(a0, a1); }
  99   catch (...) { (free)(ret); throw; }
 100   return ret;
 101 }
 102 template <typename T0, typename T1>
 103 element_type * construct(const T0 & a0, const T1 & a1)
 104 {
 105   element_type * const ret = (malloc)();
 106   if (ret == 0)
 107     return ret;
 108   try { new (ret) element_type(a0, a1); }
 109   catch (...) { (free)(ret); throw; }
 110   return ret;
 111 }
 112 template <typename T0, typename T1>
 113 element_type * construct(volatile T0 & a0, const T1 & a1)
 114 {
 115   element_type * const ret = (malloc)();
 116   if (ret == 0)
 117     return ret;
 118   try { new (ret) element_type(a0, a1); }
 119   catch (...) { (free)(ret); throw; }
 120   return ret;
 121 }
 122 template <typename T0, typename T1>
 123 element_type * construct(const volatile T0 & a0, const T1 & a1)
 124 {
 125   element_type * const ret = (malloc)();
 126   if (ret == 0)
 127     return ret;
 128   try { new (ret) element_type(a0, a1); }
 129   catch (...) { (free)(ret); throw; }
 130   return ret;
 131 }
 132 template <typename T0, typename T1>
 133 element_type * construct(T0 & a0, volatile T1 & a1)
 134 {
 135   element_type * const ret = (malloc)();
 136   if (ret == 0)
 137     return ret;
 138   try { new (ret) element_type(a0, a1); }
 139   catch (...) { (free)(ret); throw; }
 140   return ret;
 141 }
 142 template <typename T0, typename T1>
 143 element_type * construct(const T0 & a0, volatile T1 & a1)
 144 {
 145   element_type * const ret = (malloc)();
 146   if (ret == 0)
 147     return ret;
 148   try { new (ret) element_type(a0, a1); }
 149   catch (...) { (free)(ret); throw; }
 150   return ret;
 151 }
 152 template <typename T0, typename T1>
 153 element_type * construct(volatile T0 & a0, volatile T1 & a1)
 154 {
 155   element_type * const ret = (malloc)();
 156   if (ret == 0)
 157     return ret;
 158   try { new (ret) element_type(a0, a1); }
 159   catch (...) { (free)(ret); throw; }
 160   return ret;
 161 }
 162 template <typename T0, typename T1>
 163 element_type * construct(const volatile T0 & a0, volatile T1 & a1)
 164 {
 165   element_type * const ret = (malloc)();
 166   if (ret == 0)
 167     return ret;
 168   try { new (ret) element_type(a0, a1); }
 169   catch (...) { (free)(ret); throw; }
 170   return ret;
 171 }
 172 template <typename T0, typename T1>
 173 element_type * construct(T0 & a0, const volatile T1 & a1)
 174 {
 175   element_type * const ret = (malloc)();
 176   if (ret == 0)
 177     return ret;
 178   try { new (ret) element_type(a0, a1); }
 179   catch (...) { (free)(ret); throw; }
 180   return ret;
 181 }
 182 template <typename T0, typename T1>
 183 element_type * construct(const T0 & a0, const volatile T1 & a1)
 184 {
 185   element_type * const ret = (malloc)();
 186   if (ret == 0)
 187     return ret;
 188   try { new (ret) element_type(a0, a1); }
 189   catch (...) { (free)(ret); throw; }
 190   return ret;
 191 }
 192 template <typename T0, typename T1>
 193 element_type * construct(volatile T0 & a0, const volatile T1 & a1)
 194 {
 195   element_type * const ret = (malloc)();
 196   if (ret == 0)
 197     return ret;
 198   try { new (ret) element_type(a0, a1); }
 199   catch (...) { (free)(ret); throw; }
 200   return ret;
 201 }
 202 template <typename T0, typename T1>
 203 element_type * construct(const volatile T0 & a0, const volatile T1 & a1)
 204 {
 205   element_type * const ret = (malloc)();
 206   if (ret == 0)
 207     return ret;
 208   try { new (ret) element_type(a0, a1); }
 209   catch (...) { (free)(ret); throw; }
 210   return ret;
 211 }
 212 template <typename T0, typename T1, typename T2>
 213 element_type * construct(T0 & a0, T1 & a1, T2 & a2)
 214 {
 215   element_type * const ret = (malloc)();
 216   if (ret == 0)
 217     return ret;
 218   try { new (ret) element_type(a0, a1, a2); }
 219   catch (...) { (free)(ret); throw; }
 220   return ret;
 221 }
 222 template <typename T0, typename T1, typename T2>
 223 element_type * construct(const T0 & a0, T1 & a1, T2 & a2)
 224 {
 225   element_type * const ret = (malloc)();
 226   if (ret == 0)
 227     return ret;
 228   try { new (ret) element_type(a0, a1, a2); }
 229   catch (...) { (free)(ret); throw; }
 230   return ret;
 231 }
 232 template <typename T0, typename T1, typename T2>
 233 element_type * construct(volatile T0 & a0, T1 & a1, T2 & a2)
 234 {
 235   element_type * const ret = (malloc)();
 236   if (ret == 0)
 237     return ret;
 238   try { new (ret) element_type(a0, a1, a2); }
 239   catch (...) { (free)(ret); throw; }
 240   return ret;
 241 }
 242 template <typename T0, typename T1, typename T2>
 243 element_type * construct(const volatile T0 & a0, T1 & a1, T2 & a2)
 244 {
 245   element_type * const ret = (malloc)();
 246   if (ret == 0)
 247     return ret;
 248   try { new (ret) element_type(a0, a1, a2); }
 249   catch (...) { (free)(ret); throw; }
 250   return ret;
 251 }
 252 template <typename T0, typename T1, typename T2>
 253 element_type * construct(T0 & a0, const T1 & a1, T2 & a2)
 254 {
 255   element_type * const ret = (malloc)();
 256   if (ret == 0)
 257     return ret;
 258   try { new (ret) element_type(a0, a1, a2); }
 259   catch (...) { (free)(ret); throw; }
 260   return ret;
 261 }
 262 template <typename T0, typename T1, typename T2>
 263 element_type * construct(const T0 & a0, const T1 & a1, T2 & a2)
 264 {
 265   element_type * const ret = (malloc)();
 266   if (ret == 0)
 267     return ret;
 268   try { new (ret) element_type(a0, a1, a2); }
 269   catch (...) { (free)(ret); throw; }
 270   return ret;
 271 }
 272 template <typename T0, typename T1, typename T2>
 273 element_type * construct(volatile T0 & a0, const T1 & a1, T2 & a2)
 274 {
 275   element_type * const ret = (malloc)();
 276   if (ret == 0)
 277     return ret;
 278   try { new (ret) element_type(a0, a1, a2); }
 279   catch (...) { (free)(ret); throw; }
 280   return ret;
 281 }
 282 template <typename T0, typename T1, typename T2>
 283 element_type * construct(const volatile T0 & a0, const T1 & a1, T2 & a2)
 284 {
 285   element_type * const ret = (malloc)();
 286   if (ret == 0)
 287     return ret;
 288   try { new (ret) element_type(a0, a1, a2); }
 289   catch (...) { (free)(ret); throw; }
 290   return ret;
 291 }
 292 template <typename T0, typename T1, typename T2>
 293 element_type * construct(T0 & a0, volatile T1 & a1, T2 & a2)
 294 {
 295   element_type * const ret = (malloc)();
 296   if (ret == 0)
 297     return ret;
 298   try { new (ret) element_type(a0, a1, a2); }
 299   catch (...) { (free)(ret); throw; }
 300   return ret;
 301 }
 302 template <typename T0, typename T1, typename T2>
 303 element_type * construct(const T0 & a0, volatile T1 & a1, T2 & a2)
 304 {
 305   element_type * const ret = (malloc)();
 306   if (ret == 0)
 307     return ret;
 308   try { new (ret) element_type(a0, a1, a2); }
 309   catch (...) { (free)(ret); throw; }
 310   return ret;
 311 }
 312 template <typename T0, typename T1, typename T2>
 313 element_type * construct(volatile T0 & a0, volatile T1 & a1, T2 & a2)
 314 {
 315   element_type * const ret = (malloc)();
 316   if (ret == 0)
 317     return ret;
 318   try { new (ret) element_type(a0, a1, a2); }
 319   catch (...) { (free)(ret); throw; }
 320   return ret;
 321 }
 322 template <typename T0, typename T1, typename T2>
 323 element_type * construct(const volatile T0 & a0, volatile T1 & a1, T2 & a2)
 324 {
 325   element_type * const ret = (malloc)();
 326   if (ret == 0)
 327     return ret;
 328   try { new (ret) element_type(a0, a1, a2); }
 329   catch (...) { (free)(ret); throw; }
 330   return ret;
 331 }
 332 template <typename T0, typename T1, typename T2>
 333 element_type * construct(T0 & a0, const volatile T1 & a1, T2 & a2)
 334 {
 335   element_type * const ret = (malloc)();
 336   if (ret == 0)
 337     return ret;
 338   try { new (ret) element_type(a0, a1, a2); }
 339   catch (...) { (free)(ret); throw; }
 340   return ret;
 341 }
 342 template <typename T0, typename T1, typename T2>
 343 element_type * construct(const T0 & a0, const volatile T1 & a1, T2 & a2)
 344 {
 345   element_type * const ret = (malloc)();
 346   if (ret == 0)
 347     return ret;
 348   try { new (ret) element_type(a0, a1, a2); }
 349   catch (...) { (free)(ret); throw; }
 350   return ret;
 351 }
 352 template <typename T0, typename T1, typename T2>
 353 element_type * construct(volatile T0 & a0, const volatile T1 & a1, T2 & a2)
 354 {
 355   element_type * const ret = (malloc)();
 356   if (ret == 0)
 357     return ret;
 358   try { new (ret) element_type(a0, a1, a2); }
 359   catch (...) { (free)(ret); throw; }
 360   return ret;
 361 }
 362 template <typename T0, typename T1, typename T2>
 363 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, T2 & a2)
 364 {
 365   element_type * const ret = (malloc)();
 366   if (ret == 0)
 367     return ret;
 368   try { new (ret) element_type(a0, a1, a2); }
 369   catch (...) { (free)(ret); throw; }
 370   return ret;
 371 }
 372 template <typename T0, typename T1, typename T2>
 373 element_type * construct(T0 & a0, T1 & a1, const T2 & a2)
 374 {
 375   element_type * const ret = (malloc)();
 376   if (ret == 0)
 377     return ret;
 378   try { new (ret) element_type(a0, a1, a2); }
 379   catch (...) { (free)(ret); throw; }
 380   return ret;
 381 }
 382 template <typename T0, typename T1, typename T2>
 383 element_type * construct(const T0 & a0, T1 & a1, const T2 & a2)
 384 {
 385   element_type * const ret = (malloc)();
 386   if (ret == 0)
 387     return ret;
 388   try { new (ret) element_type(a0, a1, a2); }
 389   catch (...) { (free)(ret); throw; }
 390   return ret;
 391 }
 392 template <typename T0, typename T1, typename T2>
 393 element_type * construct(volatile T0 & a0, T1 & a1, const T2 & a2)
 394 {
 395   element_type * const ret = (malloc)();
 396   if (ret == 0)
 397     return ret;
 398   try { new (ret) element_type(a0, a1, a2); }
 399   catch (...) { (free)(ret); throw; }
 400   return ret;
 401 }
 402 template <typename T0, typename T1, typename T2>
 403 element_type * construct(const volatile T0 & a0, T1 & a1, const T2 & a2)
 404 {
 405   element_type * const ret = (malloc)();
 406   if (ret == 0)
 407     return ret;
 408   try { new (ret) element_type(a0, a1, a2); }
 409   catch (...) { (free)(ret); throw; }
 410   return ret;
 411 }
 412 template <typename T0, typename T1, typename T2>
 413 element_type * construct(T0 & a0, const T1 & a1, const T2 & a2)
 414 {
 415   element_type * const ret = (malloc)();
 416   if (ret == 0)
 417     return ret;
 418   try { new (ret) element_type(a0, a1, a2); }
 419   catch (...) { (free)(ret); throw; }
 420   return ret;
 421 }
 422 template <typename T0, typename T1, typename T2>
 423 element_type * construct(const T0 & a0, const T1 & a1, const T2 & a2)
 424 {
 425   element_type * const ret = (malloc)();
 426   if (ret == 0)
 427     return ret;
 428   try { new (ret) element_type(a0, a1, a2); }
 429   catch (...) { (free)(ret); throw; }
 430   return ret;
 431 }
 432 template <typename T0, typename T1, typename T2>
 433 element_type * construct(volatile T0 & a0, const T1 & a1, const T2 & a2)
 434 {
 435   element_type * const ret = (malloc)();
 436   if (ret == 0)
 437     return ret;
 438   try { new (ret) element_type(a0, a1, a2); }
 439   catch (...) { (free)(ret); throw; }
 440   return ret;
 441 }
 442 template <typename T0, typename T1, typename T2>
 443 element_type * construct(const volatile T0 & a0, const T1 & a1, const T2 & a2)
 444 {
 445   element_type * const ret = (malloc)();
 446   if (ret == 0)
 447     return ret;
 448   try { new (ret) element_type(a0, a1, a2); }
 449   catch (...) { (free)(ret); throw; }
 450   return ret;
 451 }
 452 template <typename T0, typename T1, typename T2>
 453 element_type * construct(T0 & a0, volatile T1 & a1, const T2 & a2)
 454 {
 455   element_type * const ret = (malloc)();
 456   if (ret == 0)
 457     return ret;
 458   try { new (ret) element_type(a0, a1, a2); }
 459   catch (...) { (free)(ret); throw; }
 460   return ret;
 461 }
 462 template <typename T0, typename T1, typename T2>
 463 element_type * construct(const T0 & a0, volatile T1 & a1, const T2 & a2)
 464 {
 465   element_type * const ret = (malloc)();
 466   if (ret == 0)
 467     return ret;
 468   try { new (ret) element_type(a0, a1, a2); }
 469   catch (...) { (free)(ret); throw; }
 470   return ret;
 471 }
 472 template <typename T0, typename T1, typename T2>
 473 element_type * construct(volatile T0 & a0, volatile T1 & a1, const T2 & a2)
 474 {
 475   element_type * const ret = (malloc)();
 476   if (ret == 0)
 477     return ret;
 478   try { new (ret) element_type(a0, a1, a2); }
 479   catch (...) { (free)(ret); throw; }
 480   return ret;
 481 }
 482 template <typename T0, typename T1, typename T2>
 483 element_type * construct(const volatile T0 & a0, volatile T1 & a1, const T2 & a2)
 484 {
 485   element_type * const ret = (malloc)();
 486   if (ret == 0)
 487     return ret;
 488   try { new (ret) element_type(a0, a1, a2); }
 489   catch (...) { (free)(ret); throw; }
 490   return ret;
 491 }
 492 template <typename T0, typename T1, typename T2>
 493 element_type * construct(T0 & a0, const volatile T1 & a1, const T2 & a2)
 494 {
 495   element_type * const ret = (malloc)();
 496   if (ret == 0)
 497     return ret;
 498   try { new (ret) element_type(a0, a1, a2); }
 499   catch (...) { (free)(ret); throw; }
 500   return ret;
 501 }
 502 template <typename T0, typename T1, typename T2>
 503 element_type * construct(const T0 & a0, const volatile T1 & a1, const T2 & a2)
 504 {
 505   element_type * const ret = (malloc)();
 506   if (ret == 0)
 507     return ret;
 508   try { new (ret) element_type(a0, a1, a2); }
 509   catch (...) { (free)(ret); throw; }
 510   return ret;
 511 }
 512 template <typename T0, typename T1, typename T2>
 513 element_type * construct(volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
 514 {
 515   element_type * const ret = (malloc)();
 516   if (ret == 0)
 517     return ret;
 518   try { new (ret) element_type(a0, a1, a2); }
 519   catch (...) { (free)(ret); throw; }
 520   return ret;
 521 }
 522 template <typename T0, typename T1, typename T2>
 523 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
 524 {
 525   element_type * const ret = (malloc)();
 526   if (ret == 0)
 527     return ret;
 528   try { new (ret) element_type(a0, a1, a2); }
 529   catch (...) { (free)(ret); throw; }
 530   return ret;
 531 }
 532 template <typename T0, typename T1, typename T2>
 533 element_type * construct(T0 & a0, T1 & a1, volatile T2 & a2)
 534 {
 535   element_type * const ret = (malloc)();
 536   if (ret == 0)
 537     return ret;
 538   try { new (ret) element_type(a0, a1, a2); }
 539   catch (...) { (free)(ret); throw; }
 540   return ret;
 541 }
 542 template <typename T0, typename T1, typename T2>
 543 element_type * construct(const T0 & a0, T1 & a1, volatile T2 & a2)
 544 {
 545   element_type * const ret = (malloc)();
 546   if (ret == 0)
 547     return ret;
 548   try { new (ret) element_type(a0, a1, a2); }
 549   catch (...) { (free)(ret); throw; }
 550   return ret;
 551 }
 552 template <typename T0, typename T1, typename T2>
 553 element_type * construct(volatile T0 & a0, T1 & a1, volatile T2 & a2)
 554 {
 555   element_type * const ret = (malloc)();
 556   if (ret == 0)
 557     return ret;
 558   try { new (ret) element_type(a0, a1, a2); }
 559   catch (...) { (free)(ret); throw; }
 560   return ret;
 561 }
 562 template <typename T0, typename T1, typename T2>
 563 element_type * construct(const volatile T0 & a0, T1 & a1, volatile T2 & a2)
 564 {
 565   element_type * const ret = (malloc)();
 566   if (ret == 0)
 567     return ret;
 568   try { new (ret) element_type(a0, a1, a2); }
 569   catch (...) { (free)(ret); throw; }
 570   return ret;
 571 }
 572 template <typename T0, typename T1, typename T2>
 573 element_type * construct(T0 & a0, const T1 & a1, volatile T2 & a2)
 574 {
 575   element_type * const ret = (malloc)();
 576   if (ret == 0)
 577     return ret;
 578   try { new (ret) element_type(a0, a1, a2); }
 579   catch (...) { (free)(ret); throw; }
 580   return ret;
 581 }
 582 template <typename T0, typename T1, typename T2>
 583 element_type * construct(const T0 & a0, const T1 & a1, volatile T2 & a2)
 584 {
 585   element_type * const ret = (malloc)();
 586   if (ret == 0)
 587     return ret;
 588   try { new (ret) element_type(a0, a1, a2); }
 589   catch (...) { (free)(ret); throw; }
 590   return ret;
 591 }
 592 template <typename T0, typename T1, typename T2>
 593 element_type * construct(volatile T0 & a0, const T1 & a1, volatile T2 & a2)
 594 {
 595   element_type * const ret = (malloc)();
 596   if (ret == 0)
 597     return ret;
 598   try { new (ret) element_type(a0, a1, a2); }
 599   catch (...) { (free)(ret); throw; }
 600   return ret;
 601 }
 602 template <typename T0, typename T1, typename T2>
 603 element_type * construct(const volatile T0 & a0, const T1 & a1, volatile T2 & a2)
 604 {
 605   element_type * const ret = (malloc)();
 606   if (ret == 0)
 607     return ret;
 608   try { new (ret) element_type(a0, a1, a2); }
 609   catch (...) { (free)(ret); throw; }
 610   return ret;
 611 }
 612 template <typename T0, typename T1, typename T2>
 613 element_type * construct(T0 & a0, volatile T1 & a1, volatile T2 & a2)
 614 {
 615   element_type * const ret = (malloc)();
 616   if (ret == 0)
 617     return ret;
 618   try { new (ret) element_type(a0, a1, a2); }
 619   catch (...) { (free)(ret); throw; }
 620   return ret;
 621 }
 622 template <typename T0, typename T1, typename T2>
 623 element_type * construct(const T0 & a0, volatile T1 & a1, volatile T2 & a2)
 624 {
 625   element_type * const ret = (malloc)();
 626   if (ret == 0)
 627     return ret;
 628   try { new (ret) element_type(a0, a1, a2); }
 629   catch (...) { (free)(ret); throw; }
 630   return ret;
 631 }
 632 template <typename T0, typename T1, typename T2>
 633 element_type * construct(volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
 634 {
 635   element_type * const ret = (malloc)();
 636   if (ret == 0)
 637     return ret;
 638   try { new (ret) element_type(a0, a1, a2); }
 639   catch (...) { (free)(ret); throw; }
 640   return ret;
 641 }
 642 template <typename T0, typename T1, typename T2>
 643 element_type * construct(const volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
 644 {
 645   element_type * const ret = (malloc)();
 646   if (ret == 0)
 647     return ret;
 648   try { new (ret) element_type(a0, a1, a2); }
 649   catch (...) { (free)(ret); throw; }
 650   return ret;
 651 }
 652 template <typename T0, typename T1, typename T2>
 653 element_type * construct(T0 & a0, const volatile T1 & a1, volatile T2 & a2)
 654 {
 655   element_type * const ret = (malloc)();
 656   if (ret == 0)
 657     return ret;
 658   try { new (ret) element_type(a0, a1, a2); }
 659   catch (...) { (free)(ret); throw; }
 660   return ret;
 661 }
 662 template <typename T0, typename T1, typename T2>
 663 element_type * construct(const T0 & a0, const volatile T1 & a1, volatile T2 & a2)
 664 {
 665   element_type * const ret = (malloc)();
 666   if (ret == 0)
 667     return ret;
 668   try { new (ret) element_type(a0, a1, a2); }
 669   catch (...) { (free)(ret); throw; }
 670   return ret;
 671 }
 672 template <typename T0, typename T1, typename T2>
 673 element_type * construct(volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
 674 {
 675   element_type * const ret = (malloc)();
 676   if (ret == 0)
 677     return ret;
 678   try { new (ret) element_type(a0, a1, a2); }
 679   catch (...) { (free)(ret); throw; }
 680   return ret;
 681 }
 682 template <typename T0, typename T1, typename T2>
 683 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
 684 {
 685   element_type * const ret = (malloc)();
 686   if (ret == 0)
 687     return ret;
 688   try { new (ret) element_type(a0, a1, a2); }
 689   catch (...) { (free)(ret); throw; }
 690   return ret;
 691 }
 692 template <typename T0, typename T1, typename T2>
 693 element_type * construct(T0 & a0, T1 & a1, const volatile T2 & a2)
 694 {
 695   element_type * const ret = (malloc)();
 696   if (ret == 0)
 697     return ret;
 698   try { new (ret) element_type(a0, a1, a2); }
 699   catch (...) { (free)(ret); throw; }
 700   return ret;
 701 }
 702 template <typename T0, typename T1, typename T2>
 703 element_type * construct(const T0 & a0, T1 & a1, const volatile T2 & a2)
 704 {
 705   element_type * const ret = (malloc)();
 706   if (ret == 0)
 707     return ret;
 708   try { new (ret) element_type(a0, a1, a2); }
 709   catch (...) { (free)(ret); throw; }
 710   return ret;
 711 }
 712 template <typename T0, typename T1, typename T2>
 713 element_type * construct(volatile T0 & a0, T1 & a1, const volatile T2 & a2)
 714 {
 715   element_type * const ret = (malloc)();
 716   if (ret == 0)
 717     return ret;
 718   try { new (ret) element_type(a0, a1, a2); }
 719   catch (...) { (free)(ret); throw; }
 720   return ret;
 721 }
 722 template <typename T0, typename T1, typename T2>
 723 element_type * construct(const volatile T0 & a0, T1 & a1, const volatile T2 & a2)
 724 {
 725   element_type * const ret = (malloc)();
 726   if (ret == 0)
 727     return ret;
 728   try { new (ret) element_type(a0, a1, a2); }
 729   catch (...) { (free)(ret); throw; }
 730   return ret;
 731 }
 732 template <typename T0, typename T1, typename T2>
 733 element_type * construct(T0 & a0, const T1 & a1, const volatile T2 & a2)
 734 {
 735   element_type * const ret = (malloc)();
 736   if (ret == 0)
 737     return ret;
 738   try { new (ret) element_type(a0, a1, a2); }
 739   catch (...) { (free)(ret); throw; }
 740   return ret;
 741 }
 742 template <typename T0, typename T1, typename T2>
 743 element_type * construct(const T0 & a0, const T1 & a1, const volatile T2 & a2)
 744 {
 745   element_type * const ret = (malloc)();
 746   if (ret == 0)
 747     return ret;
 748   try { new (ret) element_type(a0, a1, a2); }
 749   catch (...) { (free)(ret); throw; }
 750   return ret;
 751 }
 752 template <typename T0, typename T1, typename T2>
 753 element_type * construct(volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
 754 {
 755   element_type * const ret = (malloc)();
 756   if (ret == 0)
 757     return ret;
 758   try { new (ret) element_type(a0, a1, a2); }
 759   catch (...) { (free)(ret); throw; }
 760   return ret;
 761 }
 762 template <typename T0, typename T1, typename T2>
 763 element_type * construct(const volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
 764 {
 765   element_type * const ret = (malloc)();
 766   if (ret == 0)
 767     return ret;
 768   try { new (ret) element_type(a0, a1, a2); }
 769   catch (...) { (free)(ret); throw; }
 770   return ret;
 771 }
 772 template <typename T0, typename T1, typename T2>
 773 element_type * construct(T0 & a0, volatile T1 & a1, const volatile T2 & a2)
 774 {
 775   element_type * const ret = (malloc)();
 776   if (ret == 0)
 777     return ret;
 778   try { new (ret) element_type(a0, a1, a2); }
 779   catch (...) { (free)(ret); throw; }
 780   return ret;
 781 }
 782 template <typename T0, typename T1, typename T2>
 783 element_type * construct(const T0 & a0, volatile T1 & a1, const volatile T2 & a2)
 784 {
 785   element_type * const ret = (malloc)();
 786   if (ret == 0)
 787     return ret;
 788   try { new (ret) element_type(a0, a1, a2); }
 789   catch (...) { (free)(ret); throw; }
 790   return ret;
 791 }
 792 template <typename T0, typename T1, typename T2>
 793 element_type * construct(volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
 794 {
 795   element_type * const ret = (malloc)();
 796   if (ret == 0)
 797     return ret;
 798   try { new (ret) element_type(a0, a1, a2); }
 799   catch (...) { (free)(ret); throw; }
 800   return ret;
 801 }
 802 template <typename T0, typename T1, typename T2>
 803 element_type * construct(const volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
 804 {
 805   element_type * const ret = (malloc)();
 806   if (ret == 0)
 807     return ret;
 808   try { new (ret) element_type(a0, a1, a2); }
 809   catch (...) { (free)(ret); throw; }
 810   return ret;
 811 }
 812 template <typename T0, typename T1, typename T2>
 813 element_type * construct(T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
 814 {
 815   element_type * const ret = (malloc)();
 816   if (ret == 0)
 817     return ret;
 818   try { new (ret) element_type(a0, a1, a2); }
 819   catch (...) { (free)(ret); throw; }
 820   return ret;
 821 }
 822 template <typename T0, typename T1, typename T2>
 823 element_type * construct(const T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
 824 {
 825   element_type * const ret = (malloc)();
 826   if (ret == 0)
 827     return ret;
 828   try { new (ret) element_type(a0, a1, a2); }
 829   catch (...) { (free)(ret); throw; }
 830   return ret;
 831 }
 832 template <typename T0, typename T1, typename T2>
 833 element_type * construct(volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
 834 {
 835   element_type * const ret = (malloc)();
 836   if (ret == 0)
 837     return ret;
 838   try { new (ret) element_type(a0, a1, a2); }
 839   catch (...) { (free)(ret); throw; }
 840   return ret;
 841 }
 842 template <typename T0, typename T1, typename T2>
 843 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
 844 {
 845   element_type * const ret = (malloc)();
 846   if (ret == 0)
 847     return ret;
 848   try { new (ret) element_type(a0, a1, a2); }
 849   catch (...) { (free)(ret); throw; }
 850   return ret;
 851 }
 852