pool/detail/pool_construct.ipp

0001 // Copyright (C) 2000 Stephen Cleary
0002 //
0003 // Distributed under the Boost Software License, Version 1.0. (See accompany-
0004 // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0005 //
0006 // See http://www.boost.org for updates, documentation, and revision history.
0007
0008 // This file was AUTOMATICALLY GENERATED from "stdin"
0009 //  Do NOT include directly!
0010 //  Do NOT edit!
0011
0012 template <typename T0>
0013 element_type * construct(T0 & a0)
0014 {
0015   element_type * const ret = (malloc)();
0016   if (ret == 0)
0017     return ret;
0018   try { new (ret) element_type(a0); }
0019   catch (...) { (free)(ret); throw; }
0020   return ret;
0021 }
0022 template <typename T0>
0023 element_type * construct(const T0 & a0)
0024 {
0025   element_type * const ret = (malloc)();
0026   if (ret == 0)
0027     return ret;
0028   try { new (ret) element_type(a0); }
0029   catch (...) { (free)(ret); throw; }
0030   return ret;
0031 }
0032 template <typename T0>
0033 element_type * construct(volatile T0 & a0)
0034 {
0035   element_type * const ret = (malloc)();
0036   if (ret == 0)
0037     return ret;
0038   try { new (ret) element_type(a0); }
0039   catch (...) { (free)(ret); throw; }
0040   return ret;
0041 }
0042 template <typename T0>
0043 element_type * construct(const volatile T0 & a0)
0044 {
0045   element_type * const ret = (malloc)();
0046   if (ret == 0)
0047     return ret;
0048   try { new (ret) element_type(a0); }
0049   catch (...) { (free)(ret); throw; }
0050   return ret;
0051 }
0052 template <typename T0, typename T1>
0053 element_type * construct(T0 & a0, T1 & a1)
0054 {
0055   element_type * const ret = (malloc)();
0056   if (ret == 0)
0057     return ret;
0058   try { new (ret) element_type(a0, a1); }
0059   catch (...) { (free)(ret); throw; }
0060   return ret;
0061 }
0062 template <typename T0, typename T1>
0063 element_type * construct(const T0 & a0, T1 & a1)
0064 {
0065   element_type * const ret = (malloc)();
0066   if (ret == 0)
0067     return ret;
0068   try { new (ret) element_type(a0, a1); }
0069   catch (...) { (free)(ret); throw; }
0070   return ret;
0071 }
0072 template <typename T0, typename T1>
0073 element_type * construct(volatile T0 & a0, T1 & a1)
0074 {
0075   element_type * const ret = (malloc)();
0076   if (ret == 0)
0077     return ret;
0078   try { new (ret) element_type(a0, a1); }
0079   catch (...) { (free)(ret); throw; }
0080   return ret;
0081 }
0082 template <typename T0, typename T1>
0083 element_type * construct(const volatile T0 & a0, T1 & a1)
0084 {
0085   element_type * const ret = (malloc)();
0086   if (ret == 0)
0087     return ret;
0088   try { new (ret) element_type(a0, a1); }
0089   catch (...) { (free)(ret); throw; }
0090   return ret;
0091 }
0092 template <typename T0, typename T1>
0093 element_type * construct(T0 & a0, const T1 & a1)
0094 {
0095   element_type * const ret = (malloc)();
0096   if (ret == 0)
0097     return ret;
0098   try { new (ret) element_type(a0, a1); }
0099   catch (...) { (free)(ret); throw; }
0100   return ret;
0101 }
0102 template <typename T0, typename T1>
0103 element_type * construct(const T0 & a0, const T1 & a1)
0104 {
0105   element_type * const ret = (malloc)();
0106   if (ret == 0)
0107     return ret;
0108   try { new (ret) element_type(a0, a1); }
0109   catch (...) { (free)(ret); throw; }
0110   return ret;
0111 }
0112 template <typename T0, typename T1>
0113 element_type * construct(volatile T0 & a0, const T1 & a1)
0114 {
0115   element_type * const ret = (malloc)();
0116   if (ret == 0)
0117     return ret;
0118   try { new (ret) element_type(a0, a1); }
0119   catch (...) { (free)(ret); throw; }
0120   return ret;
0121 }
0122 template <typename T0, typename T1>
0123 element_type * construct(const volatile T0 & a0, const T1 & a1)
0124 {
0125   element_type * const ret = (malloc)();
0126   if (ret == 0)
0127     return ret;
0128   try { new (ret) element_type(a0, a1); }
0129   catch (...) { (free)(ret); throw; }
0130   return ret;
0131 }
0132 template <typename T0, typename T1>
0133 element_type * construct(T0 & a0, volatile T1 & a1)
0134 {
0135   element_type * const ret = (malloc)();
0136   if (ret == 0)
0137     return ret;
0138   try { new (ret) element_type(a0, a1); }
0139   catch (...) { (free)(ret); throw; }
0140   return ret;
0141 }
0142 template <typename T0, typename T1>
0143 element_type * construct(const T0 & a0, volatile T1 & a1)
0144 {
0145   element_type * const ret = (malloc)();
0146   if (ret == 0)
0147     return ret;
0148   try { new (ret) element_type(a0, a1); }
0149   catch (...) { (free)(ret); throw; }
0150   return ret;
0151 }
0152 template <typename T0, typename T1>
0153 element_type * construct(volatile T0 & a0, volatile T1 & a1)
0154 {
0155   element_type * const ret = (malloc)();
0156   if (ret == 0)
0157     return ret;
0158   try { new (ret) element_type(a0, a1); }
0159   catch (...) { (free)(ret); throw; }
0160   return ret;
0161 }
0162 template <typename T0, typename T1>
0163 element_type * construct(const volatile T0 & a0, volatile T1 & a1)
0164 {
0165   element_type * const ret = (malloc)();
0166   if (ret == 0)
0167     return ret;
0168   try { new (ret) element_type(a0, a1); }
0169   catch (...) { (free)(ret); throw; }
0170   return ret;
0171 }
0172 template <typename T0, typename T1>
0173 element_type * construct(T0 & a0, const volatile T1 & a1)
0174 {
0175   element_type * const ret = (malloc)();
0176   if (ret == 0)
0177     return ret;
0178   try { new (ret) element_type(a0, a1); }
0179   catch (...) { (free)(ret); throw; }
0180   return ret;
0181 }
0182 template <typename T0, typename T1>
0183 element_type * construct(const T0 & a0, const volatile T1 & a1)
0184 {
0185   element_type * const ret = (malloc)();
0186   if (ret == 0)
0187     return ret;
0188   try { new (ret) element_type(a0, a1); }
0189   catch (...) { (free)(ret); throw; }
0190   return ret;
0191 }
0192 template <typename T0, typename T1>
0193 element_type * construct(volatile T0 & a0, const volatile T1 & a1)
0194 {
0195   element_type * const ret = (malloc)();
0196   if (ret == 0)
0197     return ret;
0198   try { new (ret) element_type(a0, a1); }
0199   catch (...) { (free)(ret); throw; }
0200   return ret;
0201 }
0202 template <typename T0, typename T1>
0203 element_type * construct(const volatile T0 & a0, const volatile T1 & a1)
0204 {
0205   element_type * const ret = (malloc)();
0206   if (ret == 0)
0207     return ret;
0208   try { new (ret) element_type(a0, a1); }
0209   catch (...) { (free)(ret); throw; }
0210   return ret;
0211 }
0212 template <typename T0, typename T1, typename T2>
0213 element_type * construct(T0 & a0, T1 & a1, T2 & a2)
0214 {
0215   element_type * const ret = (malloc)();
0216   if (ret == 0)
0217     return ret;
0218   try { new (ret) element_type(a0, a1, a2); }
0219   catch (...) { (free)(ret); throw; }
0220   return ret;
0221 }
0222 template <typename T0, typename T1, typename T2>
0223 element_type * construct(const T0 & a0, T1 & a1, T2 & a2)
0224 {
0225   element_type * const ret = (malloc)();
0226   if (ret == 0)
0227     return ret;
0228   try { new (ret) element_type(a0, a1, a2); }
0229   catch (...) { (free)(ret); throw; }
0230   return ret;
0231 }
0232 template <typename T0, typename T1, typename T2>
0233 element_type * construct(volatile T0 & a0, T1 & a1, T2 & a2)
0234 {
0235   element_type * const ret = (malloc)();
0236   if (ret == 0)
0237     return ret;
0238   try { new (ret) element_type(a0, a1, a2); }
0239   catch (...) { (free)(ret); throw; }
0240   return ret;
0241 }
0242 template <typename T0, typename T1, typename T2>
0243 element_type * construct(const volatile T0 & a0, T1 & a1, T2 & a2)
0244 {
0245   element_type * const ret = (malloc)();
0246   if (ret == 0)
0247     return ret;
0248   try { new (ret) element_type(a0, a1, a2); }
0249   catch (...) { (free)(ret); throw; }
0250   return ret;
0251 }
0252 template <typename T0, typename T1, typename T2>
0253 element_type * construct(T0 & a0, const T1 & a1, T2 & a2)
0254 {
0255   element_type * const ret = (malloc)();
0256   if (ret == 0)
0257     return ret;
0258   try { new (ret) element_type(a0, a1, a2); }
0259   catch (...) { (free)(ret); throw; }
0260   return ret;
0261 }
0262 template <typename T0, typename T1, typename T2>
0263 element_type * construct(const T0 & a0, const T1 & a1, T2 & a2)
0264 {
0265   element_type * const ret = (malloc)();
0266   if (ret == 0)
0267     return ret;
0268   try { new (ret) element_type(a0, a1, a2); }
0269   catch (...) { (free)(ret); throw; }
0270   return ret;
0271 }
0272 template <typename T0, typename T1, typename T2>
0273 element_type * construct(volatile T0 & a0, const T1 & a1, T2 & a2)
0274 {
0275   element_type * const ret = (malloc)();
0276   if (ret == 0)
0277     return ret;
0278   try { new (ret) element_type(a0, a1, a2); }
0279   catch (...) { (free)(ret); throw; }
0280   return ret;
0281 }
0282 template <typename T0, typename T1, typename T2>
0283 element_type * construct(const volatile T0 & a0, const T1 & a1, T2 & a2)
0284 {
0285   element_type * const ret = (malloc)();
0286   if (ret == 0)
0287     return ret;
0288   try { new (ret) element_type(a0, a1, a2); }
0289   catch (...) { (free)(ret); throw; }
0290   return ret;
0291 }
0292 template <typename T0, typename T1, typename T2>
0293 element_type * construct(T0 & a0, volatile T1 & a1, T2 & a2)
0294 {
0295   element_type * const ret = (malloc)();
0296   if (ret == 0)
0297     return ret;
0298   try { new (ret) element_type(a0, a1, a2); }
0299   catch (...) { (free)(ret); throw; }
0300   return ret;
0301 }
0302 template <typename T0, typename T1, typename T2>
0303 element_type * construct(const T0 & a0, volatile T1 & a1, T2 & a2)
0304 {
0305   element_type * const ret = (malloc)();
0306   if (ret == 0)
0307     return ret;
0308   try { new (ret) element_type(a0, a1, a2); }
0309   catch (...) { (free)(ret); throw; }
0310   return ret;
0311 }
0312 template <typename T0, typename T1, typename T2>
0313 element_type * construct(volatile T0 & a0, volatile T1 & a1, T2 & a2)
0314 {
0315   element_type * const ret = (malloc)();
0316   if (ret == 0)
0317     return ret;
0318   try { new (ret) element_type(a0, a1, a2); }
0319   catch (...) { (free)(ret); throw; }
0320   return ret;
0321 }
0322 template <typename T0, typename T1, typename T2>
0323 element_type * construct(const volatile T0 & a0, volatile T1 & a1, T2 & a2)
0324 {
0325   element_type * const ret = (malloc)();
0326   if (ret == 0)
0327     return ret;
0328   try { new (ret) element_type(a0, a1, a2); }
0329   catch (...) { (free)(ret); throw; }
0330   return ret;
0331 }
0332 template <typename T0, typename T1, typename T2>
0333 element_type * construct(T0 & a0, const volatile T1 & a1, T2 & a2)
0334 {
0335   element_type * const ret = (malloc)();
0336   if (ret == 0)
0337     return ret;
0338   try { new (ret) element_type(a0, a1, a2); }
0339   catch (...) { (free)(ret); throw; }
0340   return ret;
0341 }
0342 template <typename T0, typename T1, typename T2>
0343 element_type * construct(const T0 & a0, const volatile T1 & a1, T2 & a2)
0344 {
0345   element_type * const ret = (malloc)();
0346   if (ret == 0)
0347     return ret;
0348   try { new (ret) element_type(a0, a1, a2); }
0349   catch (...) { (free)(ret); throw; }
0350   return ret;
0351 }
0352 template <typename T0, typename T1, typename T2>
0353 element_type * construct(volatile T0 & a0, const volatile T1 & a1, T2 & a2)
0354 {
0355   element_type * const ret = (malloc)();
0356   if (ret == 0)
0357     return ret;
0358   try { new (ret) element_type(a0, a1, a2); }
0359   catch (...) { (free)(ret); throw; }
0360   return ret;
0361 }
0362 template <typename T0, typename T1, typename T2>
0363 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, T2 & a2)
0364 {
0365   element_type * const ret = (malloc)();
0366   if (ret == 0)
0367     return ret;
0368   try { new (ret) element_type(a0, a1, a2); }
0369   catch (...) { (free)(ret); throw; }
0370   return ret;
0371 }
0372 template <typename T0, typename T1, typename T2>
0373 element_type * construct(T0 & a0, T1 & a1, const T2 & a2)
0374 {
0375   element_type * const ret = (malloc)();
0376   if (ret == 0)
0377     return ret;
0378   try { new (ret) element_type(a0, a1, a2); }
0379   catch (...) { (free)(ret); throw; }
0380   return ret;
0381 }
0382 template <typename T0, typename T1, typename T2>
0383 element_type * construct(const T0 & a0, T1 & a1, const T2 & a2)
0384 {
0385   element_type * const ret = (malloc)();
0386   if (ret == 0)
0387     return ret;
0388   try { new (ret) element_type(a0, a1, a2); }
0389   catch (...) { (free)(ret); throw; }
0390   return ret;
0391 }
0392 template <typename T0, typename T1, typename T2>
0393 element_type * construct(volatile T0 & a0, T1 & a1, const T2 & a2)
0394 {
0395   element_type * const ret = (malloc)();
0396   if (ret == 0)
0397     return ret;
0398   try { new (ret) element_type(a0, a1, a2); }
0399   catch (...) { (free)(ret); throw; }
0400   return ret;
0401 }
0402 template <typename T0, typename T1, typename T2>
0403 element_type * construct(const volatile T0 & a0, T1 & a1, const T2 & a2)
0404 {
0405   element_type * const ret = (malloc)();
0406   if (ret == 0)
0407     return ret;
0408   try { new (ret) element_type(a0, a1, a2); }
0409   catch (...) { (free)(ret); throw; }
0410   return ret;
0411 }
0412 template <typename T0, typename T1, typename T2>
0413 element_type * construct(T0 & a0, const T1 & a1, const T2 & a2)
0414 {
0415   element_type * const ret = (malloc)();
0416   if (ret == 0)
0417     return ret;
0418   try { new (ret) element_type(a0, a1, a2); }
0419   catch (...) { (free)(ret); throw; }
0420   return ret;
0421 }
0422 template <typename T0, typename T1, typename T2>
0423 element_type * construct(const T0 & a0, const T1 & a1, const T2 & a2)
0424 {
0425   element_type * const ret = (malloc)();
0426   if (ret == 0)
0427     return ret;
0428   try { new (ret) element_type(a0, a1, a2); }
0429   catch (...) { (free)(ret); throw; }
0430   return ret;
0431 }
0432 template <typename T0, typename T1, typename T2>
0433 element_type * construct(volatile T0 & a0, const T1 & a1, const T2 & a2)
0434 {
0435   element_type * const ret = (malloc)();
0436   if (ret == 0)
0437     return ret;
0438   try { new (ret) element_type(a0, a1, a2); }
0439   catch (...) { (free)(ret); throw; }
0440   return ret;
0441 }
0442 template <typename T0, typename T1, typename T2>
0443 element_type * construct(const volatile T0 & a0, const T1 & a1, const T2 & a2)
0444 {
0445   element_type * const ret = (malloc)();
0446   if (ret == 0)
0447     return ret;
0448   try { new (ret) element_type(a0, a1, a2); }
0449   catch (...) { (free)(ret); throw; }
0450   return ret;
0451 }
0452 template <typename T0, typename T1, typename T2>
0453 element_type * construct(T0 & a0, volatile T1 & a1, const T2 & a2)
0454 {
0455   element_type * const ret = (malloc)();
0456   if (ret == 0)
0457     return ret;
0458   try { new (ret) element_type(a0, a1, a2); }
0459   catch (...) { (free)(ret); throw; }
0460   return ret;
0461 }
0462 template <typename T0, typename T1, typename T2>
0463 element_type * construct(const T0 & a0, volatile T1 & a1, const T2 & a2)
0464 {
0465   element_type * const ret = (malloc)();
0466   if (ret == 0)
0467     return ret;
0468   try { new (ret) element_type(a0, a1, a2); }
0469   catch (...) { (free)(ret); throw; }
0470   return ret;
0471 }
0472 template <typename T0, typename T1, typename T2>
0473 element_type * construct(volatile T0 & a0, volatile T1 & a1, const T2 & a2)
0474 {
0475   element_type * const ret = (malloc)();
0476   if (ret == 0)
0477     return ret;
0478   try { new (ret) element_type(a0, a1, a2); }
0479   catch (...) { (free)(ret); throw; }
0480   return ret;
0481 }
0482 template <typename T0, typename T1, typename T2>
0483 element_type * construct(const volatile T0 & a0, volatile T1 & a1, const T2 & a2)
0484 {
0485   element_type * const ret = (malloc)();
0486   if (ret == 0)
0487     return ret;
0488   try { new (ret) element_type(a0, a1, a2); }
0489   catch (...) { (free)(ret); throw; }
0490   return ret;
0491 }
0492 template <typename T0, typename T1, typename T2>
0493 element_type * construct(T0 & a0, const volatile T1 & a1, const T2 & a2)
0494 {
0495   element_type * const ret = (malloc)();
0496   if (ret == 0)
0497     return ret;
0498   try { new (ret) element_type(a0, a1, a2); }
0499   catch (...) { (free)(ret); throw; }
0500   return ret;
0501 }
0502 template <typename T0, typename T1, typename T2>
0503 element_type * construct(const T0 & a0, const volatile T1 & a1, const T2 & a2)
0504 {
0505   element_type * const ret = (malloc)();
0506   if (ret == 0)
0507     return ret;
0508   try { new (ret) element_type(a0, a1, a2); }
0509   catch (...) { (free)(ret); throw; }
0510   return ret;
0511 }
0512 template <typename T0, typename T1, typename T2>
0513 element_type * construct(volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
0514 {
0515   element_type * const ret = (malloc)();
0516   if (ret == 0)
0517     return ret;
0518   try { new (ret) element_type(a0, a1, a2); }
0519   catch (...) { (free)(ret); throw; }
0520   return ret;
0521 }
0522 template <typename T0, typename T1, typename T2>
0523 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
0524 {
0525   element_type * const ret = (malloc)();
0526   if (ret == 0)
0527     return ret;
0528   try { new (ret) element_type(a0, a1, a2); }
0529   catch (...) { (free)(ret); throw; }
0530   return ret;
0531 }
0532 template <typename T0, typename T1, typename T2>
0533 element_type * construct(T0 & a0, T1 & a1, volatile T2 & a2)
0534 {
0535   element_type * const ret = (malloc)();
0536   if (ret == 0)
0537     return ret;
0538   try { new (ret) element_type(a0, a1, a2); }
0539   catch (...) { (free)(ret); throw; }
0540   return ret;
0541 }
0542 template <typename T0, typename T1, typename T2>
0543 element_type * construct(const T0 & a0, T1 & a1, volatile T2 & a2)
0544 {
0545   element_type * const ret = (malloc)();
0546   if (ret == 0)
0547     return ret;
0548   try { new (ret) element_type(a0, a1, a2); }
0549   catch (...) { (free)(ret); throw; }
0550   return ret;
0551 }
0552 template <typename T0, typename T1, typename T2>
0553 element_type * construct(volatile T0 & a0, T1 & a1, volatile T2 & a2)
0554 {
0555   element_type * const ret = (malloc)();
0556   if (ret == 0)
0557     return ret;
0558   try { new (ret) element_type(a0, a1, a2); }
0559   catch (...) { (free)(ret); throw; }
0560   return ret;
0561 }
0562 template <typename T0, typename T1, typename T2>
0563 element_type * construct(const volatile T0 & a0, T1 & a1, volatile T2 & a2)
0564 {
0565   element_type * const ret = (malloc)();
0566   if (ret == 0)
0567     return ret;
0568   try { new (ret) element_type(a0, a1, a2); }
0569   catch (...) { (free)(ret); throw; }
0570   return ret;
0571 }
0572 template <typename T0, typename T1, typename T2>
0573 element_type * construct(T0 & a0, const T1 & a1, volatile T2 & a2)
0574 {
0575   element_type * const ret = (malloc)();
0576   if (ret == 0)
0577     return ret;
0578   try { new (ret) element_type(a0, a1, a2); }
0579   catch (...) { (free)(ret); throw; }
0580   return ret;
0581 }
0582 template <typename T0, typename T1, typename T2>
0583 element_type * construct(const T0 & a0, const T1 & a1, volatile T2 & a2)
0584 {
0585   element_type * const ret = (malloc)();
0586   if (ret == 0)
0587     return ret;
0588   try { new (ret) element_type(a0, a1, a2); }
0589   catch (...) { (free)(ret); throw; }
0590   return ret;
0591 }
0592 template <typename T0, typename T1, typename T2>
0593 element_type * construct(volatile T0 & a0, const T1 & a1, volatile T2 & a2)
0594 {
0595   element_type * const ret = (malloc)();
0596   if (ret == 0)
0597     return ret;
0598   try { new (ret) element_type(a0, a1, a2); }
0599   catch (...) { (free)(ret); throw; }
0600   return ret;
0601 }
0602 template <typename T0, typename T1, typename T2>
0603 element_type * construct(const volatile T0 & a0, const T1 & a1, volatile T2 & a2)
0604 {
0605   element_type * const ret = (malloc)();
0606   if (ret == 0)
0607     return ret;
0608   try { new (ret) element_type(a0, a1, a2); }
0609   catch (...) { (free)(ret); throw; }
0610   return ret;
0611 }
0612 template <typename T0, typename T1, typename T2>
0613 element_type * construct(T0 & a0, volatile T1 & a1, volatile T2 & a2)
0614 {
0615   element_type * const ret = (malloc)();
0616   if (ret == 0)
0617     return ret;
0618   try { new (ret) element_type(a0, a1, a2); }
0619   catch (...) { (free)(ret); throw; }
0620   return ret;
0621 }
0622 template <typename T0, typename T1, typename T2>
0623 element_type * construct(const T0 & a0, volatile T1 & a1, volatile T2 & a2)
0624 {
0625   element_type * const ret = (malloc)();
0626   if (ret == 0)
0627     return ret;
0628   try { new (ret) element_type(a0, a1, a2); }
0629   catch (...) { (free)(ret); throw; }
0630   return ret;
0631 }
0632 template <typename T0, typename T1, typename T2>
0633 element_type * construct(volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
0634 {
0635   element_type * const ret = (malloc)();
0636   if (ret == 0)
0637     return ret;
0638   try { new (ret) element_type(a0, a1, a2); }
0639   catch (...) { (free)(ret); throw; }
0640   return ret;
0641 }
0642 template <typename T0, typename T1, typename T2>
0643 element_type * construct(const volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
0644 {
0645   element_type * const ret = (malloc)();
0646   if (ret == 0)
0647     return ret;
0648   try { new (ret) element_type(a0, a1, a2); }
0649   catch (...) { (free)(ret); throw; }
0650   return ret;
0651 }
0652 template <typename T0, typename T1, typename T2>
0653 element_type * construct(T0 & a0, const volatile T1 & a1, volatile T2 & a2)
0654 {
0655   element_type * const ret = (malloc)();
0656   if (ret == 0)
0657     return ret;
0658   try { new (ret) element_type(a0, a1, a2); }
0659   catch (...) { (free)(ret); throw; }
0660   return ret;
0661 }
0662 template <typename T0, typename T1, typename T2>
0663 element_type * construct(const T0 & a0, const volatile T1 & a1, volatile T2 & a2)
0664 {
0665   element_type * const ret = (malloc)();
0666   if (ret == 0)
0667     return ret;
0668   try { new (ret) element_type(a0, a1, a2); }
0669   catch (...) { (free)(ret); throw; }
0670   return ret;
0671 }
0672 template <typename T0, typename T1, typename T2>
0673 element_type * construct(volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
0674 {
0675   element_type * const ret = (malloc)();
0676   if (ret == 0)
0677     return ret;
0678   try { new (ret) element_type(a0, a1, a2); }
0679   catch (...) { (free)(ret); throw; }
0680   return ret;
0681 }
0682 template <typename T0, typename T1, typename T2>
0683 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
0684 {
0685   element_type * const ret = (malloc)();
0686   if (ret == 0)
0687     return ret;
0688   try { new (ret) element_type(a0, a1, a2); }
0689   catch (...) { (free)(ret); throw; }
0690   return ret;
0691 }
0692 template <typename T0, typename T1, typename T2>
0693 element_type * construct(T0 & a0, T1 & a1, const volatile T2 & a2)
0694 {
0695   element_type * const ret = (malloc)();
0696   if (ret == 0)
0697     return ret;
0698   try { new (ret) element_type(a0, a1, a2); }
0699   catch (...) { (free)(ret); throw; }
0700   return ret;
0701 }
0702 template <typename T0, typename T1, typename T2>
0703 element_type * construct(const T0 & a0, T1 & a1, const volatile T2 & a2)
0704 {
0705   element_type * const ret = (malloc)();
0706   if (ret == 0)
0707     return ret;
0708   try { new (ret) element_type(a0, a1, a2); }
0709   catch (...) { (free)(ret); throw; }
0710   return ret;
0711 }
0712 template <typename T0, typename T1, typename T2>
0713 element_type * construct(volatile T0 & a0, T1 & a1, const volatile T2 & a2)
0714 {
0715   element_type * const ret = (malloc)();
0716   if (ret == 0)
0717     return ret;
0718   try { new (ret) element_type(a0, a1, a2); }
0719   catch (...) { (free)(ret); throw; }
0720   return ret;
0721 }
0722 template <typename T0, typename T1, typename T2>
0723 element_type * construct(const volatile T0 & a0, T1 & a1, const volatile T2 & a2)
0724 {
0725   element_type * const ret = (malloc)();
0726   if (ret == 0)
0727     return ret;
0728   try { new (ret) element_type(a0, a1, a2); }
0729   catch (...) { (free)(ret); throw; }
0730   return ret;
0731 }
0732 template <typename T0, typename T1, typename T2>
0733 element_type * construct(T0 & a0, const T1 & a1, const volatile T2 & a2)
0734 {
0735   element_type * const ret = (malloc)();
0736   if (ret == 0)
0737     return ret;
0738   try { new (ret) element_type(a0, a1, a2); }
0739   catch (...) { (free)(ret); throw; }
0740   return ret;
0741 }
0742 template <typename T0, typename T1, typename T2>
0743 element_type * construct(const T0 & a0, const T1 & a1, const volatile T2 & a2)
0744 {
0745   element_type * const ret = (malloc)();
0746   if (ret == 0)
0747     return ret;
0748   try { new (ret) element_type(a0, a1, a2); }
0749   catch (...) { (free)(ret); throw; }
0750   return ret;
0751 }
0752 template <typename T0, typename T1, typename T2>
0753 element_type * construct(volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
0754 {
0755   element_type * const ret = (malloc)();
0756   if (ret == 0)
0757     return ret;
0758   try { new (ret) element_type(a0, a1, a2); }
0759   catch (...) { (free)(ret); throw; }
0760   return ret;
0761 }
0762 template <typename T0, typename T1, typename T2>
0763 element_type * construct(const volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
0764 {
0765   element_type * const ret = (malloc)();
0766   if (ret == 0)
0767     return ret;
0768   try { new (ret) element_type(a0, a1, a2); }
0769   catch (...) { (free)(ret); throw; }
0770   return ret;
0771 }
0772 template <typename T0, typename T1, typename T2>
0773 element_type * construct(T0 & a0, volatile T1 & a1, const volatile T2 & a2)
0774 {
0775   element_type * const ret = (malloc)();
0776   if (ret == 0)
0777     return ret;
0778   try { new (ret) element_type(a0, a1, a2); }
0779   catch (...) { (free)(ret); throw; }
0780   return ret;
0781 }
0782 template <typename T0, typename T1, typename T2>
0783 element_type * construct(const T0 & a0, volatile T1 & a1, const volatile T2 & a2)
0784 {
0785   element_type * const ret = (malloc)();
0786   if (ret == 0)
0787     return ret;
0788   try { new (ret) element_type(a0, a1, a2); }
0789   catch (...) { (free)(ret); throw; }
0790   return ret;
0791 }
0792 template <typename T0, typename T1, typename T2>
0793 element_type * construct(volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
0794 {
0795   element_type * const ret = (malloc)();
0796   if (ret == 0)
0797     return ret;
0798   try { new (ret) element_type(a0, a1, a2); }
0799   catch (...) { (free)(ret); throw; }
0800   return ret;
0801 }
0802 template <typename T0, typename T1, typename T2>
0803 element_type * construct(const volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
0804 {
0805   element_type * const ret = (malloc)();
0806   if (ret == 0)
0807     return ret;
0808   try { new (ret) element_type(a0, a1, a2); }
0809   catch (...) { (free)(ret); throw; }
0810   return ret;
0811 }
0812 template <typename T0, typename T1, typename T2>
0813 element_type * construct(T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
0814 {
0815   element_type * const ret = (malloc)();
0816   if (ret == 0)
0817     return ret;
0818   try { new (ret) element_type(a0, a1, a2); }
0819   catch (...) { (free)(ret); throw; }
0820   return ret;
0821 }
0822 template <typename T0, typename T1, typename T2>
0823 element_type * construct(const T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
0824 {
0825   element_type * const ret = (malloc)();
0826   if (ret == 0)
0827     return ret;
0828   try { new (ret) element_type(a0, a1, a2); }
0829   catch (...) { (free)(ret); throw; }
0830   return ret;
0831 }
0832 template <typename T0, typename T1, typename T2>
0833 element_type * construct(volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
0834 {
0835   element_type * const ret = (malloc)();
0836   if (ret == 0)
0837     return ret;
0838   try { new (ret) element_type(a0, a1, a2); }
0839   catch (...) { (free)(ret); throw; }
0840   return ret;
0841 }
0842 template <typename T0, typename T1, typename T2>
0843 element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
0844 {
0845   element_type * const ret = (malloc)();
0846   if (ret == 0)
0847     return ret;
0848   try { new (ret) element_type(a0, a1, a2); }
0849   catch (...) { (free)(ret); throw; }
0850   return ret;
0851 }
0852