colouringcode-passenger 0.1

data/ext/boost/type_traits/detail/size_t_trait_def.hpp

@@ -0,0 +1,58 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+
+// $Source$
+// $Date: 2005-08-25 12:27:28 -0400 (Thu, 25 Aug 2005) $
+// $Revision: 30670 $
+
+#include <boost/type_traits/detail/template_arity_spec.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/mpl/size_t.hpp>
+
+#include <cstddef>
+
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300
+#   define BOOST_TT_AUX_SIZE_T_BASE(C) ::boost::integral_constant<std::size_t,C>
+#   define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/
+#else
+#   define BOOST_TT_AUX_SIZE_T_BASE(C) ::boost::mpl::size_t<C>
+#   define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
+    typedef ::boost::mpl::size_t<C> base_; \
+    using base_::value; \
+    /**/
+#endif
+
+
+#define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) \
+template< typename T > struct trait \
+    : BOOST_TT_AUX_SIZE_T_BASE(C) \
+{ \
+    BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
+}; \
+\
+BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
+/**/
+
+#define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) \
+template<> struct trait<spec> \
+    : BOOST_TT_AUX_SIZE_T_BASE(C) \
+{ \
+    BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
+}; \
+/**/
+
+#define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) \
+template< param > struct trait<spec> \
+    : BOOST_TT_AUX_SIZE_T_BASE(C) \
+{ \
+}; \
+/**/

data/ext/boost/type_traits/detail/size_t_trait_undef.hpp

@@ -0,0 +1,16 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+
+// $Source$
+// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
+// $Revision: 24874 $
+
+#undef BOOST_TT_AUX_SIZE_T_TRAIT_DEF1
+#undef BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1
+#undef BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1

data/ext/boost/type_traits/detail/template_arity_spec.hpp

@@ -0,0 +1,31 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/aux_/template_arity_fwd.hpp>
+#include <boost/mpl/aux_/preprocessor/params.hpp>
+#include <boost/mpl/aux_/config/lambda.hpp>
+#include <boost/mpl/aux_/config/overload_resolution.hpp>
+
+#if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \
+    && defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION)
+#   define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) \
+namespace mpl { namespace aux { \
+template< BOOST_MPL_PP_PARAMS(i, typename T) > \
+struct template_arity< \
+          name< BOOST_MPL_PP_PARAMS(i, T) > \
+        > \
+    : int_<i> \
+{ \
+}; \
+}} \
+/**/
+#else
+#   define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) /**/
+#endif

data/ext/boost/type_traits/detail/type_trait_def.hpp

@@ -0,0 +1,61 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+
+// $Source$
+// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
+// $Revision: 24874 $
+
+#include <boost/type_traits/detail/template_arity_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) \
+template< typename T > struct trait \
+{ \
+    typedef result type; \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
+}; \
+\
+BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
+/**/
+
+#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) \
+template<> struct trait<spec> \
+{ \
+    typedef result type; \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
+}; \
+/**/
+
+#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) \
+template<> struct trait##_impl<spec> \
+{ \
+    typedef result type; \
+}; \
+/**/
+
+#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) \
+template< param > struct trait<spec> \
+{ \
+    typedef result type; \
+}; \
+/**/
+
+#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) \
+template< param1, param2 > struct trait<spec> \
+{ \
+    typedef result; \
+}; \
+/**/
+
+#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) \
+template< param > struct trait##_impl<spec> \
+{ \
+    typedef result type; \
+}; \
+/**/

data/ext/boost/type_traits/detail/type_trait_undef.hpp

@@ -0,0 +1,19 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+
+// $Source$
+// $Date: 2004-09-02 11:41:37 -0400 (Thu, 02 Sep 2004) $
+// $Revision: 24874 $
+
+#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
+#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
+#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
+#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
+#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
+#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1

data/ext/boost/type_traits/detail/yes_no_type.hpp

@@ -0,0 +1,26 @@
+
+//  (C) Copyright John Maddock and Steve Cleary 2000.
+//  Use, modification and distribution are 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).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+//
+//  macros and helpers for working with integral-constant-expressions.
+
+#ifndef BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED
+#define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED
+
+namespace boost {
+namespace type_traits {
+
+typedef char yes_type;
+struct no_type
+{
+   char padding[8];
+};
+
+} // namespace type_traits
+} // namespace boost
+
+#endif // BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED

data/ext/boost/type_traits/function_traits.hpp

@@ -0,0 +1,236 @@
+
+//  Copyright 2000 John Maddock (john@johnmaddock.co.uk)
+//  Use, modification and distribution are 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).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
+#define BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/add_pointer.hpp>
+
+namespace boost {
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+namespace detail {
+
+template<typename Function> struct function_traits_helper;
+
+template<typename R>
+struct function_traits_helper<R (*)(void)>
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = 0);
+  typedef R result_type;
+};
+
+template<typename R, typename T1>
+struct function_traits_helper<R (*)(T1)>
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = 1);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T1 argument_type;
+};
+
+template<typename R, typename T1, typename T2>
+struct function_traits_helper<R (*)(T1, T2)>
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = 2);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T1 first_argument_type;
+  typedef T2 second_argument_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3>
+struct function_traits_helper<R (*)(T1, T2, T3)>
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = 3);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4>
+struct function_traits_helper<R (*)(T1, T2, T3, T4)>
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = 4);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = 5);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = 6);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = 7);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = 8);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = 9);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+  typedef T9 arg9_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9,
+         typename T10>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = 10);
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+  typedef T9 arg9_type;
+  typedef T10 arg10_type;
+};
+
+} // end namespace detail
+
+template<typename Function>
+struct function_traits : 
+   public detail::function_traits_helper<typename boost::add_pointer<Function>::type>
+{
+};
+
+#else
+
+namespace detail {
+
+template<unsigned N> 
+struct type_of_size
+{
+  char elements[N];
+};
+
+template<typename R>
+type_of_size<1> function_arity_helper(R (*f)());
+
+template<typename R, typename T1>
+type_of_size<2> function_arity_helper(R (*f)(T1));
+
+template<typename R, typename T1, typename T2>
+type_of_size<3> function_arity_helper(R (*f)(T1, T2));
+
+template<typename R, typename T1, typename T2, typename T3>
+type_of_size<4> function_arity_helper(R (*f)(T1, T2, T3));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4>
+type_of_size<5> function_arity_helper(R (*f)(T1, T2, T3, T4));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5>
+type_of_size<6> function_arity_helper(R (*f)(T1, T2, T3, T4, T5));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6>
+type_of_size<7> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7>
+type_of_size<8> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8>
+type_of_size<9> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9>
+type_of_size<10> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, 
+                                              T9));
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9,
+         typename T10>
+type_of_size<11> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, 
+                                              T9, T10));
+} // end namespace detail
+
+// Won't work with references
+template<typename Function>
+struct function_traits
+{
+  BOOST_STATIC_CONSTANT(unsigned, arity = (sizeof(detail::function_arity_helper((Function*)0))-1));
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+}
+
+#endif // BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED

data/ext/boost/type_traits/has_nothrow_copy.hpp

@@ -0,0 +1,39 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are 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).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED
+#define BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED
+
+#include <boost/type_traits/has_trivial_copy.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+namespace detail{
+
+template <class T>
+struct has_nothrow_copy_imp{
+   BOOST_STATIC_CONSTANT(bool, value = 
+      (::boost::type_traits::ice_or<
+         ::boost::has_trivial_copy<T>::value,
+         BOOST_HAS_NOTHROW_COPY(T)
+      >::value));
+};
+
+}
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_copy,T,::boost::detail::has_nothrow_copy_imp<T>::value)
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_copy_constructor,T,::boost::detail::has_nothrow_copy_imp<T>::value)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED

data/ext/boost/type_traits/has_trivial_copy.hpp

@@ -0,0 +1,49 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are 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).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
+#define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
+
+#include <boost/type_traits/config.hpp>
+#include <boost/type_traits/intrinsics.hpp>
+#include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/is_pod.hpp>
+#include <boost/type_traits/detail/ice_and.hpp>
+#include <boost/type_traits/detail/ice_or.hpp>
+#include <boost/type_traits/detail/ice_not.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_copy_impl
+{
+   BOOST_STATIC_CONSTANT(bool, value =
+      (::boost::type_traits::ice_and<
+         ::boost::type_traits::ice_or<
+            ::boost::is_pod<T>::value,
+            BOOST_HAS_TRIVIAL_COPY(T)
+         >::value,
+      ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value
+      >::value));
+};
+
+} // namespace detail
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_copy,T,::boost::detail::has_trivial_copy_impl<T>::value)
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_copy_constructor,T,::boost::detail::has_trivial_copy_impl<T>::value)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED

data/ext/boost/type_traits/ice.hpp

@@ -0,0 +1,20 @@
+
+//  (C) Copyright John Maddock and Steve Cleary 2000.
+//  Use, modification and distribution are 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).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+//
+//  macros and helpers for working with integral-constant-expressions.
+
+#ifndef BOOST_TT_ICE_HPP_INCLUDED
+#define BOOST_TT_ICE_HPP_INCLUDED
+
+#include <boost/type_traits/detail/yes_no_type.hpp>
+#include <boost/type_traits/detail/ice_or.hpp>
+#include <boost/type_traits/detail/ice_and.hpp>
+#include <boost/type_traits/detail/ice_not.hpp>
+#include <boost/type_traits/detail/ice_eq.hpp>
+
+#endif // BOOST_TT_ICE_HPP_INCLUDED

data/ext/boost/type_traits/integral_constant.hpp

@@ -0,0 +1,53 @@
+//  (C) Copyright John Maddock 2005. 
+//  Use, modification and distribution are 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_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
+#define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/integral_c.hpp>
+
+namespace boost{
+
+#if defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS) || defined(__BORLANDC__)
+template <class T, int val>
+#else
+template <class T, T val>
+#endif
+struct integral_constant : public mpl::integral_c<T, val>
+{
+   typedef integral_constant<T,val> type;
+};
+
+template<> struct integral_constant<bool,true> : public mpl::true_ 
+{
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# pragma warning(push)
+# pragma warning(disable:4097)
+   typedef mpl::true_ base_;
+   using base_::value;
+# pragma warning(pop)
+#endif
+   typedef integral_constant<bool,true> type;
+};
+template<> struct integral_constant<bool,false> : public mpl::false_ 
+{
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# pragma warning(push)
+# pragma warning(disable:4097)
+   typedef mpl::false_ base_;
+   using base_::value;
+# pragma warning(pop)
+#endif
+   typedef integral_constant<bool,false> type;
+};
+
+typedef integral_constant<bool,true> true_type;
+typedef integral_constant<bool,false> false_type;
+
+}
+
+#endif