mewin/glm
1
0
Fork 0
Code Releases Activity

Added boost header

Browse Source
This commit is contained in:
Christophe Riccio
2012-01-08 01:26:07 +00:00
parent 9c3faaca40
commit c7d752cdf8
8946 changed files with 1732316 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
test/external/boost/tr1/array.hpp vendored Normal file
View File

@@ -0,0 +1,88 @@
// (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_TR1_ARRAY_HPP_INCLUDED
# define BOOST_TR1_ARRAY_HPP_INCLUDED
# include <boost/tr1/detail/config.hpp>
#ifdef BOOST_HAS_TR1_ARRAY
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(array)
# else
# include <boost/tr1/detail/config_all.hpp>
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(array))
# endif
#else
#include <boost/array.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/detail/workaround.hpp>
namespace std{ namespace tr1{
using ::boost::array;
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
// [6.1.3.2] Tuple creation functions
using ::boost::swap;
#endif
#if !defined(BOOST_TR1_USE_OLD_TUPLE)
}} namespace boost{ namespace fusion{
#endif
// [6.2.2.5] Tuple interface to class template array
template <class T> struct tuple_size; // forward declaration
template <int I, class T> struct tuple_element; // forward declaration
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <class T, size_t N>
struct tuple_size< ::boost::array<T, N> >
: public ::boost::integral_constant< ::std::size_t, N>{};
template <int I, class T, size_t N>
struct tuple_element<I, ::boost::array<T, N> >
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570))
BOOST_STATIC_ASSERT(I < (int)N);
BOOST_STATIC_ASSERT(I >= 0);
#endif
typedef T type;
};
#endif
template <int I, class T, size_t N>
T& get( ::boost::array<T, N>& a)
{
BOOST_STATIC_ASSERT(I < N);
BOOST_STATIC_ASSERT(I >= 0);
return a[I];
}
template <int I, class T, size_t N>
const T& get(const array<T, N>& a)
{
BOOST_STATIC_ASSERT(I < N);
BOOST_STATIC_ASSERT(I >= 0);
return a[I];
}
#if !defined(BOOST_TR1_USE_OLD_TUPLE)
}} namespace std{ namespace tr1{
using ::boost::fusion::tuple_size;
using ::boost::fusion::tuple_element;
using ::boost::fusion::get;
#endif
} } // namespaces
#endif
#endif

267
test/external/boost/tr1/cmath.hpp vendored Normal file
View File

@@ -0,0 +1,267 @@
// (C) Copyright John Maddock 2008.
// 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_TR1_CMATH_HPP_INCLUDED
# define BOOST_TR1_CMATH_HPP_INCLUDED
# include <boost/tr1/detail/config.hpp>
#ifdef BOOST_HAS_TR1_CMATH
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(cmath)
# else
# include <boost/tr1/detail/config_all.hpp>
# include BOOST_TR1_HEADER(cmath)
# endif
#else
#include <boost/math/tr1.hpp>
namespace std{ namespace tr1{
using boost::math::tr1::assoc_laguerre;
using boost::math::tr1::assoc_laguerref;
using boost::math::tr1::assoc_laguerrel;
// [5.2.1.2] associated Legendre functions:
using boost::math::tr1::assoc_legendre;
using boost::math::tr1::assoc_legendref;
using boost::math::tr1::assoc_legendrel;
// [5.2.1.3] beta function:
using boost::math::tr1::beta;
using boost::math::tr1::betaf;
using boost::math::tr1::betal;
// [5.2.1.4] (complete) elliptic integral of the first kind:
using boost::math::tr1::comp_ellint_1;
using boost::math::tr1::comp_ellint_1f;
using boost::math::tr1::comp_ellint_1l;
// [5.2.1.5] (complete) elliptic integral of the second kind:
using boost::math::tr1::comp_ellint_2;
using boost::math::tr1::comp_ellint_2f;
using boost::math::tr1::comp_ellint_2l;
// [5.2.1.6] (complete) elliptic integral of the third kind:
using boost::math::tr1::comp_ellint_3;
using boost::math::tr1::comp_ellint_3f;
using boost::math::tr1::comp_ellint_3l;
#if 0
// [5.2.1.7] confluent hypergeometric functions:
using boost::math::tr1::conf_hyperg;
using boost::math::tr1::conf_hypergf;
using boost::math::tr1::conf_hypergl;
#endif
// [5.2.1.8] regular modified cylindrical Bessel functions:
using boost::math::tr1::cyl_bessel_i;
using boost::math::tr1::cyl_bessel_if;
using boost::math::tr1::cyl_bessel_il;
// [5.2.1.9] cylindrical Bessel functions (of the first kind):
using boost::math::tr1::cyl_bessel_j;
using boost::math::tr1::cyl_bessel_jf;
using boost::math::tr1::cyl_bessel_jl;
// [5.2.1.10] irregular modified cylindrical Bessel functions:
using boost::math::tr1::cyl_bessel_k;
using boost::math::tr1::cyl_bessel_kf;
using boost::math::tr1::cyl_bessel_kl;
// [5.2.1.11] cylindrical Neumann functions;
// cylindrical Bessel functions (of the second kind):
using boost::math::tr1::cyl_neumann;
using boost::math::tr1::cyl_neumannf;
using boost::math::tr1::cyl_neumannl;
// [5.2.1.12] (incomplete) elliptic integral of the first kind:
using boost::math::tr1::ellint_1;
using boost::math::tr1::ellint_1f;
using boost::math::tr1::ellint_1l;
// [5.2.1.13] (incomplete) elliptic integral of the second kind:
using boost::math::tr1::ellint_2;
using boost::math::tr1::ellint_2f;
using boost::math::tr1::ellint_2l;
// [5.2.1.14] (incomplete) elliptic integral of the third kind:
using boost::math::tr1::ellint_3;
using boost::math::tr1::ellint_3f;
using boost::math::tr1::ellint_3l;
// [5.2.1.15] exponential integral:
using boost::math::tr1::expint;
using boost::math::tr1::expintf;
using boost::math::tr1::expintl;
// [5.2.1.16] Hermite polynomials:
using boost::math::tr1::hermite;
using boost::math::tr1::hermitef;
using boost::math::tr1::hermitel;
#if 0
// [5.2.1.17] hypergeometric functions:
using boost::math::tr1::hyperg;
using boost::math::tr1::hypergf;
using boost::math::tr1::hypergl;
#endif
// [5.2.1.18] Laguerre polynomials:
using boost::math::tr1::laguerre;
using boost::math::tr1::laguerref;
using boost::math::tr1::laguerrel;
// [5.2.1.19] Legendre polynomials:
using boost::math::tr1::legendre;
using boost::math::tr1::legendref;
using boost::math::tr1::legendrel;
// [5.2.1.20] Riemann zeta function:
using boost::math::tr1::riemann_zeta;
using boost::math::tr1::riemann_zetaf;
using boost::math::tr1::riemann_zetal;
// [5.2.1.21] spherical Bessel functions (of the first kind):
using boost::math::tr1::sph_bessel;
using boost::math::tr1::sph_besself;
using boost::math::tr1::sph_bessell;
// [5.2.1.22] spherical associated Legendre functions:
using boost::math::tr1::sph_legendre;
using boost::math::tr1::sph_legendref;
using boost::math::tr1::sph_legendrel;
// [5.2.1.23] spherical Neumann functions;
// spherical Bessel functions (of the second kind):
using boost::math::tr1::sph_neumann;
using boost::math::tr1::sph_neumannf;
using boost::math::tr1::sph_neumannl;
// types
using boost::math::tr1::double_t;
using boost::math::tr1::float_t;
// functions
using boost::math::tr1::acosh;
using boost::math::tr1::acoshf;
using boost::math::tr1::acoshl;
using boost::math::tr1::asinh;
using boost::math::tr1::asinhf;
using boost::math::tr1::asinhl;
using boost::math::tr1::atanh;
using boost::math::tr1::atanhf;
using boost::math::tr1::atanhl;
using boost::math::tr1::cbrt;
using boost::math::tr1::cbrtf;
using boost::math::tr1::cbrtl;
using boost::math::tr1::copysign;
using boost::math::tr1::copysignf;
using boost::math::tr1::copysignl;
using boost::math::tr1::erf;
using boost::math::tr1::erff;
using boost::math::tr1::erfl;
using boost::math::tr1::erfc;
using boost::math::tr1::erfcf;
using boost::math::tr1::erfcl;
#if 0
using boost::math::tr1::exp2;
using boost::math::tr1::exp2f;
using boost::math::tr1::exp2l;
#endif
using boost::math::tr1::expm1;
using boost::math::tr1::expm1f;
using boost::math::tr1::expm1l;
#if 0
using boost::math::tr1::fdim;
using boost::math::tr1::fdimf;
using boost::math::tr1::fdiml;
using boost::math::tr1::fma;
using boost::math::tr1::fmaf;
using boost::math::tr1::fmal;
#endif
using boost::math::tr1::fmax;
using boost::math::tr1::fmaxf;
using boost::math::tr1::fmaxl;
using boost::math::tr1::fmin;
using boost::math::tr1::fminf;
using boost::math::tr1::fminl;
using boost::math::tr1::hypot;
using boost::math::tr1::hypotf;
using boost::math::tr1::hypotl;
#if 0
using boost::math::tr1::ilogb;
using boost::math::tr1::ilogbf;
using boost::math::tr1::ilogbl;
#endif
using boost::math::tr1::lgamma;
using boost::math::tr1::lgammaf;
using boost::math::tr1::lgammal;
#if 0
using boost::math::tr1::llrint;
using boost::math::tr1::llrintf;
using boost::math::tr1::llrintl;
#endif
using boost::math::tr1::llround;
using boost::math::tr1::llroundf;
using boost::math::tr1::llroundl;
using boost::math::tr1::log1p;
using boost::math::tr1::log1pf;
using boost::math::tr1::log1pl;
#if 0
using boost::math::tr1::log2;
using boost::math::tr1::log2f;
using boost::math::tr1::log2l;
using boost::math::tr1::logb;
using boost::math::tr1::logbf;
using boost::math::tr1::logbl;
using boost::math::tr1::lrint;
using boost::math::tr1::lrintf;
using boost::math::tr1::lrintl;
#endif
using boost::math::tr1::lround;
using boost::math::tr1::lroundf;
using boost::math::tr1::lroundl;
#if 0
using boost::math::tr1::nan;
using boost::math::tr1::nanf;
using boost::math::tr1::nanl;
using boost::math::tr1::nearbyint;
using boost::math::tr1::nearbyintf;
using boost::math::tr1::nearbyintl;
#endif
using boost::math::tr1::nextafter;
using boost::math::tr1::nextafterf;
using boost::math::tr1::nextafterl;
using boost::math::tr1::nexttoward;
using boost::math::tr1::nexttowardf;
using boost::math::tr1::nexttowardl;
#if 0
using boost::math::tr1::remainder;
using boost::math::tr1::remainderf;
using boost::math::tr1::remainderl;
using boost::math::tr1::remquo;
using boost::math::tr1::remquof;
using boost::math::tr1::remquol;
using boost::math::tr1::rint;
using boost::math::tr1::rintf;
using boost::math::tr1::rintl;
#endif
using boost::math::tr1::round;
using boost::math::tr1::roundf;
using boost::math::tr1::roundl;
#if 0
using boost::math::tr1::scalbln;
using boost::math::tr1::scalblnf;
using boost::math::tr1::scalblnl;
using boost::math::tr1::scalbn;
using boost::math::tr1::scalbnf;
using boost::math::tr1::scalbnl;
#endif
using boost::math::tr1::tgamma;
using boost::math::tr1::tgammaf;
using boost::math::tr1::tgammal;
using boost::math::tr1::trunc;
using boost::math::tr1::truncf;
using boost::math::tr1::truncl;
// C99 macros defined as C++ templates
using boost::math::tr1::signbit;
using boost::math::tr1::fpclassify;
using boost::math::tr1::isfinite;
using boost::math::tr1::isinf;
using boost::math::tr1::isnan;
using boost::math::tr1::isnormal;
#if 0
using boost::math::tr1::isgreater;
using boost::math::tr1::isgreaterequal;
using boost::math::tr1::isless;
using boost::math::tr1::islessequal;
using boost::math::tr1::islessgreater;
using boost::math::tr1::isunordered;
#endif
} } // namespaces
#endif // BOOST_HAS_TR1_CMATH
#endif // BOOST_TR1_CMATH_HPP_INCLUDED

244
test/external/boost/tr1/complex.hpp vendored Normal file
View File

@@ -0,0 +1,244 @@
// (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_TR1_COMPLEX_HPP_INCLUDED
# define BOOST_TR1_COMPLEX_HPP_INCLUDED
# include <boost/tr1/detail/config.hpp>
# include <complex>
#ifndef BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
#include <boost/math/complex.hpp>
namespace std {
namespace tr1 {
using boost::math::acos;
using boost::math::asin;
using boost::math::atan;
using boost::math::acosh;
using boost::math::asinh;
using boost::math::atanh;
using boost::math::fabs;
} }
#else
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(complex)
# else
# include <boost/tr1/detail/config_all.hpp>
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(complex))
# endif
#endif
#ifndef BOOST_HAS_TR1_COMPLEX_OVERLOADS
#include <boost/tr1/detail/math_overloads.hpp>
#include <boost/assert.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/config/no_tr1/cmath.hpp>
namespace std{
#ifdef BOOST_NO_STDC_NAMESPACE
using :: atan2;
#endif
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template <class T>
inline BOOST_TR1_MATH_RETURN(double) arg(const T& t)
{
return ::std::atan2(0.0, static_cast<double>(t));
}
#else
inline double arg(const double& t)
{
return ::std::atan2(0.0, t);
}
#endif
inline long double arg(const long double& t)
{
return ::std::atan2(0.0L, static_cast<long double>(t));
}
inline float arg(const float& t)
{
return ::std::atan2(0.0F, static_cast<float>(t));
}
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template <class T>
inline BOOST_TR1_MATH_RETURN(double) norm(const T& t)
{
double r = static_cast<double>(t);
return r*r;
}
#else
inline double norm(const double& t)
{
return t*t;
}
#endif
inline long double norm(const long double& t)
{
long double l = t;
return l*l;
}
inline float norm(const float& t)
{
float f = t;
return f*f;
}
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template <class T>
inline BOOST_TR1_MATH_RETURN(std::complex<double>) conj(const T& t)
{
return ::std::conj(std::complex<double>(static_cast<double>(t)));
}
#else
inline std::complex<double> conj(const double& t)
{
return ::std::conj(std::complex<double>(t));
}
#endif
inline std::complex<long double> conj(const long double& t)
{
return ::std::conj(std::complex<long double>(t));
}
inline std::complex<float> conj(const float& t)
{
std::complex<float> ct(t);
ct = ::std::conj(ct);
return ct;
}
#if !BOOST_WORKAROUND(__BORLANDC__, <=0x570) && !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
inline complex<double> polar(const char& rho, const char& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
inline complex<double> polar(const unsigned char& rho, const unsigned char& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
inline complex<double> polar(const signed char& rho, const signed char& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
inline complex<double> polar(const short& rho, const short& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
inline complex<double> polar(const unsigned short& rho, const unsigned short& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
inline complex<double> polar(const int& rho, const int& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
inline complex<double> polar(const unsigned int& rho, const unsigned int& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
inline complex<double> polar(const long& rho, const long& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
inline complex<double> polar(const unsigned long& rho, const unsigned long& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
#ifdef BOOST_HAS_LONG_LONG
inline complex<double> polar(const long long& rho, const long long& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
inline complex<double> polar(const unsigned long long& rho, const unsigned long long& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
#elif defined(BOOST_HAS_MS_INT64)
inline complex<double> polar(const __int64& rho, const __int64& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
inline complex<double> polar(const unsigned __int64& rho, const unsigned __int64& theta = 0)
{ return ::std::polar(static_cast<double>(rho), static_cast<double>(theta)); }
#endif
template<class T, class U>
inline complex<typename boost::tr1_detail::promote_to_real<T, U>::type>
polar(const T& rho, const U& theta)
{
typedef typename boost::tr1_detail::promote_to_real<T, U>::type real_type;
return std::polar(static_cast<real_type>(rho), static_cast<real_type>(theta));
}
#endif
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template <class T>
inline BOOST_TR1_MATH_RETURN(double) imag(const T& )
{
return 0;
}
#else
inline double imag(const double& )
{
return 0;
}
#endif
inline long double imag(const long double& )
{
return 0;
}
inline float imag(const float& )
{
return 0;
}
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template <class T>
inline BOOST_TR1_MATH_RETURN(double) real(const T& t)
{
return static_cast<double>(t);
}
#else
inline double real(const double& t)
{
return t;
}
#endif
inline long double real(const long double& t)
{
return t;
}
inline float real(const float& t)
{
return t;
}
template<class T, class U>
inline complex<typename boost::tr1_detail::largest_real<T, U>::type>
pow(const complex<T>& x, const complex<U>& y)
{
typedef complex<typename boost::tr1_detail::largest_real<T, U>::type> result_type;
typedef typename boost::mpl::if_<boost::is_same<result_type, complex<T> >, result_type const&, result_type>::type cast1_type;
typedef typename boost::mpl::if_<boost::is_same<result_type, complex<U> >, result_type const&, result_type>::type cast2_type;
cast1_type x1(x);
cast2_type y1(y);
return std::pow(x1, y1);
}
template<class T, class U>
inline complex<typename boost::tr1_detail::promote_to_real<T, U>::type>
pow (const complex<T>& x, const U& y)
{
typedef typename boost::tr1_detail::promote_to_real<T, U>::type real_type;
typedef complex<typename boost::tr1_detail::promote_to_real<T, U>::type> result_type;
typedef typename boost::mpl::if_<boost::is_same<result_type, complex<T> >, result_type const&, result_type>::type cast1_type;
real_type r = y;
cast1_type x1(x);
std::complex<real_type> y1(r);
return std::pow(x1, y1);
}
template<class T, class U>
inline complex<typename boost::tr1_detail::promote_to_real<T, U>::type>
pow (const T& x, const complex<U>& y)
{
typedef typename boost::tr1_detail::promote_to_real<T, U>::type real_type;
typedef complex<typename boost::tr1_detail::promote_to_real<T, U>::type> result_type;
typedef typename boost::mpl::if_<boost::is_same<result_type, complex<U> >, result_type const&, result_type>::type cast_type;
real_type r = x;
std::complex<real_type> x1(r);
cast_type y1(y);
return std::pow(x1, y1);
}
}
#endif
#endif

169
test/external/boost/tr1/detail/config.hpp vendored Normal file
View File

@@ -0,0 +1,169 @@
// (C) Copyright John Maddock 2005-7.
// 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_TR1_DETAIL_CONFIG_HPP_INCLUDED
# define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
#include <cstddef>
#if (defined(__GNUC__) && !(defined(linux) || defined(__linux) || defined(__linux__))) \
|| (!defined(_AIX) && defined(__IBMCPP__) && (__IBMCPP__ >= 800))
// Disable use of #include_next on Linux as typically we are installed in a
// directory that is searched *after* the std lib include path.
#if !defined(BOOST_HAS_INCLUDE_NEXT)
# define BOOST_HAS_INCLUDE_NEXT
#endif
// Need to find out if we're using GLIBC:
#ifdef BOOST_TR1_UTILITY_INCLUDED
// Oops we're in a recursive include path!!
// Need to include utility, or some std lib header,
// but *not* via <utility> or <boost/config/no_tr1/utility.hpp>
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_CONFIG_RECURSION
# endif
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <utility>
# else
# include BOOST_TR1_STD_HEADER(utility)
# endif
# ifdef BOOST_TR1_NO_CONFIG_RECURSION
# undef BOOST_TR1_NO_CONFIG_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#else
#include <boost/config/no_tr1/utility.hpp>
#endif
#endif
#if defined(__GLIBCXX__) && !defined(BOOST_TR1_PATH)
# define BOOST_TR1_PATH(name) tr1/name
#endif
#if !defined(BOOST_TR1_PATH)
# define BOOST_TR1_PATH(name) name
#endif
#define BOOST_TR1_HEADER(name) <BOOST_TR1_PATH(name)>
// Can't use BOOST_WORKAROUND here, it leads to recursive includes:
#if (defined(__BORLANDC__) && (__BORLANDC__ <= 0x600)) || (defined(_MSC_VER) && (_MSC_VER < 1310))
# define BOOST_TR1_USE_OLD_TUPLE
#endif
#ifdef __IBMCPP_TR1__
// turn on support for everything:
# define BOOST_HAS_TR1
#endif
#ifdef __GXX_EXPERIMENTAL_CXX0X__
# define BOOST_HAS_TR1_COMPLEX_OVERLOADS
# define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
#endif
#ifdef BOOST_HAS_TR1
// turn on support for everything:
# define BOOST_HAS_TR1_ARRAY
# define BOOST_HAS_TR1_COMPLEX_OVERLOADS
# define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
# define BOOST_HAS_TR1_REFERENCE_WRAPPER
# define BOOST_HAS_TR1_RESULT_OF
# define BOOST_HAS_TR1_MEM_FN
# define BOOST_HAS_TR1_BIND
# define BOOST_HAS_TR1_FUNCTION
# define BOOST_HAS_TR1_HASH
# define BOOST_HAS_TR1_SHARED_PTR
# define BOOST_HAS_TR1_RANDOM
# define BOOST_HAS_TR1_REGEX
# define BOOST_HAS_TR1_TUPLE
# define BOOST_HAS_TR1_TYPE_TRAITS
# define BOOST_HAS_TR1_UTILITY
# define BOOST_HAS_TR1_UNORDERED_MAP
# define BOOST_HAS_TR1_UNORDERED_SET
# define BOOST_HAS_TR1_CMATH
#endif
#if defined(__MWERKS__) && (__MWERKS__ >= 0x3205)
//
// Very preliminary MWCW support, may not be right:
//
# define BOOST_HAS_TR1_SHARED_PTR
# define BOOST_HAS_TR1_REFERENCE_WRAPPER
# define BOOST_HAS_TR1_FUNCTION
# define BOOST_HAS_TR1_TUPLE
# define BOOST_HAS_TR1_RESULT_OF
#endif
#ifdef BOOST_HAS_GCC_TR1
// turn on support for everything in gcc 4.0.x:
# define BOOST_HAS_TR1_ARRAY
#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 403
//# define BOOST_HAS_TR1_COMPLEX_OVERLOADS
# define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
#endif
# define BOOST_HAS_TR1_REFERENCE_WRAPPER
# define BOOST_HAS_TR1_RESULT_OF
# define BOOST_HAS_TR1_MEM_FN
# define BOOST_HAS_TR1_BIND
# define BOOST_HAS_TR1_FUNCTION
# define BOOST_HAS_TR1_HASH
# define BOOST_HAS_TR1_SHARED_PTR
#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 403
# define BOOST_HAS_TR1_RANDOM
//# define BOOST_HAS_TR1_REGEX
#ifdef _GLIBCXX_USE_C99_MATH_TR1
# define BOOST_HAS_TR1_CMATH
#endif
#endif
# define BOOST_HAS_TR1_TUPLE
# define BOOST_HAS_TR1_TYPE_TRAITS
# define BOOST_HAS_TR1_UTILITY
# define BOOST_HAS_TR1_UNORDERED_MAP
# define BOOST_HAS_TR1_UNORDERED_SET
#endif
#if defined(_MSC_VER) && (_MSC_VER >= 1500) \
&& defined(_MSC_FULL_VER) && \
!defined(__SGI_STL_PORT) && \
!defined(_STLPORT_VERSION) && \
!defined(_RWSTD_VER_STR) && \
!defined(_RWSTD_VER)
//
// MSVC-9.0 defines a not-quite TR1 conforming hash
// function object in <functional>, so we must define
// this here, in addition the feature pack for VC9
// provides a more or less full TR1 implementation:
//
# if defined(_HAS_TR1) && (_HAS_TR1 + 0)
# define BOOST_HAS_TR1_ARRAY
# define BOOST_HAS_TR1_REFERENCE_WRAPPER
# define BOOST_HAS_TR1_RESULT_OF
# define BOOST_HAS_TR1_MEM_FN
# define BOOST_HAS_TR1_BIND
# define BOOST_HAS_TR1_FUNCTION
# define BOOST_HAS_TR1_HASH
# define BOOST_HAS_TR1_SHARED_PTR
# define BOOST_HAS_TR1_RANDOM
# define BOOST_HAS_TR1_REGEX
# define BOOST_HAS_TR1_TUPLE
# define BOOST_HAS_TR1_TYPE_TRAITS
# define BOOST_HAS_TR1_UTILITY
# define BOOST_HAS_TR1_UNORDERED_MAP
# define BOOST_HAS_TR1_UNORDERED_SET
# else
# define BOOST_HAS_TR1_HASH
# endif
# if _MSC_VER >= 1600
# define BOOST_HAS_CPP_0X
# endif
#endif
#include <boost/config.hpp>
#endif

168
test/external/boost/tr1/detail/config_all.hpp vendored Normal file
View File

@@ -0,0 +1,168 @@
// (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)
/*
* The gcc include path logic is derived from STLport:
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Copyright (c) 1996-1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999-2003
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef BOOST_TR1_DETAIL_CONFIG_ALL_HPP_INCLUDED
# define BOOST_TR1_DETAIL_CONFIG_ALL_HPP_INCLUDED
//
// IMPORTANT: we must figure out the basics, such as how to
// forward to the real std lib headers *without* including
// boost/config.hpp or any of the std lib headers. A classic
// chicken and the egg problem....
//
// Including <cstddef> at least lets us detect STLport:
//
#include <cstddef>
// Including <cstdlib> allows us to use __GLIBCXX__ to
// determine the version of the stdc++ library in use
// under Darwin.
#include <cstdlib>
# if defined(_RWSTD_VER) && _RWSTD_VER >= 0x04010200
# if !defined (__SUNPRO_CC) && !defined (__DECCXX)
# define BOOST_TR1_STD_CHEADER(name) <../include/ansi/name>
# endif
# endif
# if (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) && !defined(__BORLANDC__)
# ifdef __SUNPRO_CC
// can't use <../stlport/name> since some compilers put stlport in a different directory:
# define BOOST_TR1_STD_HEADER(name) <../stlport4/name>
# elif defined(__PGI)
# define BOOST_TR1_STD_HEADER(name) <../CC/name>
# else
# define BOOST_TR1_STD_HEADER(name) <../stlport/name>
# endif
# elif defined(__PATHSCALE__) && (defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER))
# define BOOST_TR1_STD_HEADER(name) <../include/name>
# elif defined(__SUNPRO_CC) && (defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER))
# define BOOST_TR1_STD_HEADER(name) <../stdcxx4/name>
# elif defined(__HP_aCC)
// HP aCC include path:
# define BOOST_TR1_STD_HEADER(name) <../include_std/name>
# elif defined(__DECCXX)
# define BOOST_TR1_STD_HEADER(name) <../cxx/name>
# elif defined(__BORLANDC__) && __BORLANDC__ >= 0x570
# define BOOST_TR1_STD_HEADER(name) <../include/dinkumware/name>
# elif defined(__clang__)
# define BOOST_TR1_STD_HEADER(name) <../include/name>
# elif defined(__GNUC__) && __GNUC__ >= 3
# if defined(BOOST_TR1_GCC_INCLUDE_PATH)
# define BOOST_TR1_STD_HEADER(name) <../BOOST_TR1_GCC_INCLUDE_PATH/name>
# elif ( (__GNUC__ == 3 ) && ((__GNUC_MINOR__ == 0) || ((__GNUC_MINOR__ < 3) && defined(__APPLE_CC__))))
# define BOOST_TR1_STD_HEADER(name) <../g++-v3/name>
# else
# if ( ((__GNUC__ == 3 ) && (__GNUC_MINOR__ >= 3)) && (defined(__APPLE_CC__) || defined(__CYGWIN__)))
# define BOOST_TR1_STD_HEADER(name) <../c++/name>
# elif ((__GLIBCXX__ == 20050421) && defined(__APPLE_CC__))
// Some Darwin tools fix libstdc++ at 4.0.0 irrespective of the actual
// compiler version:
# define BOOST_TR1_STD_HEADER(name) <../4.0.0/name>
/*
* Before version 3.4.0 the 0 patch level was not part of the include path:
*/
# elif defined (__GNUC_PATCHLEVEL__) && ((__GNUC_PATCHLEVEL__ > 0) || \
(__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
(__GNUC__ > 3))
# define BOOST_TR1_STD_HEADER(name) <../__GNUC__.__GNUC_MINOR__.__GNUC_PATCHLEVEL__/name>
# else
# define BOOST_TR1_STD_HEADER(name) <../__GNUC__.__GNUC_MINOR__/name>
# endif
# endif
# if !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT) && !defined(__ICC) \
&& (defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__))
// Disable use of #include_next on Linux as typically we are installed in a directory that is searched
// *after* the std lib include path:
# define BOOST_TR1_DISABLE_INCLUDE_NEXT
# endif
# else
# define BOOST_TR1_STD_HEADER(name) <../include/name>
# endif
#if !defined(BOOST_TR1_STD_CHEADER)
# define BOOST_TR1_STD_CHEADER(name) BOOST_TR1_STD_HEADER(name)
#endif
#if defined(__GNUC__) && !defined(BOOST_HAS_INCLUDE_NEXT)
# define BOOST_HAS_INCLUDE_NEXT
#endif
#ifdef __GXX_EXPERIMENTAL_CXX0X__
# define BOOST_HAS_CPP_0X
#endif
#if defined(_MSC_VER) && (_MSC_VER >= 1600) && !defined(BOOST_HAS_CPP_0X)
# define BOOST_HAS_CPP_0X
#endif
//
// We may be in the middle of parsing boost/config.hpp
// when this header is included, so don't rely on config
// stuff in the rest of this header...
//
// Find our actual std lib:
//
#if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
//
// We don't take this branch if BOOST_TR1_DISABLE_INCLUDE_NEXT
// is defined as we may be installed in
// /usr/include, in which case #include_next won't work as our
// include path will occur AFTER the regular std lib one :-(
//
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_CONFIG_ALL_RECURSION
# endif
# include_next <utility>
# if (__GNUC__ < 3)
# include_next <algorithm>
# include_next <iterator>
# endif
# ifdef BOOST_TR1_NO_CONFIG_ALL_RECURSION
# undef BOOST_TR1_NO_CONFIG_ALL_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#else
# include BOOST_TR1_STD_HEADER(utility)
#endif
#include <boost/tr1/detail/config.hpp>
#endif

34
test/external/boost/tr1/detail/functor2iterator.hpp vendored Normal file
View File

@@ -0,0 +1,34 @@
// (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_TR1_FUNCTOR_IT_HPP_INCLUDED
# define BOOST_TR1_FUNCTOR_IT_HPP_INCLUDED
# include <boost/iterator/iterator_facade.hpp>
namespace boost{ namespace tr1_details{
template <class Func, class R>
struct functor2iterator : boost::iterator_facade<functor2iterator<Func,R>, const R, std::input_iterator_tag>
{
functor2iterator() : m_func(0){}
functor2iterator(Func& f)
: m_func(&f)
{
m_val = (*m_func)();
}
const R& dereference()const
{ return m_val; }
void increment(){ m_val = (*m_func)(); }
bool equal(const functor2iterator&)const
{ return false; }
private:
Func* m_func;
R m_val;
};
} }
#endif

58
test/external/boost/tr1/detail/math_overloads.hpp vendored Normal file
View File

@@ -0,0 +1,58 @@
// (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_TR1_MATH_OVERLOADS_HPP_INCLUDED
# define BOOST_TR1_MATH_OVERLOADS_HPP_INCLUDED
# include <boost/config.hpp>
# ifndef BOOST_NO_SFINAE
# include <boost/utility/enable_if.hpp>
# include <boost/type_traits/is_convertible.hpp>
# define BOOST_TR1_MATH_RETURN(RET) typename ::boost::enable_if< ::boost::is_convertible<T,double>, RET >::type
# else
# define BOOST_TR1_MATH_RETURN(RET) RET
# endif
# include <boost/type_traits/is_floating_point.hpp>
# include <boost/type_traits/is_same.hpp>
# include <boost/mpl/if.hpp>
namespace boost{ namespace tr1_detail{
template <class T, class U>
struct largest_real
{
typedef typename boost::mpl::if_<
boost::is_same<long double, T>,
long double,
typename boost::mpl::if_<
boost::is_same<long double, U>,
long double,
typename boost::mpl::if_<
boost::is_same<double, T>,
double,
typename boost::mpl::if_<
boost::is_same<double, U>,
double,
float
>::type
>::type
>::type
>::type type;
};
template <class T, class U>
struct promote_to_real
{
typedef typename largest_real<
typename boost::mpl::if_< boost::is_floating_point<T>, T, double>::type,
typename boost::mpl::if_< boost::is_floating_point<U>, U, double>::type
>::type type;
};
} }
#endif

145
test/external/boost/tr1/functional.hpp vendored Normal file
View File

@@ -0,0 +1,145 @@
// (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_TR1_FUNCTIONAL_HPP_INCLUDED
# define BOOST_TR1_FUNCTIONAL_HPP_INCLUDED
# include <boost/tr1/detail/config.hpp>
# include <functional>
#if defined(BOOST_HAS_TR1_REFERENCE_WRAPPER) \
|| defined(BOOST_HAS_TR1_RESULT_OF)\
|| defined(BOOST_HAS_TR1_MEM_FN)\
|| defined(BOOST_HAS_TR1_BIND)\
|| defined(BOOST_HAS_TR1_FUNCTION)\
|| defined(BOOST_HAS_TR1_HASH)
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(functional)
# else
# include <boost/tr1/detail/config_all.hpp>
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(functional))
# endif
#endif
#ifndef BOOST_HAS_TR1_REFERENCE_WRAPPER
#include <boost/ref.hpp>
namespace std{ namespace tr1{
using ::boost::reference_wrapper;
using ::boost::ref;
using ::boost::cref;
} }
#endif // BOOST_HAS_TR1_REFERENCE_WRAPPER
#if !defined(BOOST_HAS_TR1_RESULT_OF)\
&& !defined(BOOST_NO_SFINAE) && \
!defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
//
// we can only actually include result_of.hpp if the compiler
// really does support it, otherwise we just get endless errors...
//
#include <boost/utility/result_of.hpp>
namespace std{ namespace tr1{
template<class F>
struct result_of
: ::boost::tr1_result_of<F>
{};
} }
#endif // BOOST_HAS_TR1_RESULT_OF
#ifndef BOOST_HAS_TR1_MEM_FN
// mem_fn:
#include <boost/mem_fn.hpp>
namespace std{ namespace tr1{
using boost::mem_fn;
} }
#endif // BOOST_HAS_TR1_MEM_FN
#ifndef BOOST_HAS_TR1_BIND
// Bind:
#include <boost/bind.hpp>
namespace std{ namespace tr1{
using ::boost::is_bind_expression;
using ::boost::is_placeholder;
using ::boost::bind;
namespace placeholders {
#ifndef BOOST_BIND_NO_PLACEHOLDERS
using ::_1;
using ::_2;
using ::_3;
using ::_4;
using ::_5;
using ::_6;
using ::_7;
using ::_8;
using ::_9;
#endif
} // placeholders
} }
#endif
#ifndef BOOST_HAS_TR1_FUNCTION
// polymorphic function object wrappers:
#include <boost/function.hpp>
#include <boost/detail/workaround.hpp>
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x582) \
&& !BOOST_WORKAROUND(BOOST_MSVC, < 1310) \
&& !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
namespace std{ namespace tr1{
using ::boost::bad_function_call;
using ::boost::function;
using ::boost::swap;
}}
#endif
#endif // BOOST_HAS_TR1_FUNCTION
#ifndef BOOST_HAS_TR1_HASH
//
// This header can get included by boost/hash.hpp
// leading to cyclic dependencies. As a workaround
// we forward declare boost::hash and include
// the actual header later.
//
namespace boost{
template <class T> struct hash;
}
namespace std{ namespace tr1{
//using ::boost::hash;
template <class T>
struct hash : public boost::hash<T>
{
};
}}
#include <boost/functional/hash.hpp>
#endif
#endif

72
test/external/boost/tr1/memory.hpp vendored Normal file
View File

@@ -0,0 +1,72 @@
// (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_TR1_MEMORY_HPP_INCLUDED
# define BOOST_TR1_MEMORY_HPP_INCLUDED
# include <boost/tr1/detail/config.hpp>
# include <boost/detail/workaround.hpp>
# include <memory>
#ifndef BOOST_HAS_TR1_SHARED_PTR
//
// This header can get included by boost/shared_ptr.hpp which leads
// to cyclic dependencies, the workaround is to forward declare all
// the boost components, and then include the actual headers afterwards.
// This is fragile, but seems to work, and doesn't require modification
// of boost/shared_ptr.hpp.
//
namespace boost{
class bad_weak_ptr;
template<class T> class weak_ptr;
template<class T> class shared_ptr;
template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b);
template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b);
template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r);
template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r);
template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r);
template<class D, class T> D * get_deleter(shared_ptr<T> const & p);
template<class T> class enable_shared_from_this;
namespace detail{
class shared_count;
class weak_count;
}
}
namespace std{ namespace tr1{
using ::boost::bad_weak_ptr;
using ::boost::shared_ptr;
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
using ::boost::swap;
#endif
using ::boost::static_pointer_cast;
using ::boost::dynamic_pointer_cast;
using ::boost::const_pointer_cast;
using ::boost::get_deleter;
using ::boost::weak_ptr;
using ::boost::enable_shared_from_this;
} }
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#else
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(memory)
# else
# include <boost/tr1/detail/config_all.hpp>
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(memory))
# endif
#endif
#endif

586
test/external/boost/tr1/random.hpp vendored Normal file
View File

@@ -0,0 +1,586 @@
// (C) Copyright John Maddock 2005.
// (C) Copyright Henry S. Warren 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_TR1_RANDOM_HPP_INCLUDED
# define BOOST_TR1_RANDOM_HPP_INCLUDED
# include <boost/tr1/detail/config.hpp>
#ifdef BOOST_HAS_TR1_RANDOM
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(random)
# else
# include <boost/tr1/detail/config_all.hpp>
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(random))
# endif
#else
// Boost.Random:
#include <boost/random.hpp>
#ifndef __SUNPRO_CC
// Sunpros linker complains if we so much as include this...
# include <boost/nondet_random.hpp>
#endif
#include <boost/tr1/detail/functor2iterator.hpp>
#include <boost/type_traits/is_fundamental.hpp>
#include <boost/type_traits/is_same.hpp>
namespace std { namespace tr1{
using ::boost::variate_generator;
template<class UIntType, UIntType a, UIntType c, UIntType m>
class linear_congruential
{
private:
typedef ::boost::random::linear_congruential<UIntType, a, c, m, 0> impl_type;
public:
// types
typedef UIntType result_type;
// parameter values
BOOST_STATIC_CONSTANT(UIntType, multiplier = a);
BOOST_STATIC_CONSTANT(UIntType, increment = c);
BOOST_STATIC_CONSTANT(UIntType, modulus = m);
// constructors and member function
explicit linear_congruential(unsigned long x0 = 1)
: m_gen(x0){}
linear_congruential(const linear_congruential& that)
: m_gen(that.m_gen){}
template<class Gen> linear_congruential(Gen& g)
{
init1(g, ::boost::is_same<Gen,linear_congruential>());
}
void seed(unsigned long x0 = 1)
{ m_gen.seed(x0); }
template<class Gen> void seed(Gen& g)
{
init2(g, ::boost::is_fundamental<Gen>());
}
result_type min BOOST_PREVENT_MACRO_SUBSTITUTION() const
{ return (m_gen.min)(); }
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION() const
{ return (m_gen.max)(); }
result_type operator()()
{
return m_gen();
}
bool operator==(const linear_congruential& that)const
{ return m_gen == that.m_gen; }
bool operator!=(const linear_congruential& that)const
{ return m_gen != that.m_gen; }
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
template<class CharT, class Traits>
friend std::basic_ostream<CharT,Traits>&
operator<<(std::basic_ostream<CharT,Traits>& os,
const linear_congruential& lcg)
{
return os << lcg.m_gen;
}
template<class CharT, class Traits>
friend std::basic_istream<CharT,Traits>&
operator>>(std::basic_istream<CharT,Traits>& is,
linear_congruential& lcg)
{
return is >> lcg.m_gen;
}
#endif
private:
template <class Gen>
void init1(Gen& g, const ::boost::true_type&)
{
m_gen = g.m_gen;
}
template <class Gen>
void init1(Gen& g, const ::boost::false_type&)
{
init2(g, ::boost::is_fundamental<Gen>());
}
template <class Gen>
void init2(Gen& g, const ::boost::true_type&)
{
m_gen.seed(static_cast<unsigned long>(g));
}
template <class Gen>
void init2(Gen& g, const ::boost::false_type&)
{
//typedef typename Gen::result_type gen_rt;
boost::tr1_details::functor2iterator<Gen, unsigned long> f1(g), f2;
m_gen.seed(f1, f2);
}
impl_type m_gen;
};
template<class UIntType, int w, int n, int m, int r,
UIntType a, int u, int s, UIntType b, int t, UIntType c, int l>
class mersenne_twister
{
typedef ::boost::random::mersenne_twister
<UIntType, w, n, m, r, a, u, s, b, t, c, l, 0> imp_type;
public:
// types
typedef UIntType result_type;
// parameter values
BOOST_STATIC_CONSTANT(int, word_size = w);
BOOST_STATIC_CONSTANT(int, state_size = n);
BOOST_STATIC_CONSTANT(int, shift_size = m);
BOOST_STATIC_CONSTANT(int, mask_bits = r);
BOOST_STATIC_CONSTANT(UIntType, parameter_a = a);
BOOST_STATIC_CONSTANT(int, output_u = u);
BOOST_STATIC_CONSTANT(int, output_s = s);
BOOST_STATIC_CONSTANT(UIntType, output_b = b);
BOOST_STATIC_CONSTANT(int, output_t = t);
BOOST_STATIC_CONSTANT(UIntType, output_c = c);
BOOST_STATIC_CONSTANT(int, output_l = l);
// constructors and member function
mersenne_twister(){}
explicit mersenne_twister(unsigned long value)
: m_gen(value == 0 ? 5489UL : value){}
template<class Gen> mersenne_twister(Gen& g)
{
init1(g, ::boost::is_same<mersenne_twister,Gen>());
}
void seed()
{ m_gen.seed(); }
void seed(unsigned long value)
{ m_gen.seed(value == 0 ? 5489UL : value); }
template<class Gen> void seed(Gen& g)
{ init2(g, ::boost::is_fundamental<Gen>()); }
result_type min BOOST_PREVENT_MACRO_SUBSTITUTION() const
{ return (m_gen.min)(); }
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION() const
{ return (m_gen.max)(); }
result_type operator()()
{ return m_gen(); }
bool operator==(const mersenne_twister& that)const
{ return m_gen == that.m_gen; }
bool operator!=(const mersenne_twister& that)const
{ return m_gen != that.m_gen; }
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
template<class CharT, class Traits>
friend std::basic_ostream<CharT,Traits>&
operator<<(std::basic_ostream<CharT,Traits>& os,
const mersenne_twister& lcg)
{
return os << lcg.m_gen;
}
template<class CharT, class Traits>
friend std::basic_istream<CharT,Traits>&
operator>>(std::basic_istream<CharT,Traits>& is,
mersenne_twister& lcg)
{
return is >> lcg.m_gen;
}
#endif
private:
template <class Gen>
void init1(Gen& g, const ::boost::true_type&)
{
m_gen = g.m_gen;
}
template <class Gen>
void init1(Gen& g, const ::boost::false_type&)
{
init2(g, ::boost::is_fundamental<Gen>());
}
template <class Gen>
void init2(Gen& g, const ::boost::true_type&)
{
m_gen.seed(static_cast<unsigned long>(g == 0 ? 4357UL : g));
}
template <class Gen>
void init2(Gen& g, const ::boost::false_type&)
{
m_gen.seed(g);
}
imp_type m_gen;
};
template<class IntType, IntType m, int s, int r>
class subtract_with_carry
{
public:
// types
typedef IntType result_type;
// parameter values
BOOST_STATIC_CONSTANT(IntType, modulus = m);
BOOST_STATIC_CONSTANT(int, long_lag = r);
BOOST_STATIC_CONSTANT(int, short_lag = s);
// constructors and member function
subtract_with_carry(){}
explicit subtract_with_carry(unsigned long value)
: m_gen(value == 0 ? 19780503UL : value){}
template<class Gen> subtract_with_carry(Gen& g)
{ init1(g, ::boost::is_same<Gen, subtract_with_carry<IntType, m, s, r> >()); }
void seed(unsigned long value = 19780503ul)
{ m_gen.seed(value == 0 ? 19780503UL : value); }
template<class Gen> void seed(Gen& g)
{ init2(g, ::boost::is_fundamental<Gen>()); }
result_type min BOOST_PREVENT_MACRO_SUBSTITUTION() const
{ return (m_gen.min)(); }
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION() const
{ return (m_gen.max)(); }
result_type operator()()
{ return m_gen(); }
bool operator==(const subtract_with_carry& that)const
{ return m_gen == that.m_gen; }
bool operator!=(const subtract_with_carry& that)const
{ return m_gen != that.m_gen; }
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
template<class CharT, class Traits>
friend std::basic_ostream<CharT,Traits>&
operator<<(std::basic_ostream<CharT,Traits>& os,
const subtract_with_carry& lcg)
{
return os << lcg.m_gen;
}
template<class CharT, class Traits>
friend std::basic_istream<CharT,Traits>&
operator>>(std::basic_istream<CharT,Traits>& is,
subtract_with_carry& lcg)
{
return is >> lcg.m_gen;
}
#endif
private:
template <class Gen>
void init1(Gen& g, const ::boost::true_type&)
{
m_gen = g.m_gen;
}
template <class Gen>
void init1(Gen& g, const ::boost::false_type&)
{
init2(g, ::boost::is_fundamental<Gen>());
}
template <class Gen>
void init2(Gen& g, const ::boost::true_type&)
{
m_gen.seed(static_cast<unsigned long>(g == 0 ? 19780503UL : g));
}
template <class Gen>
void init2(Gen& g, const ::boost::false_type&)
{
m_gen.seed(g);
}
::boost::random::subtract_with_carry<IntType, m, s, r, 0> m_gen;
};
template<class RealType, int w, int s, int r>
class subtract_with_carry_01
{
public:
// types
typedef RealType result_type;
// parameter values
BOOST_STATIC_CONSTANT(int, word_size = w);
BOOST_STATIC_CONSTANT(int, long_lag = r);
BOOST_STATIC_CONSTANT(int, short_lag = s);
// constructors and member function
subtract_with_carry_01(){}
explicit subtract_with_carry_01(unsigned long value)
: m_gen(value == 0 ? 19780503UL : value){}
template<class Gen> subtract_with_carry_01(Gen& g)
{ init1(g, ::boost::is_same<Gen, subtract_with_carry_01<RealType, w, s, r> >()); }
void seed(unsigned long value = 19780503UL)
{ m_gen.seed(value == 0 ? 19780503UL : value); }
template<class Gen> void seed(Gen& g)
{ init2(g, ::boost::is_fundamental<Gen>()); }
result_type min BOOST_PREVENT_MACRO_SUBSTITUTION() const
{ return (m_gen.min)(); }
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION() const
{ return (m_gen.max)(); }
result_type operator()()
{ return m_gen(); }
bool operator==(const subtract_with_carry_01& that)const
{ return m_gen == that.m_gen; }
bool operator!=(const subtract_with_carry_01& that)const
{ return m_gen != that.m_gen; }
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
template<class CharT, class Traits>
friend std::basic_ostream<CharT,Traits>&
operator<<(std::basic_ostream<CharT,Traits>& os,
const subtract_with_carry_01& lcg)
{
return os << lcg.m_gen;
}
template<class CharT, class Traits>
friend std::basic_istream<CharT,Traits>&
operator>>(std::basic_istream<CharT,Traits>& is,
subtract_with_carry_01& lcg)
{
return is >> lcg.m_gen;
}
#endif
private:
template <class Gen>
void init1(Gen& g, const ::boost::true_type&)
{
m_gen = g.m_gen;
}
template <class Gen>
void init1(Gen& g, const ::boost::false_type&)
{
init2(g, ::boost::is_fundamental<Gen>());
}
template <class Gen>
void init2(Gen& g, const ::boost::true_type&)
{
m_gen.seed(static_cast<unsigned long>(g == 0 ? 19780503UL : g));
}
template <class Gen>
void init2(Gen& g, const ::boost::false_type&)
{
//typedef typename Gen::result_type gen_rt;
boost::tr1_details::functor2iterator<Gen, unsigned long> f1(g), f2;
m_gen.seed(f1, f2);
}
::boost::random::subtract_with_carry_01<RealType, w, s, r, 0> m_gen;
};
using ::boost::random::discard_block;
template<class UniformRandomNumberGenerator1, int s1, class UniformRandomNumberGenerator2, int s2>
class xor_combine
{
public:
// types
typedef UniformRandomNumberGenerator1 base1_type;
typedef UniformRandomNumberGenerator2 base2_type;
typedef unsigned long result_type;
// parameter values
BOOST_STATIC_CONSTANT(int, shift1 = s1);
BOOST_STATIC_CONSTANT(int, shift2 = s2);
// constructors and member function
xor_combine(){ init_minmax(); }
xor_combine(const base1_type & rng1, const base2_type & rng2)
: m_b1(rng1), m_b2(rng2) { init_minmax(); }
xor_combine(unsigned long s)
: m_b1(s), m_b2(s+1) { init_minmax(); }
template<class Gen> xor_combine(Gen& g)
{
init_minmax();
init1(g, ::boost::is_same<Gen, xor_combine<UniformRandomNumberGenerator1, s1, UniformRandomNumberGenerator2, s2> >());
}
void seed()
{
m_b1.seed();
m_b2.seed();
}
void seed(unsigned long s)
{
m_b1.seed(s);
m_b2.seed(s+1);
}
template<class Gen> void seed(Gen& g)
{
init2(g, ::boost::is_fundamental<Gen>());
}
const base1_type& base1() const
{ return m_b1; }
const base2_type& base2() const
{ return m_b2; }
result_type min BOOST_PREVENT_MACRO_SUBSTITUTION() const
{ return m_min; }
result_type max BOOST_PREVENT_MACRO_SUBSTITUTION() const
{ return m_max; }
result_type operator()()
{ return (m_b1() << s1) ^ (m_b2() << s2); }
bool operator == (const xor_combine& that)const
{ return (m_b1 == that.m_b1) && (m_b2 == that.m_b2); }
bool operator != (const xor_combine& that)const
{ return !(*this == that); }
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
template<class CharT, class Traits>
friend std::basic_ostream<CharT,Traits>&
operator<<(std::basic_ostream<CharT,Traits>& os,
const xor_combine& lcg)
{
return os << lcg.m_b1 << " " << lcg.m_b2;
}
template<class CharT, class Traits>
friend std::basic_istream<CharT,Traits>&
operator>>(std::basic_istream<CharT,Traits>& is,
xor_combine& lcg)
{
return is >> lcg.m_b1 >> lcg.m_b2;
}
#endif
private:
void init_minmax();
base1_type m_b1;
base2_type m_b2;
result_type m_min;
result_type m_max;
template <class Gen>
void init1(Gen& g, const ::boost::true_type&)
{
m_b1 = g.m_b1;
m_b2 = g.m_b2;
}
template <class Gen>
void init1(Gen& g, const ::boost::false_type&)
{
init2(g, ::boost::is_fundamental<Gen>());
}
template <class Gen>
void init2(Gen& g, const ::boost::true_type&)
{
m_b1.seed(static_cast<unsigned long>(g));
m_b2.seed(static_cast<unsigned long>(g));
}
template <class Gen>
void init2(Gen& g, const ::boost::false_type&)
{
m_b1.seed(g);
m_b2.seed(g);
}
};
template<class UniformRandomNumberGenerator1, int s1, class UniformRandomNumberGenerator2, int s2>
void xor_combine<UniformRandomNumberGenerator1, s1, UniformRandomNumberGenerator2, s2>::init_minmax()
{
//
// The following code is based on that given in "Hacker's Delight"
// by Henry S. Warren, (Addison-Wesley, 2003), and at
// http://www.hackersdelight.org/index.htm.
// Used here by permission.
//
// calculation of minimum value:
//
result_type a = (m_b1.min)() << s1;
result_type b = (m_b1.max)() << s1;
result_type c = (m_b2.min)() << s2;
result_type d = (m_b2.max)() << s2;
result_type m, temp;
m = 0x1uL << ((sizeof(result_type) * CHAR_BIT) - 1);
while (m != 0) {
if (~a & c & m) {
temp = (a | m) & (static_cast<result_type>(0u) - m);
if (temp <= b) a = temp;
}
else if (a & ~c & m) {
temp = (c | m) & (static_cast<result_type>(0u) - m);
if (temp <= d) c = temp;
}
m >>= 1;
}
m_min = a ^ c;
//
// calculation of maximum value:
//
if((((std::numeric_limits<result_type>::max)() >> s1) < (m_b1.max)())
|| ((((std::numeric_limits<result_type>::max)()) >> s2) < (m_b2.max)()))
{
m_max = (std::numeric_limits<result_type>::max)();
return;
}
a = (m_b1.min)() << s1;
b = (m_b1.max)() << s1;
c = (m_b2.min)() << s2;
d = (m_b2.max)() << s2;
m = 0x1uL << ((sizeof(result_type) * CHAR_BIT) - 1);
while (m != 0) {
if (b & d & m) {
temp = (b - m) | (m - 1);
if (temp >= a) b = temp;
else {
temp = (d - m) | (m - 1);
if (temp >= c) d = temp;
}
}
m = m >> 1;
}
m_max = b ^ d;
}
typedef linear_congruential< ::boost::int32_t, 16807, 0, 2147483647> minstd_rand0;
typedef linear_congruential< ::boost::int32_t, 48271, 0, 2147483647> minstd_rand;
typedef mersenne_twister< ::boost::uint32_t, 32,624,397,31,0x9908b0df,11,7,0x9d2c5680,15,0xefc60000,18> mt19937;
typedef subtract_with_carry_01<float, 24, 10, 24> ranlux_base_01;
typedef subtract_with_carry_01<double, 48, 10, 24> ranlux64_base_01;
typedef discard_block<subtract_with_carry< ::boost::int32_t, (1<<24), 10, 24>, 223, 24> ranlux3;
typedef discard_block<subtract_with_carry< ::boost::int32_t, (1<<24), 10, 24>, 389, 24> ranlux4;
typedef discard_block<subtract_with_carry_01<float, 24, 10, 24>, 223, 24> ranlux3_01;
typedef discard_block<subtract_with_carry_01<float, 24, 10, 24>, 389, 24> ranlux4_01;
#ifndef __SUNPRO_CC
using ::boost::random_device;
#endif
using ::boost::uniform_int;
class bernoulli_distribution
{
public:
// types
typedef int input_type;
typedef bool result_type;
// constructors and member function
explicit bernoulli_distribution(double p = 0.5)
: m_dist(p){}
double p() const
{ return m_dist.p(); }
void reset()
{ m_dist.reset(); }
template<class UniformRandomNumberGenerator>
result_type operator()(UniformRandomNumberGenerator& urng)
{
return m_dist(urng);
}
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
template<class CharT, class Traits>
friend std::basic_ostream<CharT,Traits>&
operator<<(std::basic_ostream<CharT,Traits>& os,
const bernoulli_distribution& lcg)
{
return os << lcg.m_dist;
}
template<class CharT, class Traits>
friend std::basic_istream<CharT,Traits>&
operator>>(std::basic_istream<CharT,Traits>& is,
bernoulli_distribution& lcg)
{
return is >> lcg.m_dist;
}
#endif
private:
::boost::bernoulli_distribution<double> m_dist;
};
//using ::boost::bernoulli_distribution;
using ::boost::geometric_distribution;
using ::boost::poisson_distribution;
using ::boost::binomial_distribution;
using ::boost::uniform_real;
using ::boost::exponential_distribution;
using ::boost::normal_distribution;
using ::boost::gamma_distribution;
} }
#endif
#endif

147
test/external/boost/tr1/regex.hpp vendored Normal file
View File

@@ -0,0 +1,147 @@
// (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_TR1_REGEX_HPP_INCLUDED
# define BOOST_TR1_REGEX_HPP_INCLUDED
# include <boost/tr1/detail/config.hpp>
#ifdef BOOST_HAS_TR1_REGEX
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(regex)
# else
# include <boost/tr1/detail/config_all.hpp>
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(regex))
# endif
#else
#include <boost/regex.hpp>
namespace std{ namespace tr1{
// [7.5] Regex constants
namespace regex_constants {
using ::boost::regex_constants::syntax_option_type;
using ::boost::regex_constants::icase;
using ::boost::regex_constants::nosubs;
using ::boost::regex_constants::optimize;
using ::boost::regex_constants::collate;
using ::boost::regex_constants::ECMAScript;
using ::boost::regex_constants::basic;
using ::boost::regex_constants::extended;
using ::boost::regex_constants::awk;
using ::boost::regex_constants::grep;
using ::boost::regex_constants::egrep;
using ::boost::regex_constants::match_flag_type;
using ::boost::regex_constants::match_default;
using ::boost::regex_constants::match_not_bol;
using ::boost::regex_constants::match_not_eol;
using ::boost::regex_constants::match_not_bow;
using ::boost::regex_constants::match_not_eow;
using ::boost::regex_constants::match_any;
using ::boost::regex_constants::match_not_null;
using ::boost::regex_constants::match_continuous;
using ::boost::regex_constants::match_prev_avail;
using ::boost::regex_constants::format_default;
using ::boost::regex_constants::format_sed;
using ::boost::regex_constants::format_no_copy;
using ::boost::regex_constants::format_first_only;
using ::boost::regex_constants::error_type;
using ::boost::regex_constants::error_collate;
using ::boost::regex_constants::error_ctype;
using ::boost::regex_constants::error_escape;
using ::boost::regex_constants::error_backref;
using ::boost::regex_constants::error_brack;
using ::boost::regex_constants::error_paren;
using ::boost::regex_constants::error_brace;
using ::boost::regex_constants::error_badbrace;
using ::boost::regex_constants::error_range;
using ::boost::regex_constants::error_space;
using ::boost::regex_constants::error_badrepeat;
using ::boost::regex_constants::error_complexity;
using ::boost::regex_constants::error_stack;
} // namespace regex_constants
// [7.6] Class regex_error
using ::boost::regex_error;
// [7.7] Class template regex_traits
using ::boost::regex_traits;
// [7.8] Class template basic_regex
using ::boost::basic_regex;
using ::boost::regex;
#ifndef BOOST_NO_WREGEX
using ::boost::wregex;
#endif
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
// [7.8.6] basic_regex swap
using ::boost::swap;
#endif
// [7.9] Class template sub_match
using ::boost::sub_match;
using ::boost::csub_match;
#ifndef BOOST_NO_WREGEX
using ::boost::wcsub_match;
#endif
using ::boost::ssub_match;
#ifndef BOOST_NO_WREGEX
using ::boost::wssub_match;
#endif
// [7.10] Class template match_results
using ::boost::match_results;
using ::boost::cmatch;
#ifndef BOOST_NO_WREGEX
using ::boost::wcmatch;
#endif
using ::boost::smatch;
#ifndef BOOST_NO_WREGEX
using ::boost::wsmatch;
#endif
using ::boost::regex_match;
// [7.11.3] Function template regex_search
using ::boost::regex_search;
// [7.11.4] Function template regex_replace
using ::boost::regex_replace;
// [7.12.1] Class template regex_iterator
using ::boost::regex_iterator;
using ::boost::cregex_iterator;
#ifndef BOOST_NO_WREGEX
using ::boost::wcregex_iterator;
#endif
using ::boost::sregex_iterator;
#ifndef BOOST_NO_WREGEX
using ::boost::wsregex_iterator;
#endif
// [7.12.2] Class template regex_token_iterator
using ::boost::regex_token_iterator;
using ::boost::cregex_token_iterator;
#ifndef BOOST_NO_WREGEX
using ::boost::wcregex_token_iterator;
#endif
using ::boost::sregex_token_iterator;
#ifndef BOOST_NO_WREGEX
using ::boost::wsregex_token_iterator;
#endif
} } // namespaces
#endif
#endif

27
test/external/boost/tr1/tr1/algorithm vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_algorithm_INCLUDED
# define BOOST_TR1_algorithm_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_algorithm_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <algorithm>
# else
# include BOOST_TR1_STD_HEADER(algorithm)
# endif
# ifdef BOOST_TR1_NO_algorithm_RECURSION
# undef BOOST_TR1_NO_algorithm_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

34
test/external/boost/tr1/tr1/array vendored Normal file
View File

@@ -0,0 +1,34 @@
// (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)
#if !defined(BOOST_TR1_ARRAY_INCLUDED)
# define BOOST_TR1_ARRAY_INCLUDED
# include <boost/tr1/detail/config_all.hpp>
# ifdef BOOST_HAS_CPP_0X
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <array>
# else
# include BOOST_TR1_STD_HEADER(array)
# endif
# endif
# if !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_NO_RECURSION
# ifdef BOOST_HAS_TR1_ARRAY
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(array)
# else
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(array))
# endif
# else
# include <boost/tr1/array.hpp>
# endif
# undef BOOST_TR1_NO_RECURSION
#endif
#endif

13
test/external/boost/tr1/tr1/bcc32/array.h vendored Normal file
View File

@@ -0,0 +1,13 @@
// (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)
//
// Forwarding header for Borland C++:
//
#if !defined(BOOST_TR1_ARRAY_H_INCLUDED)
# define BOOST_TR1_ARRAY_H_INCLUDED
# include <array.>
#endif

13
test/external/boost/tr1/tr1/bcc32/random.h vendored Normal file
View File

@@ -0,0 +1,13 @@
// (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)
//
// Forwarding header for Borland C++:
//
#if !defined(BOOST_TR1_RANDOM_H_INCLUDED)
# define BOOST_TR1_RANDOM_H_INCLUDED
# include <random.>
#endif

13
test/external/boost/tr1/tr1/bcc32/regex.h vendored Normal file
View File

@@ -0,0 +1,13 @@
// (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)
//
// Forwarding header for Borland C++:
//
#if !defined(BOOST_TR1_REGEX_H_INCLUDED)
# define BOOST_TR1_REGEX_H_INCLUDED
# include <regex.>
#endif

13
test/external/boost/tr1/tr1/bcc32/tuple.h vendored Normal file
View File

@@ -0,0 +1,13 @@
// (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)
//
// Forwarding header for Borland C++:
//
#if !defined(BOOST_TR1_TUPLE_H_INCLUDED)
# define BOOST_TR1_TUPLE_H_INCLUDED
# include <tuple.>
#endif

13
test/external/boost/tr1/tr1/bcc32/type_tra.h vendored Normal file
View File

@@ -0,0 +1,13 @@
// (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)
//
// Forwarding header for Borland C++:
//
#if !defined(BOOST_TR1_TYPE_TRAITS_H_INCLUDED)
# define BOOST_TR1_TYPE_TRAITS_H_INCLUDED
# include <type_traits.>
#endif

15
test/external/boost/tr1/tr1/bcc32/unordere.h vendored Normal file
View File

@@ -0,0 +1,15 @@
// (C) Copyright John Maddock 2008.
// 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)
//
// Forwarding header for Borland C++:
//
#if !defined(BOOST_TR1_UNORDERED_H_INCLUDED)
# define BOOST_TR1_UNORDERED_H_INCLUDED
# include <unordered_set.>
# include <unordered_map.>
#endif

27
test/external/boost/tr1/tr1/bitset vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_bitset_INCLUDED
# define BOOST_TR1_bitset_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_bitset_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <bitset>
# else
# include BOOST_TR1_STD_HEADER(bitset)
# endif
# ifdef BOOST_TR1_NO_bitset_RECURSION
# undef BOOST_TR1_NO_bitset_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

41
test/external/boost/tr1/tr1/cmath vendored Normal file
View File

@@ -0,0 +1,41 @@
// (C) Copyright John Maddock 2008.
// 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)
#if !defined(BOOST_TR1_CMATH_INCLUDED) || defined(BOOST_TR1_NO_RECURSION)
#ifndef BOOST_TR1_CMATH_INCLUDED
# define BOOST_TR1_CMATH_INCLUDED
#endif
# ifdef BOOST_TR1_NO_CMATH_RECURSION2
# define BOOST_TR1_NO_CMATH_RECURSION3
# elif defined(BOOST_TR1_NO_CMATH_RECURSION)
# define BOOST_TR1_NO_CMATH_RECURSION2
# elif !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_CMATH_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <cmath>
# else
# include BOOST_TR1_STD_CHEADER(cmath)
# endif
#ifdef BOOST_TR1_NO_CMATH_RECURSION3
# undef BOOST_TR1_NO_CMATH_RECURSION3
#elif defined(BOOST_TR1_NO_CMATH_RECURSION2)
# undef BOOST_TR1_NO_CMATH_RECURSION2
#elif defined(BOOST_TR1_NO_CMATH_RECURSION)
# undef BOOST_TR1_NO_RECURSION
# undef BOOST_TR1_NO_CMATH_RECURSION
# endif
#endif
#if !defined(BOOST_TR1_FULL_CMATH_INCLUDED) && !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_FULL_CMATH_INCLUDED
# define BOOST_TR1_NO_RECURSION
# include <boost/tr1/cmath.hpp>
# undef BOOST_TR1_NO_RECURSION
#endif

31
test/external/boost/tr1/tr1/complex vendored Normal file
View File

@@ -0,0 +1,31 @@
// (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_TR1_COMPLEX_INCLUDED
# define BOOST_TR1_COMPLEX_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_COMPLEX_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <complex>
# else
# include BOOST_TR1_STD_HEADER(complex)
# endif
# ifdef BOOST_TR1_NO_COMPLEX_RECURSION
# undef BOOST_TR1_NO_COMPLEX_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif
#if !defined(BOOST_TR1_FULL_COMPLEX_INCLUDED) && !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_FULL_COMPLEX_INCLUDED
# define BOOST_TR1_NO_RECURSION
# include <boost/tr1/complex.hpp>
# undef BOOST_TR1_NO_RECURSION
#endif

27
test/external/boost/tr1/tr1/deque vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_deque_INCLUDED
# define BOOST_TR1_deque_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_deque_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <deque>
# else
# include BOOST_TR1_STD_HEADER(deque)
# endif
# ifdef BOOST_TR1_NO_deque_RECURSION
# undef BOOST_TR1_NO_deque_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

39
test/external/boost/tr1/tr1/exception vendored Normal file
View File

@@ -0,0 +1,39 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
// Important: there are no include guards on this header for Borland C++
// The Borland version of <exception> has some peculiar circular dependencies
// that requires multiple inclusion. Likewise for gcc (gcc-2.95.3 fix).
//
#ifdef BOOST_TR1_NO_exception_RECURSION2
# define BOOST_TR1_NO_exception_RECURSION3
#elif defined(BOOST_TR1_NO_exception_RECURSION)
# define BOOST_TR1_NO_exception_RECURSION2
#elif !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_exception_RECURSION
#endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <exception>
# else
# include BOOST_TR1_STD_HEADER(exception)
# endif
#ifdef BOOST_TR1_NO_exception_RECURSION3
# undef BOOST_TR1_NO_exception_RECURSION3
#elif defined(BOOST_TR1_NO_exception_RECURSION2)
# undef BOOST_TR1_NO_exception_RECURSION2
#elif defined(BOOST_TR1_NO_exception_RECURSION)
# undef BOOST_TR1_NO_exception_RECURSION
# undef BOOST_TR1_NO_RECURSION
#endif

27
test/external/boost/tr1/tr1/fstream vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_fstream_INCLUDED
# define BOOST_TR1_fstream_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_fstream_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <fstream>
# else
# include BOOST_TR1_STD_HEADER(fstream)
# endif
# ifdef BOOST_TR1_NO_fstream_RECURSION
# undef BOOST_TR1_NO_fstream_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

30
test/external/boost/tr1/tr1/functional vendored Normal file
View File

@@ -0,0 +1,30 @@
// (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)
#if !defined(BOOST_TR1_FUNCTIONAL_INCLUDED)
# define BOOST_TR1_FUNCTIONAL_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_FUNCTIONAL_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <functional>
# else
# include BOOST_TR1_STD_HEADER(functional)
# endif
# ifdef BOOST_TR1_NO_FUNCTIONAL_RECURSION
# undef BOOST_TR1_NO_FUNCTIONAL_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif
#if !defined(BOOST_TR1_FULL_FUNCTIONAL_INCLUDED) && !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_FULL_FUNCTIONAL_INCLUDED
# define BOOST_TR1_NO_RECURSION
# include <boost/tr1/functional.hpp>
# undef BOOST_TR1_NO_RECURSION
#endif

27
test/external/boost/tr1/tr1/iomanip vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_iomanip_INCLUDED
# define BOOST_TR1_iomanip_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_iomanip_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <iomanip>
# else
# include BOOST_TR1_STD_HEADER(iomanip)
# endif
# ifdef BOOST_TR1_NO_iomanip_RECURSION
# undef BOOST_TR1_NO_iomanip_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/ios vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_ios_INCLUDED
# define BOOST_TR1_ios_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_ios_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <ios>
# else
# include BOOST_TR1_STD_HEADER(ios)
# endif
# ifdef BOOST_TR1_NO_ios_RECURSION
# undef BOOST_TR1_NO_ios_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/iostream vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_iostream_INCLUDED
# define BOOST_TR1_iostream_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_iostream_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <iostream>
# else
# include BOOST_TR1_STD_HEADER(iostream)
# endif
# ifdef BOOST_TR1_NO_iostream_RECURSION
# undef BOOST_TR1_NO_iostream_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/istream vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_istream_INCLUDED
# define BOOST_TR1_istream_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_istream_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <istream>
# else
# include BOOST_TR1_STD_HEADER(istream)
# endif
# ifdef BOOST_TR1_NO_istream_RECURSION
# undef BOOST_TR1_NO_istream_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/iterator vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_iterator_INCLUDED
# define BOOST_TR1_iterator_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_iterator_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <iterator>
# else
# include BOOST_TR1_STD_HEADER(iterator)
# endif
# ifdef BOOST_TR1_NO_iterator_RECURSION
# undef BOOST_TR1_NO_iterator_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/limits vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_limits_INCLUDED
# define BOOST_TR1_limits_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_limits_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <limits>
# else
# include BOOST_TR1_STD_HEADER(limits)
# endif
# ifdef BOOST_TR1_NO_limits_RECURSION
# undef BOOST_TR1_NO_limits_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/list vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_list_INCLUDED
# define BOOST_TR1_list_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_list_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <list>
# else
# include BOOST_TR1_STD_HEADER(list)
# endif
# ifdef BOOST_TR1_NO_list_RECURSION
# undef BOOST_TR1_NO_list_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/locale vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_locale_INCLUDED
# define BOOST_TR1_locale_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_locale_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <locale>
# else
# include BOOST_TR1_STD_HEADER(locale)
# endif
# ifdef BOOST_TR1_NO_locale_RECURSION
# undef BOOST_TR1_NO_locale_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/map vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_map_INCLUDED
# define BOOST_TR1_map_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_map_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <map>
# else
# include BOOST_TR1_STD_HEADER(map)
# endif
# ifdef BOOST_TR1_NO_map_RECURSION
# undef BOOST_TR1_NO_map_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

31
test/external/boost/tr1/tr1/memory vendored Normal file
View File

@@ -0,0 +1,31 @@
// (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_TR1_MEMORY_INCLUDED
# define BOOST_TR1_MEMORY_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_MEMORY_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <memory>
# else
# include BOOST_TR1_STD_HEADER(memory)
# endif
# ifdef BOOST_TR1_NO_MEMORY_RECURSION
# undef BOOST_TR1_NO_MEMORY_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif
#if !defined(BOOST_TR1_FULL_MEMORY_INCLUDED) && !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_FULL_MEMORY_INCLUDED
# define BOOST_TR1_NO_RECURSION
# include <boost/tr1/memory.hpp>
# undef BOOST_TR1_NO_RECURSION
#endif

35
test/external/boost/tr1/tr1/new vendored Normal file
View File

@@ -0,0 +1,35 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifdef BOOST_TR1_NO_new_RECURSION2
# define BOOST_TR1_NO_new_RECURSION3
#elif defined(BOOST_TR1_NO_new_RECURSION)
# define BOOST_TR1_NO_new_RECURSION2
#elif !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_new_RECURSION
#endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <new>
# else
# include BOOST_TR1_STD_HEADER(new)
# endif
#ifdef BOOST_TR1_NO_new_RECURSION3
# undef BOOST_TR1_NO_new_RECURSION3
#elif defined(BOOST_TR1_NO_new_RECURSION2)
# undef BOOST_TR1_NO_new_RECURSION2
#elif defined(BOOST_TR1_NO_new_RECURSION)
# undef BOOST_TR1_NO_new_RECURSION
# undef BOOST_TR1_NO_RECURSION
#endif

27
test/external/boost/tr1/tr1/numeric vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_numeric_INCLUDED
# define BOOST_TR1_numeric_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_numeric_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <numeric>
# else
# include BOOST_TR1_STD_HEADER(numeric)
# endif
# ifdef BOOST_TR1_NO_numeric_RECURSION
# undef BOOST_TR1_NO_numeric_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/ostream vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_ostream_INCLUDED
# define BOOST_TR1_ostream_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_ostream_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <ostream>
# else
# include BOOST_TR1_STD_HEADER(ostream)
# endif
# ifdef BOOST_TR1_NO_ostream_RECURSION
# undef BOOST_TR1_NO_ostream_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/queue vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_queue_INCLUDED
# define BOOST_TR1_queue_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_queue_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <queue>
# else
# include BOOST_TR1_STD_HEADER(queue)
# endif
# ifdef BOOST_TR1_NO_queue_RECURSION
# undef BOOST_TR1_NO_queue_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

34
test/external/boost/tr1/tr1/random vendored Normal file
View File

@@ -0,0 +1,34 @@
// (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_TR1_RANDOM_INCLUDED
# define BOOST_TR1_RANDOM_INCLUDED
# include <boost/tr1/detail/config_all.hpp>
# ifdef BOOST_HAS_CPP_0X
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <random>
# else
# include BOOST_TR1_STD_HEADER(random)
# endif
# endif
# if !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_NO_RECURSION
# ifdef BOOST_HAS_TR1_RANDOM
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(random)
# else
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(random))
# endif
# else
# include <boost/tr1/random.hpp>
# endif
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

22
test/external/boost/tr1/tr1/regex vendored Normal file
View File

@@ -0,0 +1,22 @@
// (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_TR1_REGEX_INCLUDED
# define BOOST_TR1_REGEX_INCLUDED
# define BOOST_TR1_NO_RECURSION
# include <boost/tr1/detail/config_all.hpp>
# ifdef BOOST_HAS_TR1_REGEX
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(regex)
# else
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(regex))
# endif
# else
# include <boost/tr1/regex.hpp>
# endif
# undef BOOST_TR1_NO_RECURSION
#endif

27
test/external/boost/tr1/tr1/set vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_set_INCLUDED
# define BOOST_TR1_set_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_set_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <set>
# else
# include BOOST_TR1_STD_HEADER(set)
# endif
# ifdef BOOST_TR1_NO_set_RECURSION
# undef BOOST_TR1_NO_set_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/sstream vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_sstream_INCLUDED
# define BOOST_TR1_sstream_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_sstream_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <sstream>
# else
# include BOOST_TR1_STD_HEADER(sstream)
# endif
# ifdef BOOST_TR1_NO_sstream_RECURSION
# undef BOOST_TR1_NO_sstream_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/stack vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_stack_INCLUDED
# define BOOST_TR1_stack_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_stack_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <stack>
# else
# include BOOST_TR1_STD_HEADER(stack)
# endif
# ifdef BOOST_TR1_NO_stack_RECURSION
# undef BOOST_TR1_NO_stack_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

34
test/external/boost/tr1/tr1/stdexcept vendored Normal file
View File

@@ -0,0 +1,34 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifdef BOOST_TR1_NO_stdexcept_RECURSION2
# define BOOST_TR1_NO_stdexcept_RECURSION3
#elif defined(BOOST_TR1_NO_stdexcept_RECURSION)
# define BOOST_TR1_NO_stdexcept_RECURSION2
#elif !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_stdexcept_RECURSION
#endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <stdexcept>
# else
# include BOOST_TR1_STD_HEADER(stdexcept)
# endif
#ifdef BOOST_TR1_NO_stdexcept_RECURSION3
# undef BOOST_TR1_NO_stdexcept_RECURSION3
#elif defined(BOOST_TR1_NO_stdexcept_RECURSION2)
# undef BOOST_TR1_NO_stdexcept_RECURSION2
#elif defined(BOOST_TR1_NO_stdexcept_RECURSION)
# undef BOOST_TR1_NO_stdexcept_RECURSION
# undef BOOST_TR1_NO_RECURSION
#endif

27
test/external/boost/tr1/tr1/streambuf vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_streambuf_INCLUDED
# define BOOST_TR1_streambuf_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_streambuf_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <streambuf>
# else
# include BOOST_TR1_STD_HEADER(streambuf)
# endif
# ifdef BOOST_TR1_NO_streambuf_RECURSION
# undef BOOST_TR1_NO_streambuf_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/string vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_string_INCLUDED
# define BOOST_TR1_string_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_string_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <string>
# else
# include BOOST_TR1_STD_HEADER(string)
# endif
# ifdef BOOST_TR1_NO_string_RECURSION
# undef BOOST_TR1_NO_string_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

29
test/external/boost/tr1/tr1/strstream vendored Normal file
View File

@@ -0,0 +1,29 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_strstream_INCLUDED
# define BOOST_TR1_strstream_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_strstream_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <strstream>
# elif defined(__GNUC__) && (__GNUC__ >= 4) && defined(__GLIBCXX__) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
# include <backward/strstream>
# else
# include BOOST_TR1_STD_HEADER(strstream)
# endif
# ifdef BOOST_TR1_NO_strstream_RECURSION
# undef BOOST_TR1_NO_strstream_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

6
test/external/boost/tr1/tr1/sun/algorithm.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../algorithm"

6
test/external/boost/tr1/tr1/sun/array.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../array"

6
test/external/boost/tr1/tr1/sun/bcc32.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../bcc32"

6
test/external/boost/tr1/tr1/sun/bitset.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../bitset"

7
test/external/boost/tr1/tr1/sun/cmath.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,7 @@
// (C) Copyright John Maddock 2008.
// 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)
#include "../cmath"

6
test/external/boost/tr1/tr1/sun/complex.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../complex"

6
test/external/boost/tr1/tr1/sun/deque.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../deque"

6
test/external/boost/tr1/tr1/sun/exception.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../exception"

6
test/external/boost/tr1/tr1/sun/fstream.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../fstream"

6
test/external/boost/tr1/tr1/sun/functional.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../functional"

6
test/external/boost/tr1/tr1/sun/iomanip.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../iomanip"

6
test/external/boost/tr1/tr1/sun/ios.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../ios"

6
test/external/boost/tr1/tr1/sun/iostream.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../iostream"

6
test/external/boost/tr1/tr1/sun/istream.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../istream"

6
test/external/boost/tr1/tr1/sun/iterator.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../iterator"

6
test/external/boost/tr1/tr1/sun/limits.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../limits"

6
test/external/boost/tr1/tr1/sun/list.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../list"

6
test/external/boost/tr1/tr1/sun/locale.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../locale"

6
test/external/boost/tr1/tr1/sun/map.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../map"

6
test/external/boost/tr1/tr1/sun/memory.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../memory"

6
test/external/boost/tr1/tr1/sun/new.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../new"

6
test/external/boost/tr1/tr1/sun/numeric.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../numeric"

6
test/external/boost/tr1/tr1/sun/ostream.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../ostream"

6
test/external/boost/tr1/tr1/sun/queue.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../queue"

6
test/external/boost/tr1/tr1/sun/random.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../random"

6
test/external/boost/tr1/tr1/sun/regex.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../regex"

6
test/external/boost/tr1/tr1/sun/set.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../set"

6
test/external/boost/tr1/tr1/sun/sstream.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../sstream"

6
test/external/boost/tr1/tr1/sun/stack.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../stack"

6
test/external/boost/tr1/tr1/sun/stdexcept.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../stdexcept"

6
test/external/boost/tr1/tr1/sun/streambuf.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../streambuf"

6
test/external/boost/tr1/tr1/sun/string.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../string"

6
test/external/boost/tr1/tr1/sun/strstream.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../strstream"

6
test/external/boost/tr1/tr1/sun/sun.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../sun"

6
test/external/boost/tr1/tr1/sun/tuple.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../tuple"

6
test/external/boost/tr1/tr1/sun/type_traits.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../type_traits"

6
test/external/boost/tr1/tr1/sun/typeinfo.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../typeinfo"

7
test/external/boost/tr1/tr1/sun/unordered_map.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,7 @@
// (C) Copyright John Maddock 2008.
// 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)
#include "../unordered_map"

7
test/external/boost/tr1/tr1/sun/unordered_set.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,7 @@
// (C) Copyright John Maddock 2008.
// 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)
#include "../unordered_set"

6
test/external/boost/tr1/tr1/sun/utility.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../utility"

6
test/external/boost/tr1/tr1/sun/valarray.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../valarray"

6
test/external/boost/tr1/tr1/sun/vector.SUNWCCh vendored Normal file
View File

@@ -0,0 +1,6 @@
// (C) Copyright John Maddock 2006.
// 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)
#include "../vector"

34
test/external/boost/tr1/tr1/tuple vendored Normal file
View File

@@ -0,0 +1,34 @@
// (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_TR1_TUPLE_INCLUDED
# define BOOST_TR1_TUPLE_INCLUDED
# include <boost/tr1/detail/config_all.hpp>
# ifdef BOOST_HAS_CPP_0X
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <tuple>
# else
# include BOOST_TR1_STD_HEADER(tuple)
# endif
# endif
# if !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_NO_RECURSION
# ifdef BOOST_HAS_TR1_TUPLE
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(tuple)
# else
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(tuple))
# endif
# else
# include <boost/tr1/tuple.hpp>
# endif
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

43
test/external/boost/tr1/tr1/type_traits vendored Normal file
View File

@@ -0,0 +1,43 @@
// (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)
#include <boost/tr1/detail/config_all.hpp>
#if (!defined(BOOST_TR1_TYPE_TRAITS_INCLUDED) || defined(BOOST_TR1_NO_RECURSION)) && defined(BOOST_HAS_CPP_0X)
#ifndef BOOST_TR1_TYPE_TRAITS_INCLUDED
# define BOOST_TR1_TYPE_TRAITS_INCLUDED
#endif
# ifdef BOOST_TR1_NO_TYPE_TRAITS_RECURSION2
# define BOOST_TR1_NO_TYPE_TRAITS_RECURSION3
# elif defined(BOOST_TR1_NO_TYPE_TRAITS_RECURSION)
# define BOOST_TR1_NO_TYPE_TRAITS_RECURSION2
# elif !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_TYPE_TRAITS_RECURSION
# endif
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <type_traits>
# else
# include BOOST_TR1_STD_HEADER(type_traits)
# endif
#ifdef BOOST_TR1_NO_TYPE_TRAITS_RECURSION3
# undef BOOST_TR1_NO_TYPE_TRAITS_RECURSION3
#elif defined(BOOST_TR1_NO_TYPE_TRAITS_RECURSION2)
# undef BOOST_TR1_NO_TYPE_TRAITS_RECURSION2
#elif defined(BOOST_TR1_NO_TYPE_TRAITS_RECURSION)
# undef BOOST_TR1_NO_RECURSION
# undef BOOST_TR1_NO_TYPE_TRAITS_RECURSION
# endif
#endif
#if !defined(BOOST_TR1_FULL_TYPE_TRAITS_INCLUDED) && !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_FULL_TYPE_TRAITS_INCLUDED
# define BOOST_TR1_NO_RECURSION
# include <boost/tr1/type_traits.hpp>
# undef BOOST_TR1_NO_RECURSION
#endif

27
test/external/boost/tr1/tr1/typeinfo vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_typeinfo_INCLUDED
# define BOOST_TR1_typeinfo_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_typeinfo_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <typeinfo>
# else
# include BOOST_TR1_STD_HEADER(typeinfo)
# endif
# ifdef BOOST_TR1_NO_typeinfo_RECURSION
# undef BOOST_TR1_NO_typeinfo_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

34
test/external/boost/tr1/tr1/unordered_map vendored Normal file
View File

@@ -0,0 +1,34 @@
// (C) Copyright John Maddock 2008.
// 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_TR1_UNORDERED_MAP_INCLUDED
# define BOOST_TR1_UNORDERED_MAP_INCLUDED
# include <boost/tr1/detail/config_all.hpp>
# ifdef BOOST_HAS_CPP_0X
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <unordered_map>
# else
# include BOOST_TR1_STD_HEADER(unordered_map)
# endif
# endif
# if !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_NO_RECURSION
# ifdef BOOST_HAS_TR1_UNORDERED_MAP
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(unordered_map)
# else
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(unordered_map))
# endif
# else
# include <boost/tr1/unordered_map.hpp>
# endif
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

34
test/external/boost/tr1/tr1/unordered_set vendored Normal file
View File

@@ -0,0 +1,34 @@
// (C) Copyright John Maddock 2008.
// 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_TR1_UNORDERED_SET_INCLUDED
# define BOOST_TR1_UNORDERED_SET_INCLUDED
# include <boost/tr1/detail/config_all.hpp>
# ifdef BOOST_HAS_CPP_0X
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <unordered_map>
# else
# include BOOST_TR1_STD_HEADER(unordered_map)
# endif
# endif
# if !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_NO_RECURSION
# ifdef BOOST_HAS_TR1_UNORDERED_SET
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(unordered_set)
# else
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(unordered_set))
# endif
# else
# include <boost/tr1/unordered_set.hpp>
# endif
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

41
test/external/boost/tr1/tr1/utility vendored Normal file
View File

@@ -0,0 +1,41 @@
// (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)
#if !defined(BOOST_TR1_UTILITY_INCLUDED) || defined(BOOST_TR1_NO_RECURSION)
#ifndef BOOST_TR1_UTILITY_INCLUDED
# define BOOST_TR1_UTILITY_INCLUDED
#endif
# ifdef BOOST_TR1_NO_UTILITY_RECURSION2
# define BOOST_TR1_NO_UTILITY_RECURSION3
# elif defined(BOOST_TR1_NO_UTILITY_RECURSION)
# define BOOST_TR1_NO_UTILITY_RECURSION2
# elif !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_UTILITY_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <utility>
# else
# include BOOST_TR1_STD_HEADER(utility)
# endif
#ifdef BOOST_TR1_NO_UTILITY_RECURSION3
# undef BOOST_TR1_NO_UTILITY_RECURSION3
#elif defined(BOOST_TR1_NO_UTILITY_RECURSION2)
# undef BOOST_TR1_NO_UTILITY_RECURSION2
#elif defined(BOOST_TR1_NO_UTILITY_RECURSION)
# undef BOOST_TR1_NO_RECURSION
# undef BOOST_TR1_NO_UTILITY_RECURSION
# endif
#endif
#if !defined(BOOST_TR1_FULL_UTILITY_INCLUDED) && !defined(BOOST_TR1_NO_RECURSION)
# define BOOST_TR1_FULL_UTILITY_INCLUDED
# define BOOST_TR1_NO_RECURSION
# include <boost/tr1/utility.hpp>
# undef BOOST_TR1_NO_RECURSION
#endif

27
test/external/boost/tr1/tr1/valarray vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_valarray_INCLUDED
# define BOOST_TR1_valarray_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_valarray_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <valarray>
# else
# include BOOST_TR1_STD_HEADER(valarray)
# endif
# ifdef BOOST_TR1_NO_valarray_RECURSION
# undef BOOST_TR1_NO_valarray_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

27
test/external/boost/tr1/tr1/vector vendored Normal file
View File

@@ -0,0 +1,27 @@
// (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)
//
// This file exists to prevent std lib headers from accidentally
// including a TR1 extention header; we must suppress this otherwise
// we can end up with cyclic dependencies with some std lib implementations.
//
#ifndef BOOST_TR1_vector_INCLUDED
# define BOOST_TR1_vector_INCLUDED
# ifndef BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_RECURSION
# define BOOST_TR1_NO_vector_RECURSION
# endif
# include <boost/tr1/detail/config_all.hpp>
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next <vector>
# else
# include BOOST_TR1_STD_HEADER(vector)
# endif
# ifdef BOOST_TR1_NO_vector_RECURSION
# undef BOOST_TR1_NO_vector_RECURSION
# undef BOOST_TR1_NO_RECURSION
# endif
#endif

82
test/external/boost/tr1/tuple.hpp vendored Normal file
View File

@@ -0,0 +1,82 @@
// (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_TR1_TUPLE_HPP_INCLUDED
# define BOOST_TR1_TUPLE_HPP_INCLUDED
# include <boost/tr1/detail/config.hpp>
#ifdef BOOST_HAS_TR1_TUPLE
# if defined(BOOST_HAS_INCLUDE_NEXT) && !defined(BOOST_TR1_DISABLE_INCLUDE_NEXT)
# include_next BOOST_TR1_HEADER(tuple)
# else
# include <boost/tr1/detail/config_all.hpp>
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(tuple))
# endif
#else
#if defined(BOOST_TR1_USE_OLD_TUPLE)
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <boost/type_traits/integral_constant.hpp>
namespace std{ namespace tr1{
using ::boost::tuple;
// [6.1.3.2] Tuple creation functions
using ::boost::tuples::ignore;
using ::boost::make_tuple;
using ::boost::tie;
// [6.1.3.3] Tuple helper classes
template <class T>
struct tuple_size
: public ::boost::integral_constant
< ::std::size_t, ::boost::tuples::length<T>::value>
{};
template < int I, class T>
struct tuple_element
{
typedef typename boost::tuples::element<I,T>::type type;
};
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
// [6.1.3.4] Element access
using ::boost::get;
#endif
} } // namespaces
#else
#include <boost/fusion/include/tuple.hpp>
#include <boost/fusion/include/std_pair.hpp>
namespace std{ namespace tr1{
using ::boost::fusion::tuple;
// [6.1.3.2] Tuple creation functions
using ::boost::fusion::ignore;
using ::boost::fusion::make_tuple;
using ::boost::fusion::tie;
using ::boost::fusion::get;
// [6.1.3.3] Tuple helper classes
using ::boost::fusion::tuple_size;
using ::boost::fusion::tuple_element;
}}
#endif
#endif
#endif

Some files were not shown because too many files have changed in this diff Show More