Chris@16: // Copyright (C) 2000 Stephen Cleary
Chris@16: //
Chris@16: // Distributed under the Boost Software License, Version 1.0. (See accompany-
Chris@16: // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: //
Chris@16: // See http://www.boost.org for updates, documentation, and revision history.
Chris@16: 
Chris@16: // This file was AUTOMATICALLY GENERATED from "stdin"
Chris@16: //  Do NOT include directly!
Chris@16: //  Do NOT edit!
Chris@16: 
Chris@16: template <typename T0>
Chris@16: element_type * construct(T0 & a0)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0>
Chris@16: element_type * construct(const T0 & a0)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0>
Chris@16: element_type * construct(volatile T0 & a0)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0>
Chris@16: element_type * construct(const volatile T0 & a0)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(T0 & a0, T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(const T0 & a0, T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(volatile T0 & a0, T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(const volatile T0 & a0, T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(T0 & a0, const T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(const T0 & a0, const T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(volatile T0 & a0, const T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(const volatile T0 & a0, const T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(T0 & a0, volatile T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(const T0 & a0, volatile T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(volatile T0 & a0, volatile T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(const volatile T0 & a0, volatile T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(T0 & a0, const volatile T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(const T0 & a0, const volatile T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(volatile T0 & a0, const volatile T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1>
Chris@16: element_type * construct(const volatile T0 & a0, const volatile T1 & a1)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, const T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, const T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, const T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, const T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, volatile T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, volatile T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, volatile T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, volatile T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, const volatile T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, const volatile T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, const volatile T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, const volatile T1 & a1, T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, const T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, const T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, const T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, const T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, volatile T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, volatile T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, volatile T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, volatile T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, const volatile T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, const volatile T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, const T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, const T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, const T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, const T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, volatile T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, volatile T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, const volatile T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, const volatile T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, const T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, const T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, volatile T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, volatile T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: template <typename T0, typename T1, typename T2>
Chris@16: element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
Chris@16: {
Chris@16:   element_type * const ret = (malloc)();
Chris@16:   if (ret == 0)
Chris@16:     return ret;
Chris@16:   try { new (ret) element_type(a0, a1, a2); }
Chris@16:   catch (...) { (free)(ret); throw; }
Chris@16:   return ret;
Chris@16: }
Chris@16: