passenger 4.0.60 → 5.0.0.beta1

data/ext/boost/parameter/value_type.hpp

@@ -0,0 +1,108 @@
+// Copyright Daniel Wallin 2006. Use, modification and distribution is
+// subject to the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PARAMETER_VALUE_TYPE_060921_HPP
+# define BOOST_PARAMETER_VALUE_TYPE_060921_HPP
+
+# include <boost/mpl/apply.hpp>
+# include <boost/mpl/assert.hpp>
+# include <boost/mpl/and.hpp>
+# include <boost/parameter/aux_/result_of0.hpp>
+# include <boost/parameter/aux_/void.hpp>
+# include <boost/type_traits/is_same.hpp>
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#  include <boost/mpl/eval_if.hpp>
+# endif
+
+namespace boost { namespace parameter { 
+
+// A metafunction that, given an argument pack, returns the type of
+// the parameter identified by the given keyword.  If no such
+// parameter has been specified, returns Default
+
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <class Parameters, class Keyword, class Default>
+struct value_type0
+{
+    typedef typename mpl::apply_wrap3<
+        typename Parameters::binding,Keyword,Default,mpl::false_
+    >::type type;
+
+    BOOST_MPL_ASSERT_NOT((
+        mpl::and_<
+            is_same<Default, void_>
+          , is_same<type, void_>
+        >
+    ));
+};
+# endif
+
+template <class Parameters, class Keyword, class Default = void_>
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+struct value_type
+# else
+struct value_type_eti
+# endif
+{
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    typedef typename mpl::eval_if<
+        mpl::is_placeholder<Parameters>
+      , mpl::identity<int>
+      , value_type0<Parameters,Keyword,Default>
+    >::type type;
+# else
+    typedef typename mpl::apply_wrap3<
+        typename Parameters::binding,Keyword,Default,mpl::false_
+    >::type type;
+
+    BOOST_MPL_ASSERT_NOT((
+        mpl::and_<
+            is_same<Default, void_>
+          , is_same<type, void_>
+        >
+    ));
+# endif
+
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default))
+# endif
+};
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+template <class Parameters, class Keyword, class Default = void_>
+struct value_type
+{
+    typedef typename mpl::eval_if<
+        is_same<Parameters, int>
+      , mpl::identity<int>
+      , value_type_eti<Parameters, Keyword, Default>
+    >::type type;
+
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default))
+};
+# endif
+
+// A metafunction that, given an argument pack, returns the type of
+// the parameter identified by the given keyword.  If no such
+// parameter has been specified, returns the type returned by invoking
+// DefaultFn
+template <class Parameters, class Keyword, class DefaultFn>
+struct lazy_value_type
+{
+  typedef typename mpl::apply_wrap3<
+      typename Parameters::binding
+    , Keyword
+    , typename aux::result_of0<DefaultFn>::type
+    , mpl::false_
+  >::type type;
+};
+
+
+}} // namespace boost::parameter
+
+#endif // BOOST_PARAMETER_VALUE_TYPE_060921_HPP
+

data/ext/boost/pool/detail/for.m4

@@ -0,0 +1,107 @@
+m4_dnl 
+m4_dnl Copyright (C) 2000 Stephen Cleary
+m4_dnl 
+m4_dnl Distributed under the Boost Software License, Version 1.0. (See accompany-
+m4_dnl ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+m4_dnl
+m4_dnl See http://www.boost.org for updates, documentation, and revision history.
+m4_dnl 
+m4_dnl
+m4_dnl 
+m4_dnl BOOST_M4_FOR: repeat a given text for a range of values
+m4_dnl   $1 - variable to hold the current value.
+m4_dnl   $2 - the starting value.
+m4_dnl   $3 - the ending value (text is _not_ repeated for this value).
+m4_dnl   $4 - the text to repeat.
+m4_dnl   $5 - the delimeter text (optional).
+m4_dnl
+m4_dnl If the starting value is < ending value:
+m4_dnl   Will repeat $4, binding $1 to the values in the range [$2, $3).
+m4_dnl Else (that is, starting value >= ending value):
+m4_dnl   Will do nothing
+m4_dnl Repeats $5 in-between each occurrence of $4
+m4_dnl
+m4_dnl Logic:
+m4_dnl   Set $1 to $2 and call BOOST_M4_FOR_LIST_HELPER:
+m4_dnl     If $1 >= $3, do nothing
+m4_dnl     Else
+m4_dnl       output $4,
+m4_dnl       set $1 to itself incremented,
+m4_dnl       If $1 != $3, output $5,
+m4_dnl       and use recursion
+m4_dnl
+m4_define(`BOOST_M4_FOR',
+          `m4_ifelse(m4_eval($# < 4 || $# > 5), 1,
+                     `m4_errprint(m4___file__:m4___line__: `Boost m4 script: BOOST_M4_FOR: Wrong number of arguments ($#)')',
+                     `m4_pushdef(`$1', `$2')BOOST_M4_FOR_HELPER($@)m4_popdef(`$1')')')m4_dnl
+m4_define(`BOOST_M4_FOR_HELPER',
+          `m4_ifelse(m4_eval($1 >= $3), 1, ,
+                     `$4`'m4_define(`$1', m4_incr($1))m4_ifelse(m4_eval($1 != $3), 1, `$5')`'BOOST_M4_FOR_HELPER($@)')')m4_dnl
+m4_dnl 
+m4_dnl Testing/Examples:
+m4_dnl 
+m4_dnl The following line will output:
+m4_dnl   "repeat.m4:42: Boost m4 script: BOOST_M4_FOR: Wrong number of arguments (3)"
+m4_dnl BOOST_M4_FOR(i, 1, 3)
+m4_dnl
+m4_dnl The following line will output:
+m4_dnl   "repeat.m4:46: Boost m4 script: BOOST_M4_FOR: Wrong number of arguments (6)"
+m4_dnl BOOST_M4_FOR(i, 1, 3, i, ` ', 13)
+m4_dnl
+m4_dnl The following line will output (nothing):
+m4_dnl   ""
+m4_dnl BOOST_M4_FOR(i, 7, 0, i )
+m4_dnl
+m4_dnl The following line will output (nothing):
+m4_dnl   ""
+m4_dnl BOOST_M4_FOR(i, 0, 0, i )
+m4_dnl
+m4_dnl The following line will output:
+m4_dnl   "0 1 2 3 4 5 6 "
+m4_dnl BOOST_M4_FOR(i, 0, 7, i )
+m4_dnl
+m4_dnl The following line will output:
+m4_dnl   "-13 -12 -11 "
+m4_dnl BOOST_M4_FOR(i, -13, -10, i )
+m4_dnl
+m4_dnl The following two lines will output:
+m4_dnl   "(0, 0) (0, 1) (0, 2) (0, 3) "
+m4_dnl   "(1, 0) (1, 1) (1, 2) (1, 3) "
+m4_dnl   "(2, 0) (2, 1) (2, 2) (2, 3) "
+m4_dnl   "(3, 0) (3, 1) (3, 2) (3, 3) "
+m4_dnl   "(4, 0) (4, 1) (4, 2) (4, 3) "
+m4_dnl   "(5, 0) (5, 1) (5, 2) (5, 3) "
+m4_dnl   "(6, 0) (6, 1) (6, 2) (6, 3) "
+m4_dnl   "(7, 0) (7, 1) (7, 2) (7, 3) "
+m4_dnl   ""
+m4_dnl BOOST_M4_FOR(i, 0, 8, BOOST_M4_FOR(j, 0, 4, (i, j) )
+m4_dnl )
+m4_dnl
+m4_dnl The following line will output (nothing):
+m4_dnl   ""
+m4_dnl BOOST_M4_FOR(i, 7, 0, i, |)
+m4_dnl
+m4_dnl The following line will output (nothing):
+m4_dnl   ""
+m4_dnl BOOST_M4_FOR(i, 0, 0, i, |)
+m4_dnl
+m4_dnl The following line will output:
+m4_dnl   "0|1|2|3|4|5|6"
+m4_dnl BOOST_M4_FOR(i, 0, 7, i, |)
+m4_dnl
+m4_dnl The following line will output:
+m4_dnl   "-13, -12, -11"
+m4_dnl BOOST_M4_FOR(i, -13, -10, i, `, ')
+m4_dnl
+m4_dnl The following two lines will output:
+m4_dnl   "[(0, 0), (0, 1), (0, 2), (0, 3)],"
+m4_dnl   "[(1, 0), (1, 1), (1, 2), (1, 3)],"
+m4_dnl   "[(2, 0), (2, 1), (2, 2), (2, 3)],"
+m4_dnl   "[(3, 0), (3, 1), (3, 2), (3, 3)],"
+m4_dnl   "[(4, 0), (4, 1), (4, 2), (4, 3)],"
+m4_dnl   "[(5, 0), (5, 1), (5, 2), (5, 3)],"
+m4_dnl   "[(6, 0), (6, 1), (6, 2), (6, 3)],"
+m4_dnl   "[(7, 0), (7, 1), (7, 2), (7, 3)]"
+m4_dnl BOOST_M4_FOR(i, 0, 8, `[BOOST_M4_FOR(j, 0, 4, (i, j), `, ')]', `,
+m4_dnl ')
+m4_dnl

data/ext/boost/pool/detail/guard.hpp

@@ -0,0 +1,69 @@
+// Copyright (C) 2000 Stephen Cleary
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POOL_GUARD_HPP
+#define BOOST_POOL_GUARD_HPP
+
+/*!
+  \file
+  \brief Extremely Light-Weight guard class.
+  \details Auto-lock/unlock-er
+  detail/guard.hpp provides a type guard<Mutex>
+  that allows scoped access to the Mutex's locking and unlocking operations.
+  It is used to ensure that a Mutex is unlocked, even if an exception is thrown.
+*/
+
+namespace boost {
+
+namespace details {
+namespace pool {
+
+template <typename Mutex> //!< \tparam Mutex (platform-specific) mutex class.
+class guard
+{ //! Locks the mutex, binding guard<Mutex> to Mutex.
+	/*! Example:
+	Given a (platform-specific) mutex class, we can wrap code as follows:
+
+	extern mutex global_lock;
+
+	static void f()
+	{
+		boost::details::pool::guard<mutex> g(global_lock);
+		// g's constructor locks "global_lock"
+
+		... // do anything:
+				//   throw exceptions
+				//   return
+				//   or just fall through
+	} // g's destructor unlocks "global_lock"
+	*/
+  private:
+    Mutex & mtx;
+
+    guard(const guard &); //!< Guards the mutex, ensuring unlocked on destruction, even if exception is thrown.
+    void operator=(const guard &);
+
+  public:
+    explicit guard(Mutex & nmtx)
+    :mtx(nmtx)
+    { //! Locks the mutex of the guard class.
+			mtx.lock();
+		}
+
+    ~guard()
+    { //! destructor unlocks the mutex of the guard class.
+			mtx.unlock();
+		}
+}; // class guard
+
+} // namespace pool
+} // namespace details
+
+} // namespace boost
+
+#endif

data/ext/boost/pool/detail/mutex.hpp

@@ -0,0 +1,42 @@
+// Copyright (C) 2000 Stephen Cleary
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POOL_MUTEX_HPP
+#define BOOST_POOL_MUTEX_HPP
+
+#include <boost/config.hpp>  // for workarounds
+#ifdef BOOST_HAS_THREADS
+#include <boost/thread/mutex.hpp>
+#endif
+
+namespace boost{ namespace details{ namespace pool{
+
+class null_mutex
+{
+  private:
+    null_mutex(const null_mutex &);
+    void operator=(const null_mutex &);
+
+  public:
+    null_mutex() { }
+
+    static void lock() { }
+    static void unlock() { }
+};
+
+#if !defined(BOOST_HAS_THREADS) || defined(BOOST_NO_MT) || defined(BOOST_POOL_NO_MT)
+  typedef null_mutex default_mutex;
+#else
+  typedef boost::mutex default_mutex;
+#endif
+
+} // namespace pool
+} // namespace details
+} // namespace boost
+
+#endif

data/ext/boost/pool/detail/pool_construct.bat

@@ -0,0 +1,24 @@
+@echo off
+rem
+rem Copyright (C) 2000, 2001 Stephen Cleary
+rem
+rem Distributed under the Boost Software License, Version 1.0. (See accompany-
+rem ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+
+rem Check for Windows NT
+if %OS%==Windows_NT goto NT
+
+rem Not NT - run m4 as normal, then exit
+m4 -P -E -DNumberOfArguments=%1 pool_construct.m4 > pool_construct.ipp
+goto end
+
+rem DJGPP programs (including m4) running on Windows/NT do NOT support long
+rem  file names (see the DJGPP v2 FAQ, question 8.1)
+rem Note that the output doesn't have to be a short name because it's an
+rem  argument to the command shell, not m4.
+:NT
+m4 -P -E -DNumberOfArguments=%1 < pool_construct.m4 > pool_construct.ipp
+
+:end

data/ext/boost/pool/detail/pool_construct.ipp

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