From: hartmann Date: Mon, 9 Feb 2004 08:18:47 +0000 (+0000) Subject: minimized boost-1.30.2 library. X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=947d9f2c8472af0164b17a155cb13082d6f689cc;p=dealii-svn.git minimized boost-1.30.2 library. git-svn-id: https://svn.dealii.org/trunk@8423 0785d39b-7218-0410-832d-ea1e28bc413d --- diff --git a/deal.II/contrib/boost/include/boost/assert.hpp b/deal.II/contrib/boost/include/boost/assert.hpp new file mode 100644 index 0000000000..754ebb954b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/assert.hpp @@ -0,0 +1,38 @@ +// +// boost/assert.hpp - BOOST_ASSERT(expr) +// +// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. +// +// Permission to copy, use, modify, sell and distribute this software +// is granted provided this copyright notice appears in all copies. +// This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. +// +// Note: There are no include guards. This is intentional. +// +// See http://www.boost.org/libs/utility/assert.html for documentation. +// + +#undef BOOST_ASSERT + +#if defined(BOOST_DISABLE_ASSERTS) + +# define BOOST_ASSERT(expr) ((void)0) + +#elif defined(BOOST_ENABLE_ASSERT_HANDLER) + +#include + +namespace boost +{ + +void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined + +} // namespace boost + +#define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)) + +#else +# include +# define BOOST_ASSERT(expr) assert(expr) +#endif diff --git a/deal.II/contrib/boost/include/boost/checked_delete.hpp b/deal.II/contrib/boost/include/boost/checked_delete.hpp new file mode 100644 index 0000000000..480c041837 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/checked_delete.hpp @@ -0,0 +1,69 @@ +#ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED +#define BOOST_CHECKED_DELETE_HPP_INCLUDED + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// boost/checked_delete.hpp +// +// Copyright (c) 1999, 2000, 2001, 2002 boost.org +// Copyright (c) 2002, 2003 Peter Dimov +// Copyright (c) 2003 Daniel Frey +// Copyright (c) 2003 Howard Hinnant +// +// Permission to copy, use, modify, sell and distribute this software +// is granted provided this copyright notice appears in all copies. +// This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. +// +// See http://www.boost.org/libs/utility/checked_delete.html for documentation. +// + +namespace boost +{ + +// verify that types are complete for increased safety + +template inline void checked_delete(T * x) +{ + // intentionally complex - simplification causes regressions + typedef char type_must_be_complete[ sizeof(T)? 1: -1 ]; + (void) sizeof(type_must_be_complete); + delete x; +} + +template inline void checked_array_delete(T * x) +{ + typedef char type_must_be_complete[ sizeof(T)? 1: -1 ]; + (void) sizeof(type_must_be_complete); + delete [] x; +} + +template struct checked_deleter +{ + typedef void result_type; + typedef T * argument_type; + + void operator()(T * x) const + { + // boost:: disables ADL + boost::checked_delete(x); + } +}; + +template struct checked_array_deleter +{ + typedef void result_type; + typedef T * argument_type; + + void operator()(T * x) const + { + boost::checked_array_delete(x); + } +}; + +} // namespace boost + +#endif // #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/config.hpp b/deal.II/contrib/boost/include/boost/config.hpp new file mode 100644 index 0000000000..8e37a39e96 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/config.hpp @@ -0,0 +1,69 @@ +// Boost config.hpp configuration header file ------------------------------// + +// (C) Copyright Boost.org 2001. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org/libs/config for most recent version. + +// Boost config.hpp policy and rationale documentation has been moved to +// http://www.boost.org/libs/config +// +// CAUTION: This file is intended to be completely stable - +// DO NOT MODIFY THIS FILE! +// + +#ifndef BOOST_CONFIG_HPP +#define BOOST_CONFIG_HPP + +// if we don't have a user config, then use the default location: +#if !defined(BOOST_USER_CONFIG) && !defined(BOOST_NO_USER_CONFIG) +# define BOOST_USER_CONFIG +#endif +// include it first: +#ifdef BOOST_USER_CONFIG +# include BOOST_USER_CONFIG +#endif + +// if we don't have a compiler config set, try and find one: +#if !defined(BOOST_COMPILER_CONFIG) && !defined(BOOST_NO_COMPILER_CONFIG) && !defined(BOOST_NO_CONFIG) +# include +#endif +// if we have a compiler config, include it now: +#ifdef BOOST_COMPILER_CONFIG +# include BOOST_COMPILER_CONFIG +#endif + +// if we don't have a std library config set, try and find one: +#if !defined(BOOST_STDLIB_CONFIG) && !defined(BOOST_NO_STDLIB_CONFIG) && !defined(BOOST_NO_CONFIG) +# include +#endif +// if we have a std library config, include it now: +#ifdef BOOST_STDLIB_CONFIG +# include BOOST_STDLIB_CONFIG +#endif + +// if we don't have a platform config set, try and find one: +#if !defined(BOOST_PLATFORM_CONFIG) && !defined(BOOST_NO_PLATFORM_CONFIG) && !defined(BOOST_NO_CONFIG) +# include +#endif +// if we have a platform config, include it now: +#ifdef BOOST_PLATFORM_CONFIG +# include BOOST_PLATFORM_CONFIG +#endif + +// get config suffix code: +#include + +#endif // BOOST_CONFIG_HPP + + + + + + + + + + diff --git a/deal.II/contrib/boost/include/boost/config/compiler/gcc.hpp b/deal.II/contrib/boost/include/boost/config/compiler/gcc.hpp new file mode 100644 index 0000000000..5c8e231cde --- /dev/null +++ b/deal.II/contrib/boost/include/boost/config/compiler/gcc.hpp @@ -0,0 +1,84 @@ +// (C) Copyright Boost.org 2001. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org for most recent version. + +// GNU C++ compiler setup: + +# if __GNUC__ == 2 && __GNUC_MINOR__ == 91 + // egcs 1.1 won't parse shared_ptr.hpp without this: +# define BOOST_NO_AUTO_PTR +# endif +# if __GNUC__ == 2 && __GNUC_MINOR__ < 95 + // + // Prior to gcc 2.95 member templates only partly + // work - define BOOST_MSVC6_MEMBER_TEMPLATES + // instead since inline member templates mostly work. + // +# define BOOST_NO_MEMBER_TEMPLATES +# if __GNUC_MINOR__ >= 9 +# define BOOST_MSVC6_MEMBER_TEMPLATES +# endif +# endif + +# if __GNUC__ == 2 && __GNUC_MINOR__ <= 97 +# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS +# define BOOST_NO_OPERATORS_IN_NAMESPACE +# endif + +# if __GNUC__ < 3 +# define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE +# endif + +#ifndef __EXCEPTIONS +# define BOOST_NO_EXCEPTIONS +#endif + +// +// Bug specific to gcc 3.1 and 3.2: +// +#if (__GNUC__ == 3) && ((__GNUC_MINOR__ == 1) || (__GNUC_MINOR__ == 2)) +# define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS +#endif + +// +// Threading support: Turn this on unconditionally here (except for +// those platforms where we can know for sure). It will get turned off again +// later if no threading API is detected. +// +#if !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(linux) && !defined(__linux) && !defined(__linux__) +# define BOOST_HAS_THREADS +#endif + +// +// gcc has "long long" +// +#define BOOST_HAS_LONG_LONG + +// +// gcc implements the named return value optimization since version 3.1 +// +#if __GNUC__ > 3 || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 1 ) +#define BOOST_HAS_NRVO +#endif + +#define BOOST_COMPILER "GNU C++ version " __VERSION__ + +// +// versions check: +// we don't know gcc prior to version 2.90: +#if (__GNUC__ == 2) && (__GNUC_MINOR__ < 90) +# error "Compiler not configured - please reconfigure" +#endif +// +// last known and checked version is 3.3: +#if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 3)) +# if defined(BOOST_ASSERT_CONFIG) +# error "Unknown compiler version - please run the configure tests and report the results" +# else +# warning "Unknown compiler version - please run the configure tests and report the results" +# endif +#endif + diff --git a/deal.II/contrib/boost/include/boost/config/platform/linux.hpp b/deal.II/contrib/boost/include/boost/config/platform/linux.hpp new file mode 100644 index 0000000000..21e375ef23 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/config/platform/linux.hpp @@ -0,0 +1,96 @@ +// (C) Copyright Boost.org 2001. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org for most recent version. + +// linux specific config options: + +#define BOOST_PLATFORM "linux" + +// make sure we have __GLIBC_PREREQ if available at all +#include + +// +// added to glibc 2.1.1 +// We can only test for 2.1 though: +// +#if defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 1))) + // defines int64_t unconditionally, but defines + // int64_t only if __GNUC__. Thus, assume a fully usable + // only when using GCC. +# if defined __GNUC__ +# define BOOST_HAS_STDINT_H +# endif +#endif + +#if defined(__LIBCOMO__) + // + // como on linux doesn't have std:: c functions: + // NOTE: versions of libcomo prior to beta28 have octal version numbering, + // e.g. version 25 is 21 (dec) + // +# if __LIBCOMO_VERSION__ <= 20 +# define BOOST_NO_STDC_NAMESPACE +# endif + +# if __LIBCOMO_VERSION__ <= 21 +# define BOOST_NO_SWPRINTF +# endif + +#endif + +// +// If glibc is past version 2 then we definitely have +// gettimeofday, earlier versions may or may not have it: +// +#if defined(__GLIBC__) && (__GLIBC__ >= 2) +# define BOOST_HAS_GETTIMEOFDAY +#endif + +#ifdef __USE_POSIX199309 +# define BOOST_HAS_NANOSLEEP +#endif + +#if defined(__GLIBC__) && defined(__GLIBC_PREREQ) +// __GLIBC_PREREQ is available since 2.1.2 + + // swprintf is available since glibc 2.2.0 +# if !__GLIBC_PREREQ(2,2) || (!defined(__USE_ISOC99) && !defined(__USE_UNIX98)) +# define BOOST_NO_SWPRINTF +# endif +#else +# define BOOST_NO_SWPRINTF +#endif + +// boilerplate code: +#define BOOST_HAS_UNISTD_H +#include + +#ifndef __GNUC__ +// +// if the compiler is not gcc we still need to be able to parse +// the GNU system headers, some of which (mainly ) +// use GNU specific extensions: +// +# ifndef __extension__ +# define __extension__ +# endif +# ifndef __const__ +# define __const__ const +# endif +# ifndef __volatile__ +# define __volatile__ volatile +# endif +# ifndef __signed__ +# define __signed__ signed +# endif +# ifndef __typeof__ +# define __typeof__ typeof +# endif +# ifndef __inline__ +# define __inline__ inline +# endif +#endif + diff --git a/deal.II/contrib/boost/include/boost/config/posix_features.hpp b/deal.II/contrib/boost/include/boost/config/posix_features.hpp new file mode 100644 index 0000000000..81979c3ff9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/config/posix_features.hpp @@ -0,0 +1,85 @@ +// (C) Copyright Boost.org 2001. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org for most recent version. + +// All POSIX feature tests go in this file, +// Note that we test _POSIX_C_SOURCE and _XOPEN_SOURCE as well +// _POSIX_VERSION and _XOPEN_VERSION: on some systems POSIX API's +// may be present but none-functional unless _POSIX_C_SOURCE and +// _XOPEN_SOURCE have been defined to the right value (it's up +// to the user to do this *before* including any header, although +// in most cases the compiler will do this for you). + +# if defined(BOOST_HAS_UNISTD_H) +# include + + // XOpen has , but is this the correct version check? +# if defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 3) +# define BOOST_HAS_NL_TYPES_H +# endif + + // POSIX version 6 requires +# if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 200100) +# define BOOST_HAS_STDINT_H +# endif + + // POSIX version 2 requires +# if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199009L) +# define BOOST_HAS_DIRENT_H +# endif + + // POSIX version 3 requires to have sigaction: +# if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199506L) +# define BOOST_HAS_SIGACTION +# endif + // POSIX defines _POSIX_THREADS > 0 for pthread support, + // however some platforms define _POSIX_THREADS without + // a value, hence the (_POSIX_THREADS+0 >= 0) check. + // Strictly speaking this may catch platforms with a + // non-functioning stub , but such occurrences should + // occur very rarely if at all. +# if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_MPTASKS) +# define BOOST_HAS_PTHREADS +# endif + + // BOOST_HAS_NANOSLEEP: + // This is predicated on _POSIX_TIMERS or _XOPEN_REALTIME: +# if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0)) \ + || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0)) +# define BOOST_HAS_NANOSLEEP +# endif + + // BOOST_HAS_CLOCK_GETTIME: + // This is predicated on _POSIX_TIMERS (also on _XOPEN_REALTIME + // but at least one platform - linux - defines that flag without + // defining clock_gettime): +# if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0)) +# define BOOST_HAS_CLOCK_GETTIME +# endif + + // BOOST_HAS_SCHED_YIELD: + // This is predicated on _POSIX_PRIORITY_SCHEDULING or + // on _POSIX_THREAD_PRIORITY_SCHEDULING or on _XOPEN_REALTIME. +# if defined(_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING+0 > 0)\ + || (defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING+0 > 0))\ + || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0)) +# define BOOST_HAS_SCHED_YIELD +# endif + + // BOOST_HAS_GETTIMEOFDAY: + // BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE: + // These are predicated on _XOPEN_VERSION, and appears to be first released + // in issue 4, version 2 (_XOPEN_VERSION > 500). +# if defined(_XOPEN_VERSION) && (_XOPEN_VERSION+0 >= 500) +# define BOOST_HAS_GETTIMEOFDAY +# if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 500) +# define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE +# endif +# endif + +# endif + + diff --git a/deal.II/contrib/boost/include/boost/config/select_compiler_config.hpp b/deal.II/contrib/boost/include/boost/config/select_compiler_config.hpp new file mode 100644 index 0000000000..8a16a48c04 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/config/select_compiler_config.hpp @@ -0,0 +1,78 @@ +// Boost compiler configuration selection header file + +// (C) Copyright Boost.org 2001. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org for most recent version. + +// locate which compiler we are using and define +// BOOST_COMPILER_CONFIG as needed: + +# if defined __COMO__ +// Comeau C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/comeau.hpp" + +#elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC) +// Intel +# define BOOST_COMPILER_CONFIG "boost/config/compiler/intel.hpp" + +# elif defined __GNUC__ +// GNU C++: +# define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp" + +#elif defined __KCC +// Kai C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/kai.hpp" + +#elif defined __sgi +// SGI MIPSpro C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/sgi_mipspro.hpp" + +#elif defined __DECCXX +// Compaq Tru64 Unix cxx +# define BOOST_COMPILER_CONFIG "boost/config/compiler/compaq_cxx.hpp" + +#elif defined __ghs +// Greenhills C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/greenhills.hpp" + +#elif defined __BORLANDC__ +// Borland +# define BOOST_COMPILER_CONFIG "boost/config/compiler/borland.hpp" + +#elif defined __MWERKS__ +// Metrowerks CodeWarrior +# define BOOST_COMPILER_CONFIG "boost/config/compiler/metrowerks.hpp" + +#elif defined __SUNPRO_CC +// Sun Workshop Compiler C++ +# define BOOST_COMPILER_CONFIG "boost/config/compiler/sunpro_cc.hpp" + +#elif defined __HP_aCC +// HP aCC +# define BOOST_COMPILER_CONFIG "boost/config/compiler/hp_acc.hpp" + +#elif defined(__MRC__) || defined(__SC__) +// MPW MrCpp or SCpp +# define BOOST_COMPILER_CONFIG "boost/config/compiler/mpw.hpp" + +#elif defined(__IBMCPP__) +// IBM Visual Age +# define BOOST_COMPILER_CONFIG "boost/config/compiler/vacpp.hpp" + +#elif defined _MSC_VER +// Microsoft Visual C++ +// +// Must remain the last #elif since some other vendors (Metrowerks, for +// example) also #define _MSC_VER +# define BOOST_COMPILER_CONFIG "boost/config/compiler/visualc.hpp" + +#elif defined (BOOST_ASSERT_CONFIG) +// this must come last - generate an error if we don't +// recognise the compiler: +# error "Unknown compiler - please configure and report the results to boost.org" + +#endif + diff --git a/deal.II/contrib/boost/include/boost/config/select_platform_config.hpp b/deal.II/contrib/boost/include/boost/config/select_platform_config.hpp new file mode 100644 index 0000000000..5921cc5e55 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/config/select_platform_config.hpp @@ -0,0 +1,84 @@ +// Boost compiler configuration selection header file + +// (C) Copyright Boost.org 2001. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org for most recent version. + +// locate which platform we are on and define BOOST_PLATFORM_CONFIG as needed. +// Note that we define the headers to include using "header_name" not +// in order to prevent macro expansion within the header +// name (for example "linux" is a macro on linux systems). + +#if defined(linux) || defined(__linux) || defined(__linux__) +// linux: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp" + +#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) +// BSD: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/bsd.hpp" + +#elif defined(sun) || defined(__sun) +// solaris: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/solaris.hpp" + +#elif defined(__sgi) +// SGI Irix: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/irix.hpp" + +#elif defined(__hpux) +// hp unix: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/hpux.hpp" + +#elif defined(__CYGWIN__) +// cygwin is not win32: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/cygwin.hpp" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +// win32: +# define BOOST_PLATFORM_CONFIG "boost/config/platform/win32.hpp" + +#elif defined(__BEOS__) +// BeOS +# define BOOST_PLATFORM_CONFIG "boost/config/platform/beos.hpp" + +#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) +// MacOS +# define BOOST_PLATFORM_CONFIG "boost/config/platform/macos.hpp" + +#elif defined(__IBMCPP__) +// IBM +# define BOOST_PLATFORM_CONFIG "boost/config/platform/aix.hpp" + +#elif defined(__amigaos__) +// AmigaOS +# define BOOST_PLATFORM_CONFIG "boost/config/platform/amigaos.hpp" + +#else + +# if defined(unix) \ + || defined(__unix) \ + || defined(_XOPEN_SOURCE) \ + || defined(_POSIX_SOURCE) + + // generic unix platform: + +# ifndef BOOST_HAS_UNISTD_H +# define BOOST_HAS_UNISTD_H +# endif + +# include + +# endif + +# if defined (BOOST_ASSERT_CONFIG) + // this must come last - generate an error if we don't + // recognise the platform: +# error "Unknown platform - please configure and report the results to boost.org" +# endif + +#endif + + diff --git a/deal.II/contrib/boost/include/boost/config/select_stdlib_config.hpp b/deal.II/contrib/boost/include/boost/config/select_stdlib_config.hpp new file mode 100644 index 0000000000..668b97c5fd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/config/select_stdlib_config.hpp @@ -0,0 +1,65 @@ +// Boost compiler configuration selection header file + +// (C) Copyright Boost.org 2001. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org for most recent version. + +// locate which std lib we are using and define BOOST_STDLIB_CONFIG as needed: + +// we need to include a std lib header here in order to detect which +// library is in use, use as it's about the smallest +// of the std lib headers - do not rely on this header being included - +// users can short-circuit this header if they know whose std lib +// they are using. + +#include + +#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) +// STLPort library; this _must_ come first, otherwise since +// STLport typically sits on top of some other library, we +// can end up detecting that first rather than STLport: +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/stlport.hpp" + +#elif defined(__LIBCOMO__) +// Comeau STL: +#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcomo.hpp" + +#elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER) +// Rogue Wave library: +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/roguewave.hpp" + +#elif defined(__GLIBCPP__) +// GNU libstdc++ 3 +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp" + +#elif defined(__STL_CONFIG_H) +// generic SGI STL +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/sgi.hpp" + +#elif defined(__MSL_CPP__) +// MSL standard lib: +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/msl.hpp" + +#elif defined(__IBMCPP__) +// take the default VACPP std lib +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/vacpp.hpp" + +#elif defined(MSIPL_COMPILE_H) +// Modena C++ standard library +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/modena.hpp" + +#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER) +// Dinkumware Library (this has to appear after any possible replacement libraries): +# define BOOST_STDLIB_CONFIG "boost/config/stdlib/dinkumware.hpp" + +#elif defined (BOOST_ASSERT_CONFIG) +// this must come last - generate an error if we don't +// recognise the library: +# error "Unknown standard library - please configure and report the results to boost.org" + +#endif + + diff --git a/deal.II/contrib/boost/include/boost/config/stdlib/sgi.hpp b/deal.II/contrib/boost/include/boost/config/stdlib/sgi.hpp new file mode 100644 index 0000000000..dd086c2c95 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/config/stdlib/sgi.hpp @@ -0,0 +1,107 @@ +// (C) Copyright Boost.org 2001. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org for most recent version. + +// generic SGI STL: + +#if !defined(__STL_CONFIG_H) +# include +# if !defined(__STL_CONFIG_H) +# error "This is not the SGI STL!" +# endif +#endif + +// +// No std::iterator traits without partial specialisation: +// +#if !defined(__STL_CLASS_PARTIAL_SPECIALIZATION) +# define BOOST_NO_STD_ITERATOR_TRAITS +#endif + +// +// No std::stringstream with gcc < 3 +// +#if defined(__GNUC__) && (__GNUC__ < 3) && \ + ((__GNUC_MINOR__ < 95) || (__GNUC_MINOR__ == 96)) && \ + !defined(__STL_USE_NEW_IOSTREAMS) || \ + defined(__APPLE_CC__) + // Note that we only set this for GNU C++ prior to 2.95 since the + // latest patches for that release do contain a minimal + // If you are running a 2.95 release prior to 2.95.3 then this will need + // setting, but there is no way to detect that automatically (other + // than by running the configure script). + // Also, the unofficial GNU C++ 2.96 included in RedHat 7.1 doesn't + // have . +# define BOOST_NO_STRINGSTREAM +#endif + +// +// Assume no std::locale without own iostreams (this may be an +// incorrect assumption in some cases): +// +#if !defined(__SGI_STL_OWN_IOSTREAMS) && !defined(__STL_USE_NEW_IOSTREAMS) +# define BOOST_NO_STD_LOCALE +#endif + +// +// Original native SGI streams have non-standard std::messages facet: +// +#if defined(__sgi) && (_COMPILER_VERSION <= 650) && !defined(__SGI_STL_OWN_IOSTREAMS) +# define BOOST_NO_STD_LOCALE +#endif + +// +// SGI's new iostreams have missing "const" in messages<>::open +// +#if defined(__sgi) && (_COMPILER_VERSION <= 730) && defined(__STL_USE_NEW_IOSTREAMS) +# define BOOST_NO_STD_MESSAGES +#endif + +// +// No template iterator constructors, or std::allocator +// without member templates: +// +#if !defined(__STL_MEMBER_TEMPLATES) +# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS +# define BOOST_NO_STD_ALLOCATOR +#endif + +// +// We always have SGI style hash_set, hash_map, and slist: +// +#define BOOST_HAS_HASH +#define BOOST_HAS_SLIST + +// +// If this is GNU libstdc++2, then no and no std::wstring: +// +#if (defined(__GNUC__) && (__GNUC__ < 3)) +# include +# if defined(__BASTRING__) +# define BOOST_NO_LIMITS +// Note: will provide compile-time constants +# undef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS +# define BOOST_NO_STD_WSTRING +# endif +#endif + +// +// There is no standard iterator unless we have namespace support: +// +#if !defined(__STL_USE_NAMESPACES) +# define BOOST_NO_STD_ITERATOR +#endif + +// +// Intrinsic type_traits support. +// The SGI STL has it's own __type_traits class, which +// has intrinsic compiler support with SGI's compilers. +// Whatever map SGI style type traits to boost equivalents: +// +#define BOOST_HAS_SGI_TYPE_TRAITS + +#define BOOST_STDLIB "SGI standard library" + diff --git a/deal.II/contrib/boost/include/boost/config/suffix.hpp b/deal.II/contrib/boost/include/boost/config/suffix.hpp new file mode 100644 index 0000000000..6635666bc1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/config/suffix.hpp @@ -0,0 +1,383 @@ +// Boost config.hpp configuration header file ------------------------------// + +// (C) Copyright Boost.org 2001. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org for most recent version. + +// Boost config.hpp policy and rationale documentation has been moved to +// http://www.boost.org/libs/config +// +// This file is intended to be stable, and relatively unchanging. +// It should contain boilerplate code only - no compiler specific +// code unless it is unavoidable - no changes unless unavoidable. + +#ifndef BOOST_CONFIG_SUFFIX_HPP +#define BOOST_CONFIG_SUFFIX_HPP + +// +// look for long long by looking for the appropriate macros in . +// Note that we use limits.h rather than climits for maximal portability, +// remember that since these just declare a bunch of macros, there should be +// no namespace issues from this. +// +#include +# if !defined(BOOST_HAS_LONG_LONG) \ + && !(defined(BOOST_MSVC) && BOOST_MSVC <=1300) && !defined(__BORLANDC__) \ + && (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) +# define BOOST_HAS_LONG_LONG +#endif +#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T) +# define BOOST_NO_INTEGRAL_INT64_T +#endif + +// GCC 3.x will clean up all of those nasty macro definitions that +// BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine +// it under GCC 3.x. +#if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS) +# undef BOOST_NO_CTYPE_FUNCTIONS +#endif + + +// +// Assume any extensions are in namespace std:: unless stated otherwise: +// +# ifndef BOOST_STD_EXTENSION_NAMESPACE +# define BOOST_STD_EXTENSION_NAMESPACE std +# endif + +// +// If cv-qualified specializations are not allowed, then neither are cv-void ones: +// +# if defined(BOOST_NO_CV_SPECIALIZATIONS) \ + && !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS) +# define BOOST_NO_CV_VOID_SPECIALIZATIONS +# endif + +// +// If there is no numeric_limits template, then it can't have any compile time +// constants either! +// +# if defined(BOOST_NO_LIMITS) \ + && !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) +# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS +# define BOOST_NO_MS_INT64_NUMERIC_LIMITS +# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS +# endif + +// +// if there is no long long then there is no specialisation +// for numeric_limits either: +// +#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS) +# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS +#endif + +// +// if there is no __int64 then there is no specialisation +// for numeric_limits<__int64> either: +// +#if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS) +# define BOOST_NO_MS_INT64_NUMERIC_LIMITS +#endif + +// +// if member templates are supported then so is the +// VC6 subset of member templates: +// +# if !defined(BOOST_NO_MEMBER_TEMPLATES) \ + && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) +# define BOOST_MSVC6_MEMBER_TEMPLATES +# endif + +// +// Without partial specialization, can't test for partial specialisation bugs: +// +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) +# define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG +# endif + +// +// Without partial specialization, std::iterator_traits can't work: +// +# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_NO_STD_ITERATOR_TRAITS) +# define BOOST_NO_STD_ITERATOR_TRAITS +# endif + +// +// Without member template support, we can't have template constructors +// in the standard library either: +// +# if defined(BOOST_NO_MEMBER_TEMPLATES) \ + && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ + && !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) +# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS +# endif + +// +// Without member template support, we can't have a conforming +// std::allocator template either: +// +# if defined(BOOST_NO_MEMBER_TEMPLATES) \ + && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ + && !defined(BOOST_NO_STD_ALLOCATOR) +# define BOOST_NO_STD_ALLOCATOR +# endif + +// +// If we have a standard allocator, then we have a partial one as well: +// +#if !defined(BOOST_NO_STD_ALLOCATOR) +# define BOOST_HAS_PARTIAL_STD_ALLOCATOR +#endif + +// +// We can't have a working std::use_facet if there is no std::locale: +// +# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET) +# define BOOST_NO_STD_USE_FACET +# endif + +// +// We can't have a std::messages facet if there is no std::locale: +// +# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES) +# define BOOST_NO_STD_MESSAGES +# endif + +// +// We can't have a working std::wstreambuf if there is no std::locale: +// +# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF) +# define BOOST_NO_STD_WSTREAMBUF +# endif + +// +// We can't have a if there is no : +// +# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE) +# define BOOST_NO_CWCTYPE +# endif + +// +// We can't have a swprintf if there is no : +// +# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF) +# define BOOST_NO_SWPRINTF +# endif + +// +// If Win32 support is turned off, then we must turn off +// threading support also, unless there is some other +// thread API enabled: +// +#if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \ + && !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS) +# define BOOST_DISABLE_THREADS +#endif + +// +// Turn on threading support if the compiler thinks that it's in +// multithreaded mode. We put this here because there are only a +// limited number of macros that identify this (if there's any missing +// from here then add to the appropriate compiler section): +// +#if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \ + || defined(_PTHREADS)) && !defined(BOOST_HAS_THREADS) +# define BOOST_HAS_THREADS +#endif + +// +// Turn threading support off if BOOST_DISABLE_THREADS is defined: +// +#if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS) +# undef BOOST_HAS_THREADS +#endif + +// +// Turn threading support off if we don't recognise the threading API: +// +#if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\ + && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\ + && !defined(BOOST_HAS_MPTASKS) +# undef BOOST_HAS_THREADS +#endif + +// +// If the compiler claims to be C99 conformant, then it had better +// have a : +// +# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901) +# define BOOST_HAS_STDINT_H +# endif + +// +// Define BOOST_NO_SLIST and BOOST_NO_HASH if required. +// Note that this is for backwards compatibility only. +// +# ifndef BOOST_HAS_SLIST +# define BOOST_NO_SLIST +# endif + +# ifndef BOOST_HAS_HASH +# define BOOST_NO_HASH +# endif + +// BOOST_NO_STDC_NAMESPACE workaround --------------------------------------// +// Because std::size_t usage is so common, even in boost headers which do not +// otherwise use the C library, the workaround is included here so +// that ugly workaround code need not appear in many other boost headers. +// NOTE WELL: This is a workaround for non-conforming compilers; +// must still be #included in the usual places so that inclusion +// works as expected with standard conforming compilers. The resulting +// double inclusion of is harmless. + +# ifdef BOOST_NO_STDC_NAMESPACE +# include + namespace std { using ::ptrdiff_t; using ::size_t; } +# endif + +// BOOST_NO_STD_MIN_MAX workaround -----------------------------------------// + +# ifdef BOOST_NO_STD_MIN_MAX + +namespace std { + template + inline const _Tp& min(const _Tp& __a, const _Tp& __b) { + return __b < __a ? __b : __a; + } + template + inline const _Tp& max(const _Tp& __a, const _Tp& __b) { + return __a < __b ? __b : __a; + } +} + +# endif + +// BOOST_STATIC_CONSTANT workaround --------------------------------------- // +// On compilers which don't allow in-class initialization of static integral +// constant members, we must use enums as a workaround if we want the constants +// to be available at compile-time. This macro gives us a convenient way to +// declare such constants. + +# ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION +# define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment } +# else +# define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment +# endif + +// BOOST_USE_FACET workaround ----------------------------------------------// +// When the standard library does not have a conforming std::use_facet there +// are various workarounds available, but they differ from library to library. +// This macro provides a consistent way to access a locale's facets. +// Usage: +// replace +// std::use_facet(loc); +// with +// BOOST_USE_FACET(Type, loc); +// Note do not add a std:: prefix to the front of BOOST_USE_FACET! + +#if defined(BOOST_NO_STD_USE_FACET) +# ifdef BOOST_HAS_TWO_ARG_USE_FACET +# define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast(0)) +# elif defined(BOOST_HAS_MACRO_USE_FACET) +# define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type) +# elif defined(BOOST_HAS_STLP_USE_FACET) +# define BOOST_USE_FACET(Type, loc) (*std::_Use_facet(loc)) +# endif +#else +# define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc) +#endif + +// BOOST_NESTED_TEMPLATE workaround ------------------------------------------// +// Member templates are supported by some compilers even though they can't use +// the A::template member syntax, as a workaround replace: +// +// typedef typename A::template rebind binder; +// +// with: +// +// typedef typename A::BOOST_NESTED_TEMPLATE rebind binder; + +#ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD +# define BOOST_NESTED_TEMPLATE template +#else +# define BOOST_NESTED_TEMPLATE +#endif + +// BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------// +// Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION +// is defined, in which case it evaluates to return x; Use when you have a return +// statement that can never be reached. + +#ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION +# define BOOST_UNREACHABLE_RETURN(x) return x; +#else +# define BOOST_UNREACHABLE_RETURN(x) +#endif + +// BOOST_DEDUCED_TYPENAME workaround ------------------------------------------// +// +// Some compilers don't support the use of `typename' for dependent +// types in deduced contexts, e.g. +// +// template void f(T, typename T::type); +// ^^^^^^^^ +// Replace these declarations with: +// +// template void f(T, BOOST_DEDUCED_TYPENAME T::type); + +#ifndef BOOST_NO_DEDUCED_TYPENAME +# define BOOST_DEDUCED_TYPENAME typename +#else +# define BOOST_DEDUCED_TYPENAME +#endif + +// ---------------------------------------------------------------------------// + +// +// Helper macro BOOST_STRINGIZE: +// Converts the parameter X to a string after macro replacement +// on X has been performed. +// +#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X) +#define BOOST_DO_STRINGIZE(X) #X + +// +// Helper macro BOOST_JOIN: +// The following piece of macro magic joins the two +// arguments together, even when one of the arguments is +// itself a macro (see 16.3.1 in C++ standard). The key +// is that macro expansion of macro arguments does not +// occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN. +// +#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y ) +#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y) +#define BOOST_DO_JOIN2( X, Y ) X##Y + +// +// Set some default values for compiler/library/platform names. +// These are for debugging config setup only: +// +# ifndef BOOST_COMPILER +# define BOOST_COMPILER "Unknown ISO C++ Compiler" +# endif +# ifndef BOOST_STDLIB +# define BOOST_STDLIB "Unknown ISO standard library" +# endif +# ifndef BOOST_PLATFORM +# if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \ + || defined(_POSIX_SOURCE) +# define BOOST_PLATFORM "Generic Unix" +# else +# define BOOST_PLATFORM "Unknown" +# endif +# endif + +#endif + + diff --git a/deal.II/contrib/boost/include/boost/config/user.hpp b/deal.II/contrib/boost/include/boost/config/user.hpp new file mode 100644 index 0000000000..98adbac909 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/config/user.hpp @@ -0,0 +1,68 @@ +// boost/config/user.hpp ---------------------------------------------------// + +// (C) Copyright Boost.org 2001. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// Do not check in modified versions of this file, +// This file may be customized by the end user, but not by boost. + +// +// Use this file to define a site and compiler specific +// configuration policy: +// + +// define this to locate a compiler config file: +// #define BOOST_COMPILER_CONFIG + +// define this to locate a stdlib config file: +// #define BOOST_STDLIB_CONFIG + +// define this to locate a platform config file: +// #define BOOST_PLATFORM_CONFIG + +// define this to disable compiler config, +// use if your compiler config has nothing to set: +// #define BOOST_NO_COMPILER_CONFIG + +// define this to disable stdlib config, +// use if your stdlib config has nothing to set: +// #define BOOST_NO_STDLIB_CONFIG + +// define this to disable platform config, +// use if your platform config has nothing to set: +// #define BOOST_NO_PLATFORM_CONFIG + +// define this to disable all config options, +// excluding the user config. Use if your +// setup is fully ISO compliant, and has no +// useful extensions, or for autoconf generated +// setups: +// #define BOOST_NO_CONFIG + +// define this to make the config "optimistic" +// about unknown compiler versions. Normally +// unknown compiler versions are assumed to have +// all the defects of the last known version, however +// setting this flag, causes the config to assume +// that unknown compiler versions are fully conformant +// with the standard: +// #define BOOST_STRICT_CONFIG + +// define this to cause the config to halt compilation +// with an #error if it encounters anything unknown -- +// either an unknown compiler version or an unknown +// compiler/platform/library: +// #define BOOST_ASSERT_CONFIG + + +// define if you want to disable threading support, even +// when available: +// #define BOOST_DISABLE_THREADS + +// define when you want to disable Win32 specific features +// even when available: +// #define BOOST_DISABLE_WIN32 + + diff --git a/deal.II/contrib/boost/include/boost/detail/lightweight_mutex.hpp b/deal.II/contrib/boost/include/boost/detail/lightweight_mutex.hpp new file mode 100644 index 0000000000..1310da3755 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/detail/lightweight_mutex.hpp @@ -0,0 +1,89 @@ +#ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED +#define BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED + +#if _MSC_VER >= 1020 +#pragma once +#endif + +// +// boost/detail/lightweight_mutex.hpp - lightweight mutex +// +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// +// Permission to copy, use, modify, sell and distribute this software +// is granted provided this copyright notice appears in all copies. +// This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. +// +// typedef boost::detail::lightweight_mutex; +// +// boost::detail::lightweight_mutex meets a subset of the Mutex concept +// requirements: http://www.boost.org/libs/thread/doc/mutex_concept.html#Mutex +// +// * Used by the smart pointer library +// * Performance oriented +// * Header-only implementation +// * Small memory footprint +// * Not a general purpose mutex, use boost::mutex, CRITICAL_SECTION or +// pthread_mutex instead. +// * Never spin in a tight lock/do-something/unlock loop, since +// lightweight_mutex does not guarantee fairness. +// * Never keep a lightweight_mutex locked for long periods. +// +// The current implementation can use a pthread_mutex, a CRITICAL_SECTION, +// or a platform-specific spinlock. +// +// You can force a particular implementation by defining BOOST_LWM_USE_PTHREADS, +// BOOST_LWM_USE_CRITICAL_SECTION, or BOOST_LWM_USE_SPINLOCK. +// +// If neither macro has been defined, the default is to use a spinlock on Win32, +// and a pthread_mutex otherwise. +// +// Note that a spinlock is not a general synchronization primitive. In particular, +// it is not guaranteed to be a memory barrier, and it is possible to "livelock" +// if a lower-priority thread has acquired the spinlock but a higher-priority +// thread is spinning trying to acquire the same lock. +// +// For these reasons, spinlocks have been disabled by default except on Windows, +// where a spinlock can be several orders of magnitude faster than a CRITICAL_SECTION. + + +// Note: lwm_linux.hpp has been disabled by default; see the comments +// inside for more info. + + +#include + +// Note to implementors: if you write a platform-specific spinlock +// for a platform that supports pthreads, be sure to test its performance +// against the pthreads-based version using shared_ptr_timing_test.cpp and +// shared_ptr_mt_test.cpp. Custom versions are usually not worth the trouble +// _unless_ the performance gains are substantial. +// +// Be sure to compare against a "real" pthreads library; +// shared_ptr_timing_test.cpp will compile succesfully with a stub do-nothing +// pthreads library, since it doesn't create any threads. + +#ifndef BOOST_HAS_THREADS +# include +#elif defined(BOOST_LWM_USE_SPINLOCK) && defined(BOOST_USE_ASM_ATOMIC_H) +# include +#elif defined(BOOST_LWM_USE_CRITICAL_SECTION) +# include +#elif defined(BOOST_LWM_USE_PTHREADS) +# include +#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) +# include +#elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__sgi) +# include +#elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__GLIBCPP__) +# include +#elif defined(BOOST_HAS_PTHREADS) +# define BOOST_LWM_USE_PTHREADS +# include +#else +// Use #define BOOST_DISABLE_THREADS to avoid the error +# error Unrecognized threading platform +#endif + +#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/detail/lwm_nop.hpp b/deal.II/contrib/boost/include/boost/detail/lwm_nop.hpp new file mode 100644 index 0000000000..671a5b0474 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/detail/lwm_nop.hpp @@ -0,0 +1,36 @@ +#ifndef BOOST_DETAIL_LWM_NOP_HPP_INCLUDED +#define BOOST_DETAIL_LWM_NOP_HPP_INCLUDED + +#if _MSC_VER >= 1020 +#pragma once +#endif + +// +// boost/detail/lwm_nop.hpp +// +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// +// Permission to copy, use, modify, sell and distribute this software +// is granted provided this copyright notice appears in all copies. +// This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. +// + +namespace boost +{ + +namespace detail +{ + +class lightweight_mutex +{ +public: + + typedef lightweight_mutex scoped_lock; +}; + +} // namespace detail + +} // namespace boost + +#endif // #ifndef BOOST_DETAIL_LWM_NOP_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/detail/shared_count.hpp b/deal.II/contrib/boost/include/boost/detail/shared_count.hpp new file mode 100644 index 0000000000..3ade9f91ab --- /dev/null +++ b/deal.II/contrib/boost/include/boost/detail/shared_count.hpp @@ -0,0 +1,552 @@ +#ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED +#define BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +// +// detail/shared_count.hpp +// +// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd. +// +// Permission to copy, use, modify, sell and distribute this software +// is granted provided this copyright notice appears in all copies. +// This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. +// + +#include + +#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR) +# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible. +#endif + +#include +#include +#include + +#if defined(BOOST_SP_USE_QUICK_ALLOCATOR) +#include +#endif + +#include // std::auto_ptr, std::allocator +#include // std::less +#include // std::exception +#include // std::bad_alloc +#include // std::type_info in get_deleter +#include // std::size_t + +#ifdef __BORLANDC__ +# pragma warn -8026 // Functions with excep. spec. are not expanded inline +# pragma warn -8027 // Functions containing try are not expanded inline +#endif + +namespace boost +{ + +// Debug hooks + +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + +void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn); +void sp_array_constructor_hook(void * px); +void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn); +void sp_array_destructor_hook(void * px); + +#endif + + +// The standard library that comes with Borland C++ 5.5.1 +// defines std::exception and its members as having C calling +// convention (-pc). When the definition of bad_weak_ptr +// is compiled with -ps, the compiler issues an error. +// Hence, the temporary #pragma option -pc below. The version +// check is deliberately conservative. + +#if defined(__BORLANDC__) && __BORLANDC__ == 0x551 +# pragma option push -pc +#endif + +class bad_weak_ptr: public std::exception +{ +public: + + virtual char const * what() const throw() + { + return "boost::bad_weak_ptr"; + } +}; + +#if defined(__BORLANDC__) && __BORLANDC__ == 0x551 +# pragma option pop +#endif + +namespace detail +{ + +class sp_counted_base +{ +private: + + typedef detail::lightweight_mutex mutex_type; + +public: + + sp_counted_base(): use_count_(1), weak_count_(1) + { + } + + virtual ~sp_counted_base() // nothrow + { + } + + // dispose() is called when use_count_ drops to zero, to release + // the resources managed by *this. + + virtual void dispose() = 0; // nothrow + + // destruct() is called when weak_count_ drops to zero. + + virtual void destruct() // nothrow + { + delete this; + } + + virtual void * get_deleter(std::type_info const & ti) = 0; + + void add_ref() + { +#if defined(BOOST_HAS_THREADS) + mutex_type::scoped_lock lock(mtx_); +#endif + if(use_count_ == 0 && weak_count_ != 0) boost::throw_exception(boost::bad_weak_ptr()); + ++use_count_; + ++weak_count_; + } + + void release() // nothrow + { + { +#if defined(BOOST_HAS_THREADS) + mutex_type::scoped_lock lock(mtx_); +#endif + long new_use_count = --use_count_; + + if(new_use_count != 0) + { + --weak_count_; + return; + } + } + + dispose(); + weak_release(); + } + + void weak_add_ref() // nothrow + { +#if defined(BOOST_HAS_THREADS) + mutex_type::scoped_lock lock(mtx_); +#endif + ++weak_count_; + } + + void weak_release() // nothrow + { + long new_weak_count; + + { +#if defined(BOOST_HAS_THREADS) + mutex_type::scoped_lock lock(mtx_); +#endif + new_weak_count = --weak_count_; + } + + if(new_weak_count == 0) + { + destruct(); + } + } + + long use_count() const // nothrow + { +#if defined(BOOST_HAS_THREADS) + mutex_type::scoped_lock lock(mtx_); +#endif + return use_count_; + } + +private: + + sp_counted_base(sp_counted_base const &); + sp_counted_base & operator= (sp_counted_base const &); + + // inv: use_count_ <= weak_count_ + + long use_count_; + long weak_count_; + +#if defined(BOOST_HAS_THREADS) + mutable mutex_type mtx_; +#endif +}; + +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + +template void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter const &, int) +{ + boost::sp_scalar_constructor_hook(px, sizeof(T), pn); +} + +template void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter const &, int) +{ + boost::sp_array_constructor_hook(px); +} + +template void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long) +{ +} + +template void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter const &, int) +{ + boost::sp_scalar_destructor_hook(px, sizeof(T), pn); +} + +template void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter const &, int) +{ + boost::sp_array_destructor_hook(px); +} + +template void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long) +{ +} + +#endif + +// +// Borland's Codeguard trips up over the -Vx- option here: +// +#ifdef __CODEGUARD__ +# pragma option push -Vx- +#endif + +template class sp_counted_base_impl: public sp_counted_base +{ +private: + + P ptr; // copy constructor must not throw + D del; // copy constructor must not throw + + sp_counted_base_impl(sp_counted_base_impl const &); + sp_counted_base_impl & operator= (sp_counted_base_impl const &); + + typedef sp_counted_base_impl this_type; + +public: + + // pre: initial_use_count <= initial_weak_count, d(p) must not throw + + sp_counted_base_impl(P p, D d): ptr(p), del(d) + { +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + detail::cbi_call_constructor_hook(this, p, d, 0); +#endif + } + + virtual void dispose() // nothrow + { +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + detail::cbi_call_destructor_hook(this, ptr, del, 0); +#endif + del(ptr); + } + + virtual void * get_deleter(std::type_info const & ti) + { + return ti == typeid(D)? &del: 0; + } + +#if defined(BOOST_SP_USE_STD_ALLOCATOR) + + void * operator new(std::size_t) + { + return std::allocator().allocate(1, static_cast(0)); + } + + void operator delete(void * p) + { + std::allocator().deallocate(static_cast(p), 1); + } + +#endif + +#if defined(BOOST_SP_USE_QUICK_ALLOCATOR) + + void * operator new(std::size_t) + { + return quick_allocator::alloc(); + } + + void operator delete(void * p) + { + quick_allocator::dealloc(p); + } + +#endif +}; + +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + +int const shared_count_id = 0x2C35F101; +int const weak_count_id = 0x298C38A4; + +#endif + +class weak_count; + +class shared_count +{ +private: + + sp_counted_base * pi_; + +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + int id_; +#endif + + friend class weak_count; + +public: + + shared_count(): pi_(0) // nothrow +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + , id_(shared_count_id) +#endif + { + } + + template shared_count(P p, D d): pi_(0) +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + , id_(shared_count_id) +#endif + { +#ifndef BOOST_NO_EXCEPTIONS + + try + { + pi_ = new sp_counted_base_impl(p, d); + } + catch(...) + { + d(p); // delete p + throw; + } + +#else + + pi_ = new sp_counted_base_impl(p, d); + + if(pi_ == 0) + { + d(p); // delete p + boost::throw_exception(std::bad_alloc()); + } + +#endif + } + +#ifndef BOOST_NO_AUTO_PTR + + // auto_ptr is special cased to provide the strong guarantee + + template + explicit shared_count(std::auto_ptr & r): pi_(new sp_counted_base_impl< Y *, checked_deleter >(r.get(), checked_deleter())) +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + , id_(shared_count_id) +#endif + { + r.release(); + } + +#endif + + ~shared_count() // nothrow + { + if(pi_ != 0) pi_->release(); +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + id_ = 0; +#endif + } + + shared_count(shared_count const & r): pi_(r.pi_) // nothrow +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + , id_(shared_count_id) +#endif + { + if(pi_ != 0) pi_->add_ref(); + } + + explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0 + + shared_count & operator= (shared_count const & r) // nothrow + { + sp_counted_base * tmp = r.pi_; + if(tmp != 0) tmp->add_ref(); + if(pi_ != 0) pi_->release(); + pi_ = tmp; + + return *this; + } + + void swap(shared_count & r) // nothrow + { + sp_counted_base * tmp = r.pi_; + r.pi_ = pi_; + pi_ = tmp; + } + + long use_count() const // nothrow + { + return pi_ != 0? pi_->use_count(): 0; + } + + bool unique() const // nothrow + { + return use_count() == 1; + } + + friend inline bool operator==(shared_count const & a, shared_count const & b) + { + return a.pi_ == b.pi_; + } + + friend inline bool operator<(shared_count const & a, shared_count const & b) + { + return std::less()(a.pi_, b.pi_); + } + + void * get_deleter(std::type_info const & ti) const + { + return pi_? pi_->get_deleter(ti): 0; + } +}; + +#ifdef __CODEGUARD__ +# pragma option pop +#endif + + +class weak_count +{ +private: + + sp_counted_base * pi_; + +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + int id_; +#endif + + friend class shared_count; + +public: + + weak_count(): pi_(0) // nothrow +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + , id_(weak_count_id) +#endif + { + } + + weak_count(shared_count const & r): pi_(r.pi_) // nothrow +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + , id_(shared_count_id) +#endif + { + if(pi_ != 0) pi_->weak_add_ref(); + } + + weak_count(weak_count const & r): pi_(r.pi_) // nothrow +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + , id_(shared_count_id) +#endif + { + if(pi_ != 0) pi_->weak_add_ref(); + } + + ~weak_count() // nothrow + { + if(pi_ != 0) pi_->weak_release(); +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + id_ = 0; +#endif + } + + weak_count & operator= (shared_count const & r) // nothrow + { + sp_counted_base * tmp = r.pi_; + if(tmp != 0) tmp->weak_add_ref(); + if(pi_ != 0) pi_->weak_release(); + pi_ = tmp; + + return *this; + } + + weak_count & operator= (weak_count const & r) // nothrow + { + sp_counted_base * tmp = r.pi_; + if(tmp != 0) tmp->weak_add_ref(); + if(pi_ != 0) pi_->weak_release(); + pi_ = tmp; + + return *this; + } + + void swap(weak_count & r) // nothrow + { + sp_counted_base * tmp = r.pi_; + r.pi_ = pi_; + pi_ = tmp; + } + + long use_count() const // nothrow + { + return pi_ != 0? pi_->use_count(): 0; + } + + friend inline bool operator==(weak_count const & a, weak_count const & b) + { + return a.pi_ == b.pi_; + } + + friend inline bool operator<(weak_count const & a, weak_count const & b) + { + return std::less()(a.pi_, b.pi_); + } +}; + +inline shared_count::shared_count(weak_count const & r): pi_(r.pi_) +#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) + , id_(shared_count_id) +#endif +{ + if(pi_ != 0) + { + pi_->add_ref(); + } + else + { + boost::throw_exception(boost::bad_weak_ptr()); + } +} + +} // namespace detail + +} // namespace boost + +#ifdef __BORLANDC__ +# pragma warn .8027 // Functions containing try are not expanded inline +# pragma warn .8026 // Functions with excep. spec. are not expanded inline +#endif + +#endif // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/detail/workaround.hpp b/deal.II/contrib/boost/include/boost/detail/workaround.hpp new file mode 100644 index 0000000000..995c53ca85 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/detail/workaround.hpp @@ -0,0 +1,74 @@ +// Copyright David Abrahams 2002. Permission to copy, use, +// modify, sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +#ifndef WORKAROUND_DWA2002126_HPP +# define WORKAROUND_DWA2002126_HPP + +// Compiler/library version workaround macro +// +// Usage: +// +// #if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) +// ... // workaround code here +// #endif +// +// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the +// first argument must be undefined or expand to a numeric +// value. The above expands to: +// +// (BOOST_MSVC) != 0 && (BOOST_MSVC) <= 1200 +// +// When used for workarounds that apply to the latest known version +// and all earlier versions of a compiler, the following convention +// should be observed: +// +// #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301)) +// +// The version number in this case corresponds to the last version in +// which the workaround was known to have been required. When +// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro +// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates +// the workaround for any version of the compiler. When +// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or +// error will be issued if the compiler version exceeds the argument +// to BOOST_TESTED_AT(). This can be used to locate workarounds which +// may be obsoleted by newer versions. + +# ifndef BOOST_STRICT_CONFIG + +# define BOOST_WORKAROUND(symbol, test) \ + ((symbol != 0) && (1 % (( (symbol test) ) + 1))) +// ^ ^ ^ ^ +// The extra level of parenthesis nesting above, along with the +// BOOST_OPEN_PAREN indirection below, is required to satisfy the +// broken preprocessor in MWCW 8.3 and earlier. +// +// The basic mechanism works as follows: +// (symbol test) + 1 => if (symbol test) then 2 else 1 +// 1 % ((symbol test) + 1) => if (symbol test) then 1 else 0 +// +// The complication with % is for cooperation with BOOST_TESTED_AT(). +// When "test" is BOOST_TESTED_AT(x) and +// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined, +// +// symbol test => if (symbol <= x) then 1 else -1 +// (symbol test) + 1 => if (symbol <= x) then 2 else 0 +// 1 % ((symbol test) + 1) => if (symbol <= x) then 1 else divide-by-zero +// + +# ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS +# define BOOST_OPEN_PAREN ( +# define BOOST_TESTED_AT(value) > value) ?(-1): BOOST_OPEN_PAREN 1 +# else +# define BOOST_TESTED_AT(value) != 0 +# endif + +# else + +# define BOOST_WORKAROUND(symbol, test) 0 + +# endif + +#endif // WORKAROUND_DWA2002126_HPP diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/algorithm_namespace.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/algorithm_namespace.hpp new file mode 100644 index 0000000000..420e1d6462 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/algorithm_namespace.hpp @@ -0,0 +1,34 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/algorithm_namespace.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_ALGORITHM_NAMESPACE_HPP_INCLUDED +#define BOOST_MPL_AUX_ALGORITHM_NAMESPACE_HPP_INCLUDED + +#if defined(__GNUC__) && __GNUC__ >= 3 + +# define BOOST_MPL_AUX_AGLORITHM_NAMESPACE_PREFIX algo_:: +# define BOOST_MPL_AUX_AGLORITHM_NAMESPACE_BEGIN namespace algo_ { +# define BOOST_MPL_AUX_AGLORITHM_NAMESPACE_END } using namespace algo_; + +#else + +# define BOOST_MPL_AUX_AGLORITHM_NAMESPACE_PREFIX /**/ +# define BOOST_MPL_AUX_AGLORITHM_NAMESPACE_BEGIN /**/ +# define BOOST_MPL_AUX_AGLORITHM_NAMESPACE_END /**/ + +#endif + +#endif // BOOST_MPL_AUX_ALGORITHM_NAMESPACE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/arity.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/arity.hpp new file mode 100644 index 0000000000..3a7d281597 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/arity.hpp @@ -0,0 +1,46 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/arity.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2001-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_ARITY_HPP_INCLUDED +#define BOOST_MPL_AUX_ARITY_HPP_INCLUDED + +#include "boost/mpl/aux_/config/dtp.hpp" +#include "boost/mpl/aux_/config/nttp.hpp" + +#if defined(BOOST_BROKEN_DEFAULT_TEMPLATE_PARAMETERS_IN_NESTED_TEMPLATES) + +# include "boost/config.hpp" + +namespace boost { +namespace mpl { +namespace aux { + +// agurt, 15/mar/02: it's possible to implement the template so that it will +// "just work" and do not require any specialization, but not on the compilers +// that require the arity workaround in the first place +template< typename F, BOOST_MPL_AUX_NTTP_DECL(int, N) > +struct arity +{ + BOOST_STATIC_CONSTANT(int, value = N); +}; + +} // namespace aux +} // namespace mpl +} // namespace boost + +#endif // BOOST_BROKEN_DEFAULT_TEMPLATE_PARAMETERS_IN_NESTED_TEMPLATES + +#endif // BOOST_MPL_AUX_ARITY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/dtp.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/dtp.hpp new file mode 100644 index 0000000000..d6bfb3b43a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/dtp.hpp @@ -0,0 +1,41 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/config/dtp.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2001-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED + +#include "boost/config.hpp" + +// MWCW 7.x-8.0 "losts" default template parameters of nested class +// templates when their owner classes are passed as arguments to other +// templates; Borland 5.5.1 "forgets" them from the very beginning (if +// the owner class is a class template), and Borland 5.6 isn't even +// able to compile a definition of nested class template with DTP + +#if defined(__BORLANDC__) && __BORLANDC__ >= 0x560 && \ + (__BORLANDC__ <= 0x561 || !defined(BOOST_STRICT_CONFIG)) \ + && !defined(BOOST_NO_DEFAULT_TEMPLATE_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_NO_DEFAULT_TEMPLATE_PARAMETERS_IN_NESTED_TEMPLATES +#endif + +#if defined(__MWERKS__) && __MWERKS__ <= 0x3001 \ + || defined(__BORLANDC__) && (__BORLANDC__ <= 0x570 || !defined(BOOST_STRICT_CONFIG)) \ + || defined(BOOST_NO_DEFAULT_TEMPLATE_PARAMETERS_IN_NESTED_TEMPLATES) \ + && !defined(BOOST_BROKEN_DEFAULT_TEMPLATE_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_BROKEN_DEFAULT_TEMPLATE_PARAMETERS_IN_NESTED_TEMPLATES +#endif + +#endif // BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/eti.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/eti.hpp new file mode 100644 index 0000000000..70006b5a46 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/eti.hpp @@ -0,0 +1,30 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/config/eti.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2001-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED + +#include "boost/config.hpp" + +// flags for MSVC 6.5's so-called "early template instantiation bug" +#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 +# if BOOST_MSVC < 1300 +# define BOOST_MPL_MSVC_60_ETI_BUG +# endif +# define BOOST_MPL_MSVC_ETI_BUG +#endif + +#endif // BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/lambda.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/lambda.hpp new file mode 100644 index 0000000000..50630b0c55 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/lambda.hpp @@ -0,0 +1,35 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/config/lambda.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED + +#include "boost/mpl/aux_/config/ttp.hpp" +#include "boost/config.hpp" + +// agurt, 15/jan/02: full-fledged implementation requires both +// template template parameters _and_ partial specialization + +#if defined(BOOST_NO_TEMPLATE_TEMPLATE_PARAMETERS) \ + || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ + && !defined(BOOST_MPL_NO_FULL_LAMBDA_SUPPORT) +# define BOOST_MPL_NO_FULL_LAMBDA_SUPPORT +#endif + +//#define BOOST_MPL_NO_UNNAMED_PLACEHOLDER_SUPPORT +//#define BOOST_MPL_NO_LAMBDA_HEURISTIC + +#endif // BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/msvc.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/msvc.hpp new file mode 100644 index 0000000000..aa559ca475 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/msvc.hpp @@ -0,0 +1,23 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/config/msvc.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2000-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED + +// BOOST_MSVC is defined here: +#include "boost/config.hpp" + +#endif // BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/nttp.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/nttp.hpp new file mode 100644 index 0000000000..9f35c2a57f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/nttp.hpp @@ -0,0 +1,56 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/config/nttp.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2001-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED + +#include "boost/mpl/aux_/config/msvc.hpp" + +// MSVC 6.5 ICE-s on the code as simple as this: +// +// namespace std { +// template< typename Char > struct string; +// } +// +// void foo(std::string); +// +// namespace boost { namespace mpl { +// template< int > struct arg; +// }} +// +// fortunately, a workaround is simple as well: +// +// typedef int nttp_int; +// template< nttp_int > struct arg; + +#if defined(BOOST_MSVC) && BOOST_MSVC < 1300 + +#include "boost/preprocessor/cat.hpp" + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +namespace boost { namespace mpl { +typedef int nttp_int; +typedef long nttp_long; +}} +#endif + +# define BOOST_MPL_AUX_NTTP_DECL(T, x) BOOST_PP_CAT(nttp_,T) x /**/ + +#else +# define BOOST_MPL_AUX_NTTP_DECL(T, x) T x /**/ +#endif + +#endif // BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/overload_resolution.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/overload_resolution.hpp new file mode 100644 index 0000000000..009ccc821c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/overload_resolution.hpp @@ -0,0 +1,28 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/config/overload_resolution.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED + +#include "boost/config.hpp" + +#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x561 || !defined(BOOST_STRICT_CONFIG)) \ + || defined(__MWERKS__) && __MWERKS__ < 0x3001 \ + && !defined(BOOST_MPL_BROKEN_OVERLOAD_RESOLUTION) +# define BOOST_MPL_BROKEN_OVERLOAD_RESOLUTION +#endif + +#endif // BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/preprocessor.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/preprocessor.hpp new file mode 100644 index 0000000000..66cef48846 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/preprocessor.hpp @@ -0,0 +1,30 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/config/preprocessor.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2000-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED + +#include "boost/config.hpp" + +#if defined(__MWERKS__) && (__MWERKS__ <= 0x3003 || !defined(BOOST_STRICT_CONFIG)) \ + || defined(__BORLANDC__) && (__BORLANDC__ <= 0x561 || !defined(BOOST_STRICT_CONFIG)) \ + || defined(__IBMCPP__) && (__IBMCPP__ <= 502 || !defined(BOOST_STRICT_CONFIG)) +# define BOOST_MPL_BROKEN_PP_MACRO_EXPANSION +#endif + +//#define BOOST_MPL_NO_OWN_PP_PRIMITIVES + +#endif // BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/static_constant.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/static_constant.hpp new file mode 100644 index 0000000000..ae94fc63e9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/static_constant.hpp @@ -0,0 +1,25 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/config/static_constant.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2000-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED + +#if !defined(BOOST_MPL_PREPROCESSING_MODE) +// BOOST_STATIC_CONSTANT is defined here: +# include "boost/config.hpp" +#endif + +#endif // BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/ttp.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/ttp.hpp new file mode 100644 index 0000000000..29f1fc620a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/ttp.hpp @@ -0,0 +1,34 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/config/ttp.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2000-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED + +#include "boost/config.hpp" + +#if defined(BOOST_NO_TEMPLATE_TEMPLATES) \ + && (!defined(BOOST_MSVC) || BOOST_MSVC < 1300) +# define BOOST_NO_TEMPLATE_TEMPLATE_PARAMETERS +#endif + +#if defined(__GNUC__) && (__GNUC__ < 3 || __GNUC__ == 3 && __GNUC_MINOR__ <= 2 \ + || !defined(BOOST_STRICT_CONFIG)) \ + || defined(__BORLANDC__) && (__BORLANDC__ <= 0x561 || !defined(BOOST_STRICT_CONFIG)) \ + && !defined(BOOST_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) +# define BOOST_EXTENDED_TEMPLATE_PARAMETERS_MATCHING +#endif + +#endif // BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/config/workaround.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/config/workaround.hpp new file mode 100644 index 0000000000..dd3445629b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/config/workaround.hpp @@ -0,0 +1,22 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/config/workaround.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED +#define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED + +#include "boost/detail/workaround.hpp" + +#endif // BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/ice_cast.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/ice_cast.hpp new file mode 100644 index 0000000000..ffa6226fbc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/ice_cast.hpp @@ -0,0 +1,31 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/ice_cast.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2001-03 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_ICE_CAST_HPP_INCLUDED +#define BOOST_MPL_AUX_ICE_CAST_HPP_INCLUDED + +#include "boost/mpl/aux_/config/workaround.hpp" + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \ + || BOOST_WORKAROUND(__GNUC__, < 3) +# define BOOST_MPL_AUX_ICE_CAST(T, expr) T(expr) +#elif BOOST_WORKAROUND(__MWERKS__, <= 0x3001) +# define BOOST_MPL_AUX_ICE_CAST(T, expr) (T)(expr) +#else +# define BOOST_MPL_AUX_ICE_CAST(T, expr) static_cast(expr) +#endif + +#endif // BOOST_MPL_AUX_ICE_CAST_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/integral_wrapper.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/integral_wrapper.hpp new file mode 100644 index 0000000000..216ea3bbb9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/integral_wrapper.hpp @@ -0,0 +1,86 @@ + +// + file: boost/mpl/aux_/intergal_wrapper.hpp +// + last modified: 27/jan/03 + +// Copyright (c) 2000-03 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +// +// See http://www.boost.org/libs/mpl for documentation. + +// no include guards, the header is intended for multiple inclusion! + +#include "boost/mpl/aux_/ice_cast.hpp" +#include "boost/mpl/aux_/config/nttp.hpp" +#include "boost/mpl/aux_/config/static_constant.hpp" +#include "boost/mpl/aux_/config/workaround.hpp" + +#include "boost/preprocessor/cat.hpp" + +#if !defined(AUX_WRAPPER_NAME) +# define AUX_WRAPPER_NAME BOOST_PP_CAT(AUX_WRAPPER_VALUE_TYPE,_) +#endif + +#if !defined(AUX_WRAPPER_PARAMS) +# define AUX_WRAPPER_PARAMS(N) BOOST_MPL_AUX_NTTP_DECL(AUX_WRAPPER_VALUE_TYPE, N) +#endif + +#if !defined(AUX_WRAPPER_INST) +# define AUX_WRAPPER_INST(value) mpl::AUX_WRAPPER_NAME< value > +#endif + +namespace boost { namespace mpl { + +template< AUX_WRAPPER_PARAMS(N) > +struct AUX_WRAPPER_NAME +{ + BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, value = N); +// agurt, 08/mar/03: SGI MIPSpro C++ workaround, have to #ifdef because some +// other compilers (e.g. MSVC) are not particulary happy about it +#if BOOST_WORKAROUND(__EDG_VERSION__, <= 238) + typedef struct AUX_WRAPPER_NAME type; +#else + typedef AUX_WRAPPER_NAME type; +#endif + typedef AUX_WRAPPER_VALUE_TYPE value_type; + +// have to #ifdef here: some compilers don't like the 'N + 1' form (MSVC), +// while some other don't like 'value + 1' (Borland), and some don't like +// either +#if BOOST_WORKAROUND(__EDG_VERSION__, <= 243) + private: + BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, next_value = BOOST_MPL_AUX_ICE_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1))); + BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, prior_value = BOOST_MPL_AUX_ICE_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1))); + public: + typedef AUX_WRAPPER_INST(next_value) next; + typedef AUX_WRAPPER_INST(prior_value) prior; +#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \ + || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(502)) \ + || BOOST_WORKAROUND(__HP_aCC, BOOST_TESTED_AT(53800)) + typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_ICE_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)) ) next; + typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_ICE_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)) ) prior; +#else + typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_ICE_CAST(AUX_WRAPPER_VALUE_TYPE, (value + 1)) ) next; + typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_ICE_CAST(AUX_WRAPPER_VALUE_TYPE, (value - 1)) ) prior; +#endif + + // enables uniform function call syntax for families of overloaded + // functions that return objects of both arithmetic ('int', 'long', + // 'double', etc.) and wrapped integral types (for an example, see + // "mpl/example/power.cpp") + operator AUX_WRAPPER_VALUE_TYPE() const { return this->value; } +}; + +}} // namespace boost::mpl + +#undef AUX_WRAPPER_NAME +#undef AUX_WRAPPER_PARAMS +#undef AUX_WRAPPER_INST +#undef AUX_WRAPPER_VALUE_TYPE diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_arity_param.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_arity_param.hpp new file mode 100644 index 0000000000..926e3a3dc0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_arity_param.hpp @@ -0,0 +1,28 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/lambda_arity_param.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2001-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED +#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED + +#include "boost/mpl/aux_/config/ttp.hpp" + +#if !defined(BOOST_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) +# define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) +#else +# define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) , param +#endif + +#endif // BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_support.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_support.hpp new file mode 100644 index 0000000000..0a174da45f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/lambda_support.hpp @@ -0,0 +1,136 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/lambda_support.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2001-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED +#define BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED + +#include "boost/mpl/aux_/config/lambda.hpp" + +#if !defined(BOOST_MPL_NO_FULL_LAMBDA_SUPPORT) + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) /**/ +# define BOOST_MPL_AUX_LAMBDA_SUPPORT(i,name,params) /**/ + +#else + +# include "boost/mpl/aux_/config/workaround.hpp" +# include "boost/mpl/aux_/preprocessor/params.hpp" +# include "boost/preprocessor/tuple/to_list.hpp" +# include "boost/preprocessor/list/for_each_i.hpp" +# include "boost/preprocessor/inc.hpp" +# include "boost/preprocessor/cat.hpp" + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC(R,typedef_,i,param) \ + typedef_ param BOOST_PP_CAT(arg,BOOST_PP_INC(i)); \ + /**/ + +// agurt, 07/mar/03: restore an old revision for the sake of SGI MIPSpro C++ +#if BOOST_WORKAROUND(__EDG_VERSION__, <= 238) + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ + BOOST_STATIC_CONSTANT(int, arity = i); \ + BOOST_PP_LIST_FOR_EACH_I_R( \ + 1 \ + , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \ + , typedef \ + , BOOST_PP_TUPLE_TO_LIST(i,params) \ + ) \ + struct rebind \ + { \ + template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ + : name< BOOST_MPL_PP_PARAMS(i,U) > \ + { \ + }; \ + }; \ + /**/ + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ + /**/ + +#elif BOOST_WORKAROUND(__EDG_VERSION__, <= 244) && !defined(BOOST_INTEL_CXX_VERSION) +// agurt, 18/jan/03: old EDG-based compilers actually enforce 11.4 para 9 +// (in strict mode), so we have to provide an alternative to the +// MSVC-optimized implementation + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ + BOOST_STATIC_CONSTANT(int, arity = i); \ + BOOST_PP_LIST_FOR_EACH_I_R( \ + 1 \ + , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \ + , typedef \ + , BOOST_PP_TUPLE_TO_LIST(i,params) \ + ) \ + struct rebind; \ +/**/ + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ +}; \ +template< BOOST_MPL_PP_PARAMS(i,typename T) > \ +struct name::rebind \ +{ \ + template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ + : name< BOOST_MPL_PP_PARAMS(i,U) > \ + { \ + }; \ +/**/ + +#else // __EDG_VERSION__ + +# define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ + BOOST_STATIC_CONSTANT(int, arity = i); \ + BOOST_PP_LIST_FOR_EACH_I_R( \ + 1 \ + , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \ + , typedef \ + , BOOST_PP_TUPLE_TO_LIST(i,params) \ + ) \ + friend class BOOST_PP_CAT(name,_rebind); \ + typedef BOOST_PP_CAT(name,_rebind) rebind; \ +/**/ + +# if !defined(__BORLANDC__) +# define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ +}; \ +class BOOST_PP_CAT(name,_rebind) \ +{ \ + public: \ + template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ + : name< BOOST_MPL_PP_PARAMS(i,U) > \ + { \ + }; \ +/**/ +# else +# define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ +}; \ +class BOOST_PP_CAT(name,_rebind) \ +{ \ + public: \ + template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ + { \ + typedef typename name< BOOST_MPL_PP_PARAMS(i,U) >::type type; \ + }; \ +/**/ +# endif // __BORLANDC__ + +#endif // __EDG_VERSION__ + +#endif // BOOST_MPL_NO_FULL_LAMBDA_SUPPORT + +#endif // BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp new file mode 100644 index 0000000000..c8e564cbbc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp @@ -0,0 +1,108 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/preprocessor/def_params_tail.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2000-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED + +#include "boost/mpl/limits/arity.hpp" +#include "boost/mpl/aux_/config/dtp.hpp" +#include "boost/mpl/aux_/config/preprocessor.hpp" + +#include "boost/preprocessor/comma_if.hpp" +#include "boost/preprocessor/logical/and.hpp" +#include "boost/preprocessor/identity.hpp" +#include "boost/preprocessor/empty.hpp" + +// BOOST_MPL_PP_DEF_PARAMS_TAIL(1,T): , T1 = void_, .., Tn = void_ +// BOOST_MPL_PP_DEF_PARAMS_TAIL(2,T): , T2 = void_, .., Tn = void_ +// BOOST_MPL_PP_DEF_PARAMS_TAIL(n,T): + +#if !defined(BOOST_MPL_NO_OWN_PP_PRIMITIVES) + +# include "boost/mpl/aux_/preprocessor/filter_params.hpp" +# include "boost/mpl/aux_/preprocessor/sub.hpp" + +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, value_func) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_1( \ + i \ + , BOOST_MPL_PP_SUB(BOOST_MPL_METAFUNCTION_MAX_ARITY,i) \ + , param \ + , value_func \ + ) \ + /**/ + +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_1(i, n, param, value_func) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_2(i,n,param,value_func) \ + /**/ + +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_2(i, n, param, value_func) \ + BOOST_PP_COMMA_IF(BOOST_PP_AND(i,n)) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_##i(n,param,value_func) \ + /**/ + +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_0(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##1 v(),p##2 v(),p##3 v(),p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v()) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_1(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##2 v(),p##3 v(),p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_2(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##3 v(),p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_3(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2,p3) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_4(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2,p3,p4) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_5(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2,p3,p4,p5) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_6(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##7 v(),p##8 v(),p##9 v(),p1,p2,p3,p4,p5,p6) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_7(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##8 v(),p##9 v(),p1,p2,p3,p4,p5,p6,p7) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_8(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##9 v(),p1,p2,p3,p4,p5,p6,p7,p8) +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_9(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p1,p2,p3,p4,p5,p6,p7,p8,p9) + +#else + +# include "boost/preprocessor/arithmetic/add.hpp" +# include "boost/preprocessor/arithmetic/sub.hpp" +# include "boost/preprocessor/inc.hpp" +# include "boost/preprocessor/tuple/elem.hpp" +# include "boost/preprocessor/repeat.hpp" +# include "boost/preprocessor/cat.hpp" + +# define BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC(unused, i, op) \ + BOOST_PP_COMMA_IF(i) \ + BOOST_PP_CAT( \ + BOOST_PP_TUPLE_ELEM(3, 1, op) \ + , BOOST_PP_ADD_D(1, i, BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3, 0, op))) \ + ) BOOST_PP_TUPLE_ELEM(3, 2, op)() \ + /**/ + +# define BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, value_func) \ + BOOST_PP_REPEAT_1( \ + BOOST_PP_SUB_D(1, BOOST_MPL_METAFUNCTION_MAX_ARITY, i) \ + , BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC \ + , (i, param, value_func) \ + ) \ + /**/ + +#endif // BOOST_MPL_NO_OWN_PP_PRIMITIVES + +#define BOOST_MPL_PP_DEF_PARAMS_TAIL(i, param, value) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value)) \ + /**/ + +#if !defined(BOOST_NO_DEFAULT_TEMPLATE_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, param, value) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value)) \ + /**/ +#else +# define BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, param, value) \ + BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_EMPTY) \ + /**/ +#endif + +#endif // BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/enum.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/enum.hpp new file mode 100644 index 0000000000..829787574a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/enum.hpp @@ -0,0 +1,65 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/preprocessor/enum.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2000-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED + +#include "boost/mpl/aux_/config/preprocessor.hpp" + +// BOOST_MPL_PP_ENUM(0,int): +// BOOST_MPL_PP_ENUM(1,int): int +// BOOST_MPL_PP_ENUM(2,int): int, int +// BOOST_MPL_PP_ENUM(n,int): int, int, .., int + +#if !defined(BOOST_MPL_NO_OWN_PP_PRIMITIVES) + +# include "boost/preprocessor/cat.hpp" + +# define BOOST_MPL_PP_ENUM(n, param) \ + BOOST_PP_CAT(BOOST_MPL_PP_ENUM_,n)(param) \ + /**/ + +# define BOOST_MPL_PP_ENUM_0(p) +# define BOOST_MPL_PP_ENUM_1(p) p +# define BOOST_MPL_PP_ENUM_2(p) p,p +# define BOOST_MPL_PP_ENUM_3(p) p,p,p +# define BOOST_MPL_PP_ENUM_4(p) p,p,p,p +# define BOOST_MPL_PP_ENUM_5(p) p,p,p,p,p +# define BOOST_MPL_PP_ENUM_6(p) p,p,p,p,p,p +# define BOOST_MPL_PP_ENUM_7(p) p,p,p,p,p,p,p +# define BOOST_MPL_PP_ENUM_8(p) p,p,p,p,p,p,p,p +# define BOOST_MPL_PP_ENUM_9(p) p,p,p,p,p,p,p,p,p + +#else + +# include "boost/preprocessor/comma_if.hpp" +# include "boost/preprocessor/repeat.hpp" + +# define BOOST_MPL_PP_AUX_ENUM_FUNC(unused, i, param) \ + BOOST_PP_COMMA_IF(i) param \ + /**/ + +# define BOOST_MPL_PP_ENUM(n, param) \ + BOOST_PP_REPEAT_1( \ + n \ + , BOOST_MPL_PP_AUX_ENUM_FUNC \ + , param \ + ) \ + /**/ + +#endif // BOOST_MPL_NO_OWN_PP_PRIMITIVES + +#endif // BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/filter_params.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/filter_params.hpp new file mode 100644 index 0000000000..b6dc3f9eb9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/filter_params.hpp @@ -0,0 +1,31 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/preprocessor/filter_params.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2000-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_FILTER_PARAMS_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_FILTER_PARAMS_HPP_INCLUDED + +#define BOOST_MPL_PP_FILTER_PARAMS_0(p1,p2,p3,p4,p5,p6,p7,p8,p9) +#define BOOST_MPL_PP_FILTER_PARAMS_1(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1 +#define BOOST_MPL_PP_FILTER_PARAMS_2(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2 +#define BOOST_MPL_PP_FILTER_PARAMS_3(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3 +#define BOOST_MPL_PP_FILTER_PARAMS_4(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4 +#define BOOST_MPL_PP_FILTER_PARAMS_5(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5 +#define BOOST_MPL_PP_FILTER_PARAMS_6(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6 +#define BOOST_MPL_PP_FILTER_PARAMS_7(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6,p7 +#define BOOST_MPL_PP_FILTER_PARAMS_8(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6,p7,p8 +#define BOOST_MPL_PP_FILTER_PARAMS_9(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6,p7,p8,p9 + +#endif // BOOST_MPL_AUX_PREPROCESSOR_FILTER_PARAMS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/params.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/params.hpp new file mode 100644 index 0000000000..baaac7d825 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/params.hpp @@ -0,0 +1,68 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/preprocessor/params.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2000-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED + +#include "boost/mpl/aux_/config/preprocessor.hpp" + +// BOOST_MPL_PP_PARAMS(0,T): +// BOOST_MPL_PP_PARAMS(1,T): T1 +// BOOST_MPL_PP_PARAMS(2,T): T1, T2 +// BOOST_MPL_PP_PARAMS(n,T): T1, T2, .., Tn + +#if !defined(BOOST_MPL_NO_OWN_PP_PRIMITIVES) + +# include "boost/preprocessor/cat.hpp" + +# define BOOST_MPL_PP_PARAMS(n,p) \ + BOOST_PP_CAT(BOOST_MPL_PP_PARAMS_,n)(p) \ + /**/ + +# define BOOST_MPL_PP_PARAMS_0(p) +# define BOOST_MPL_PP_PARAMS_1(p) p##1 +# define BOOST_MPL_PP_PARAMS_2(p) p##1,p##2 +# define BOOST_MPL_PP_PARAMS_3(p) p##1,p##2,p##3 +# define BOOST_MPL_PP_PARAMS_4(p) p##1,p##2,p##3,p##4 +# define BOOST_MPL_PP_PARAMS_5(p) p##1,p##2,p##3,p##4,p##5 +# define BOOST_MPL_PP_PARAMS_6(p) p##1,p##2,p##3,p##4,p##5,p##6 +# define BOOST_MPL_PP_PARAMS_7(p) p##1,p##2,p##3,p##4,p##5,p##6,p##7 +# define BOOST_MPL_PP_PARAMS_8(p) p##1,p##2,p##3,p##4,p##5,p##6,p##7,p##8 +# define BOOST_MPL_PP_PARAMS_9(p) p##1,p##2,p##3,p##4,p##5,p##6,p##7,p##8,p##9 + +#else + +# include "boost/preprocessor/comma_if.hpp" +# include "boost/preprocessor/repeat.hpp" +# include "boost/preprocessor/inc.hpp" +# include "boost/preprocessor/cat.hpp" + +# define BOOST_MPL_PP_AUX_PARAM_FUNC(unused, i, param) \ + BOOST_PP_COMMA_IF(i) \ + BOOST_PP_CAT(param, BOOST_PP_INC(i)) \ + /**/ + +# define BOOST_MPL_PP_PARAMS(n, param) \ + BOOST_PP_REPEAT_1( \ + n \ + , BOOST_MPL_PP_AUX_PARAM_FUNC \ + , param \ + ) \ + /**/ + +#endif // BOOST_MPL_NO_OWN_PP_PRIMITIVES + +#endif // BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/sub.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/sub.hpp new file mode 100644 index 0000000000..e16ffda062 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/sub.hpp @@ -0,0 +1,55 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/preprocessor/sub.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_SUB_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_SUB_HPP_INCLUDED + +#include "boost/mpl/aux_/preprocessor/tuple.hpp" +#include "boost/mpl/aux_/config/preprocessor.hpp" + +#if defined(BOOST_MPL_BROKEN_PP_MACRO_EXPANSION) +# include "boost/preprocessor/cat.hpp" + +# define BOOST_MPL_PP_SUB(i,j) \ + BOOST_MPL_PP_SUB_DELAY(i,j) \ + /**/ + +# define BOOST_MPL_PP_SUB_DELAY(i,j) \ + BOOST_PP_CAT(BOOST_MPL_PP_TUPLE_11_ELEM_##i,BOOST_MPL_PP_SUB_##j) \ + /**/ +#else +# define BOOST_MPL_PP_SUB(i,j) \ + BOOST_MPL_PP_SUB_DELAY(i,j) \ + /**/ + +# define BOOST_MPL_PP_SUB_DELAY(i,j) \ + BOOST_MPL_PP_TUPLE_11_ELEM_##i BOOST_MPL_PP_SUB_##j \ + /**/ +#endif // BOOST_MPL_BROKEN_PP_MACRO_EXPANSION + +#define BOOST_MPL_PP_SUB_0 (0,1,2,3,4,5,6,7,8,9,10) +#define BOOST_MPL_PP_SUB_1 (0,0,1,2,3,4,5,6,7,8,9) +#define BOOST_MPL_PP_SUB_2 (0,0,0,1,2,3,4,5,6,7,8) +#define BOOST_MPL_PP_SUB_3 (0,0,0,0,1,2,3,4,5,6,7) +#define BOOST_MPL_PP_SUB_4 (0,0,0,0,0,1,2,3,4,5,6) +#define BOOST_MPL_PP_SUB_5 (0,0,0,0,0,0,1,2,3,4,5) +#define BOOST_MPL_PP_SUB_6 (0,0,0,0,0,0,0,1,2,3,4) +#define BOOST_MPL_PP_SUB_7 (0,0,0,0,0,0,0,0 1,2,3) +#define BOOST_MPL_PP_SUB_8 (0,0,0,0,0,0,0,0,0,1,2) +#define BOOST_MPL_PP_SUB_9 (0,0,0,0,0,0,0,0,0,0,1) +#define BOOST_MPL_PP_SUB_10 (0,0,0,0,0,0,0,0,0,0,0) + +#endif // BOOST_MPL_AUX_PREPROCESSOR_SUB_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/tuple.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/tuple.hpp new file mode 100644 index 0000000000..a7198430fa --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/preprocessor/tuple.hpp @@ -0,0 +1,32 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/preprocessor/tuple.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED +#define BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED + +#define BOOST_MPL_PP_TUPLE_11_ELEM_0(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e0 +#define BOOST_MPL_PP_TUPLE_11_ELEM_1(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e1 +#define BOOST_MPL_PP_TUPLE_11_ELEM_2(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e2 +#define BOOST_MPL_PP_TUPLE_11_ELEM_3(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e3 +#define BOOST_MPL_PP_TUPLE_11_ELEM_4(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e4 +#define BOOST_MPL_PP_TUPLE_11_ELEM_5(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e5 +#define BOOST_MPL_PP_TUPLE_11_ELEM_6(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e6 +#define BOOST_MPL_PP_TUPLE_11_ELEM_7(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e7 +#define BOOST_MPL_PP_TUPLE_11_ELEM_8(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e8 +#define BOOST_MPL_PP_TUPLE_11_ELEM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e9 +#define BOOST_MPL_PP_TUPLE_11_ELEM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e10 + +#endif // BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/template_arity_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/template_arity_fwd.hpp new file mode 100644 index 0000000000..6cb409ec4a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/template_arity_fwd.hpp @@ -0,0 +1,30 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/template_arity_fwd.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2001-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED +#define BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED + +namespace boost { +namespace mpl { +namespace aux { + +template< typename F > struct template_arity; + +} // namespace aux +} // namespace mpl +} // namespace boost + +#endif // BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/value_wknd.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/value_wknd.hpp new file mode 100644 index 0000000000..f0676d97f8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/value_wknd.hpp @@ -0,0 +1,60 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/value_wknd.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2000-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED +#define BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED + +#include "boost/mpl/aux_/config/eti.hpp" + +#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x561 || !defined(BOOST_STRICT_CONFIG)) \ + || defined(BOOST_MPL_MSVC_60_ETI_BUG) + +# include "boost/mpl/int.hpp" + +namespace boost { namespace mpl { namespace aux { + +template< typename C_ > +struct value_wknd + : C_ +{ +}; + +#if defined(BOOST_MPL_MSVC_60_ETI_BUG) +template<> +struct value_wknd + : int_<0> +{ +}; +#endif + +}}} // namespace boost::mpl::aux + +# if !defined(BOOST_MPL_MSVC_60_ETI_BUG) +# define BOOST_MPL_AUX_VALUE_WKND(C) ::boost::mpl::aux::value_wknd< C > +# define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) BOOST_MPL_AUX_VALUE_WKND(C) +# else +# define BOOST_MPL_AUX_VALUE_WKND(C) C +# define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) ::boost::mpl::aux::value_wknd< C > +# endif + +#else + +# define BOOST_MPL_AUX_VALUE_WKND(C) C +# define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) C + +#endif // __BORLANDC__ || BOOST_MPL_MSVC_60_ETI_BUG + +#endif // BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/aux_/void_spec.hpp b/deal.II/contrib/boost/include/boost/mpl/aux_/void_spec.hpp new file mode 100644 index 0000000000..7363aa044e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/aux_/void_spec.hpp @@ -0,0 +1,152 @@ +//----------------------------------------------------------------------------- +// boost mpl/aux_/void_spec.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2001-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_AUX_VOID_SPEC_HPP_INCLUDED +#define BOOST_MPL_AUX_VOID_SPEC_HPP_INCLUDED + +#include "boost/mpl/lambda_fwd.hpp" +#include "boost/mpl/void.hpp" +#include "boost/mpl/int_fwd.hpp" +#include "boost/mpl/aux_/preprocessor/params.hpp" +#include "boost/mpl/aux_/preprocessor/enum.hpp" +#include "boost/mpl/aux_/preprocessor/def_params_tail.hpp" +#include "boost/mpl/aux_/arity.hpp" +#include "boost/mpl/aux_/template_arity_fwd.hpp" +#include "boost/mpl/aux_/lambda_arity_param.hpp" +#include "boost/mpl/aux_/algorithm_namespace.hpp" +#include "boost/mpl/aux_/config/dtp.hpp" +#include "boost/mpl/aux_/config/nttp.hpp" +#include "boost/mpl/aux_/config/ttp.hpp" +#include "boost/mpl/aux_/config/lambda.hpp" +#include "boost/mpl/aux_/config/overload_resolution.hpp" + +#include "boost/config.hpp" + +#define BOOST_MPL_AUX_VOID_SPEC_PARAMS(i) \ + BOOST_MPL_PP_ENUM(i, void_) \ +/**/ + +#if defined(BOOST_BROKEN_DEFAULT_TEMPLATE_PARAMETERS_IN_NESTED_TEMPLATES) +# define BOOST_MPL_AUX_VOID_SPEC_ARITY(i, name) \ +namespace aux { \ +template< BOOST_MPL_AUX_NTTP_DECL(int, N) > \ +struct arity< \ + name< BOOST_MPL_AUX_VOID_SPEC_PARAMS(i) > \ + , N \ + > \ +{ \ + BOOST_STATIC_CONSTANT(int \ + , value = BOOST_MPL_METAFUNCTION_MAX_ARITY \ + ); \ +}; \ +} \ +/**/ +#else +# define BOOST_MPL_AUX_VOID_SPEC_ARITY(i, name) /**/ +#endif + +#define BOOST_MPL_AUX_VOID_SPEC_MAIN(i, name) \ +template<> \ +struct name< BOOST_MPL_AUX_VOID_SPEC_PARAMS(i) > \ +{ \ + template< \ + BOOST_MPL_PP_PARAMS(i, typename T) \ + BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, typename T, void_) \ + > \ + struct apply \ + : name< BOOST_MPL_PP_PARAMS(i, T) > \ + { \ + }; \ +}; \ +/**/ + +#if defined(BOOST_MPL_NO_FULL_LAMBDA_SUPPORT) +# define BOOST_MPL_AUX_VOID_SPEC_LAMBDA(i, name) \ +template<> \ +struct lambda< \ + name< BOOST_MPL_AUX_VOID_SPEC_PARAMS(i) > \ + , true \ + > \ +{ \ + typedef name< BOOST_MPL_AUX_VOID_SPEC_PARAMS(i) > type; \ +}; \ +/**/ +#else +# define BOOST_MPL_AUX_VOID_SPEC_LAMBDA(i, name) \ +template<> \ +struct lambda< \ + name< BOOST_MPL_AUX_VOID_SPEC_PARAMS(i) > \ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<-1>) \ + > \ +{ \ + typedef name< BOOST_MPL_AUX_VOID_SPEC_PARAMS(i) > type; \ +}; \ +/**/ +#endif + +#if defined(BOOST_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) || \ + defined(BOOST_MPL_NO_FULL_LAMBDA_SUPPORT) && \ + defined(BOOST_MPL_BROKEN_OVERLOAD_RESOLUTION) +# define BOOST_MPL_AUX_VOID_SPEC_TEMPLATE_ARITY(i, j, name) \ +namespace aux { \ +template< BOOST_MPL_PP_PARAMS(j, typename T) > \ +struct template_arity< \ + name< BOOST_MPL_PP_PARAMS(j, T) > \ + > \ +{ \ + BOOST_STATIC_CONSTANT(int, value = j); \ +}; \ +\ +template<> \ +struct template_arity< \ + name< BOOST_MPL_PP_ENUM(i, void_) > \ + > \ +{ \ + BOOST_STATIC_CONSTANT(int, value = -1); \ +}; \ +} \ +/**/ +#else +# define BOOST_MPL_AUX_VOID_SPEC_TEMPLATE_ARITY(i, j, name) /**/ +#endif + + +#define BOOST_MPL_AUX_VOID_SPEC_PARAM(param) param = void_ + +#define BOOST_MPL_AUX_VOID_SPEC(i, name) \ +BOOST_MPL_AUX_VOID_SPEC_MAIN(i, name) \ +BOOST_MPL_AUX_VOID_SPEC_LAMBDA(i, name) \ +BOOST_MPL_AUX_VOID_SPEC_ARITY(i, name) \ +BOOST_MPL_AUX_VOID_SPEC_TEMPLATE_ARITY(i, i, name) \ +/**/ + +#define BOOST_MPL_AUX_VOID_SPEC_EXT(i, j, name) \ +BOOST_MPL_AUX_VOID_SPEC_MAIN(i, name) \ +BOOST_MPL_AUX_VOID_SPEC_LAMBDA(i, name) \ +BOOST_MPL_AUX_VOID_SPEC_ARITY(i, name) \ +BOOST_MPL_AUX_VOID_SPEC_TEMPLATE_ARITY(i, j, name) \ +/**/ + +#define BOOST_MPL_AUX_ALGORITHM_VOID_SPEC(i, name) \ +BOOST_MPL_AUX_AGLORITHM_NAMESPACE_BEGIN \ +BOOST_MPL_AUX_VOID_SPEC_MAIN(i, name) \ +BOOST_MPL_AUX_AGLORITHM_NAMESPACE_END \ +BOOST_MPL_AUX_VOID_SPEC_LAMBDA(i, BOOST_MPL_AUX_AGLORITHM_NAMESPACE_PREFIX name) \ +BOOST_MPL_AUX_VOID_SPEC_ARITY(i, BOOST_MPL_AUX_AGLORITHM_NAMESPACE_PREFIX name) \ +BOOST_MPL_AUX_VOID_SPEC_TEMPLATE_ARITY(i, i, BOOST_MPL_AUX_AGLORITHM_NAMESPACE_PREFIX name) \ +/**/ + +#endif // BOOST_MPL_AUX_VOID_SPEC_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/bool.hpp b/deal.II/contrib/boost/include/boost/mpl/bool.hpp new file mode 100644 index 0000000000..38e8596644 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/bool.hpp @@ -0,0 +1,36 @@ + +#ifndef BOOST_MPL_BOOL_HPP_INCLUDED +#define BOOST_MPL_BOOL_HPP_INCLUDED + +// + file: boost/mpl/bool.hpp +// + last modified: 08/mar/03 + +// Copyright (c) 2000-03 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +// +// See http://www.boost.org/libs/mpl for documentation. + +#include "boost/mpl/bool_fwd.hpp" +#include "boost/mpl/aux_/config/static_constant.hpp" + +namespace boost { namespace mpl { + +template< bool C_ > struct bool_ +{ + BOOST_STATIC_CONSTANT(bool, value = C_); + typedef bool_ type; + typedef bool value_type; + operator bool() const { return this->value; } +}; + +}} // namespace boost::mpl + +#endif // BOOST_MPL_BOOL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/bool_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/bool_fwd.hpp new file mode 100644 index 0000000000..851293715c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/bool_fwd.hpp @@ -0,0 +1,31 @@ + +#ifndef BOOST_MPL_BOOL_FWD_HPP_INCLUDED +#define BOOST_MPL_BOOL_FWD_HPP_INCLUDED + +// + file: boost/mpl/bool_fwd.hpp +// + last modified: 08/mar/03 + +// Copyright (c) 2000-03 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +// +// See http://www.boost.org/libs/mpl for documentation. + +namespace boost { namespace mpl { + +template< bool C_ > struct bool_; + +// shorcuts +typedef bool_ true_; +typedef bool_ false_; + +}} + +#endif // BOOST_MPL_BOOL_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/if.hpp b/deal.II/contrib/boost/include/boost/mpl/if.hpp new file mode 100644 index 0000000000..0ef343e196 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/if.hpp @@ -0,0 +1,177 @@ + +#ifndef BOOST_MPL_IF_HPP_INCLUDED +#define BOOST_MPL_IF_HPP_INCLUDED + +// + file: boost/mpl/if.hpp +// + last modified: 10/mar/03 + +// Copyright (c) 2000-03 Boost.org +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +// +// See http://www.boost.org/libs/mpl for documentation. + +#include "boost/mpl/aux_/value_wknd.hpp" +#include "boost/mpl/aux_/ice_cast.hpp" +#include "boost/mpl/aux_/void_spec.hpp" +#include "boost/mpl/aux_/lambda_support.hpp" +#include "boost/mpl/aux_/config/workaround.hpp" +#include "boost/config.hpp" + +namespace boost { +namespace mpl { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +template< + bool C + , typename T1 + , typename T2 + > +struct if_c +{ + typedef T1 type; +}; + +template< + typename T1 + , typename T2 + > +struct if_c +{ + typedef T2 type; +}; + +template< + typename BOOST_MPL_AUX_VOID_SPEC_PARAM(C) + , typename BOOST_MPL_AUX_VOID_SPEC_PARAM(T1) + , typename BOOST_MPL_AUX_VOID_SPEC_PARAM(T2) + > +struct if_ +{ + private: + // agurt, 02/jan/03: two-step 'type' definition for the sake of aCC + typedef if_c< +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) + BOOST_MPL_AUX_VALUE_WKND(C)::value +#else + BOOST_MPL_AUX_ICE_CAST(bool, BOOST_MPL_AUX_VALUE_WKND(C)::value) +#endif + , T1 + , T2 + > almost_type_; + + public: + typedef typename almost_type_::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,if_,(C,T1,T2)) +}; + +#elif defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) + +// MSVC6.5-specific version + +template< + bool C_ + , typename T1 + , typename T2 + > +struct if_c +{ + private: + template struct answer { typedef T1 type; }; + template<> struct answer { typedef T2 type; }; + + public: + typedef typename answer< C_ >::type type; +}; + +// (almost) copy & paste in order to save one more +// recursively nested template instantiation to user +template< + typename C_ + , typename T1 + , typename T2 + > +struct if_ +{ + private: + template struct answer { typedef T1 type; }; + template<> struct answer { typedef T2 type; }; + + // agurt, 17/sep/02: in some situations MSVC 7.0 doesn't + // handle 'answer' expression very well + enum { c_ = C_::value }; + + public: + typedef typename answer< BOOST_MPL_AUX_ICE_CAST(bool, c_) >::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,if_,(C_,T1,T2)) +}; + +#else + +// no partial class template specialization + +namespace aux { + +template< bool C > +struct if_impl +{ + template< typename T1, typename T2 > struct result_ + { + typedef T1 type; + }; +}; + +template<> +struct if_impl +{ + template< typename T1, typename T2 > struct result_ + { + typedef T2 type; + }; +}; + +} // namespace aux + +template< + bool C + , typename T1 + , typename T2 + > +struct if_c +{ + typedef typename aux::if_impl< C > + ::template result_::type type; +}; + +// (almost) copy & paste in order to save one more +// recursively nested template instantiation to user +template< + typename BOOST_MPL_AUX_VOID_SPEC_PARAM(C) + , typename BOOST_MPL_AUX_VOID_SPEC_PARAM(T1) + , typename BOOST_MPL_AUX_VOID_SPEC_PARAM(T2) + > +struct if_ +{ + typedef typename aux::if_impl< BOOST_MPL_AUX_ICE_CAST(bool, C::value) > + ::template result_::type type; + + BOOST_MPL_AUX_LAMBDA_SUPPORT(3,if_,(C,T1,T2)) +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +BOOST_MPL_AUX_VOID_SPEC(3, if_) + +} // namespace mpl +} // namespace boost + +#endif // BOOST_MPL_IF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/int_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/int_fwd.hpp new file mode 100644 index 0000000000..7165c24108 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/int_fwd.hpp @@ -0,0 +1,25 @@ + +#ifndef BOOST_MPL_INT_FWD_HPP_INCLUDED +#define BOOST_MPL_INT_FWD_HPP_INCLUDED + +// + file: boost/mpl/int_fwd.hpp +// + last modified: 08/mar/03 + +// Copyright (c) 2000-03 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +// +// See http://www.boost.org/libs/mpl for documentation. + +namespace boost { namespace mpl { +template< int N > struct int_; +}} + +#endif // BOOST_MPL_INT_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/lambda_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/lambda_fwd.hpp new file mode 100644 index 0000000000..a4680b552e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/lambda_fwd.hpp @@ -0,0 +1,36 @@ +//----------------------------------------------------------------------------- +// boost mpl/labmda_fwd.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2001-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED +#define BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED + +#include "boost/mpl/aux_/lambda_arity_param.hpp" +#include "boost/mpl/aux_/config/lambda.hpp" + +namespace boost { +namespace mpl { + +#if !defined(BOOST_MPL_NO_FULL_LAMBDA_SUPPORT) +template< typename T BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity) > +struct lambda; +#else +template< typename T, bool Protect > struct lambda; +#endif + +} // namespace mpl +} // namespace boost + +#endif // BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/limits/arity.hpp b/deal.II/contrib/boost/include/boost/mpl/limits/arity.hpp new file mode 100644 index 0000000000..a045c3c1b8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/limits/arity.hpp @@ -0,0 +1,24 @@ +//----------------------------------------------------------------------------- +// boost mpl/limits/arity.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2000-02 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED +#define BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED + +#if !defined(BOOST_MPL_METAFUNCTION_MAX_ARITY) +# define BOOST_MPL_METAFUNCTION_MAX_ARITY 5 +#endif + +#endif // BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/size_t.hpp b/deal.II/contrib/boost/include/boost/mpl/size_t.hpp new file mode 100644 index 0000000000..086d1dcb8b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/size_t.hpp @@ -0,0 +1,29 @@ + +#ifndef BOOST_MPL_SIZE_T_HPP_INCLUDED +#define BOOST_MPL_SIZE_T_HPP_INCLUDED + +// + file: boost/mpl/size_t.hpp +// + last modified: 08/mar/03 + +// Copyright (c) 2000-03 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +// +// See http://www.boost.org/libs/mpl for documentation. + +#include "boost/mpl/size_t_fwd.hpp" + +#define AUX_WRAPPER_VALUE_TYPE std::size_t +#define AUX_WRAPPER_NAME size_t +#define AUX_WRAPPER_PARAMS(N) std::size_t N + +#include "boost/mpl/aux_/integral_wrapper.hpp" + +#endif // BOOST_MPL_SIZE_T_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/size_t_fwd.hpp b/deal.II/contrib/boost/include/boost/mpl/size_t_fwd.hpp new file mode 100644 index 0000000000..3cd63c4046 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/size_t_fwd.hpp @@ -0,0 +1,28 @@ + +#ifndef BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED +#define BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED + +// + file: boost/mpl/size_t_fwd.hpp +// + last modified: 08/mar/03 + +// Copyright (c) 2000-03 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. +// +// See http://www.boost.org/libs/mpl for documentation. + +#include "boost/config.hpp" // make sure 'size_t' is placed into 'std' +#include + +namespace boost { namespace mpl { +template< std::size_t N > struct size_t; +}} + +#endif // BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/mpl/void.hpp b/deal.II/contrib/boost/include/boost/mpl/void.hpp new file mode 100644 index 0000000000..e6c79d18a1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/mpl/void.hpp @@ -0,0 +1,53 @@ +//----------------------------------------------------------------------------- +// boost mpl/void.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2001-02 +// Peter Dimov, Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +#ifndef BOOST_MPL_VOID_HPP_INCLUDED +#define BOOST_MPL_VOID_HPP_INCLUDED + +#include "boost/mpl/bool.hpp" +#include "boost/config.hpp" + +namespace boost { +namespace mpl { + +// [JDG Feb-4-2003] made void_ a complete type to allow it to be +// instantiated so that it can be passed in as an object that can be +// used to select an overloaded function. Possible use includes signaling +// a zero arity functor evaluation call. +struct void_ {}; + +template< typename T > +struct is_void_ + : false_ +{ +#if defined(BOOST_MSVC) && BOOST_MSVC < 1300 + using false_::value; +#endif +}; + +template<> +struct is_void_ + : true_ +{ +#if defined(BOOST_MSVC) && BOOST_MSVC < 1300 + using true_::value; +#endif +}; + +} // namespace mpl +} // namespace boost + +#endif // BOOST_MPL_VOID_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/preprocessor/arithmetic/inc.hpp b/deal.II/contrib/boost/include/boost/preprocessor/arithmetic/inc.hpp new file mode 100644 index 0000000000..817e8a61a2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/arithmetic/inc.hpp @@ -0,0 +1,289 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_ARITHMETIC_INC_HPP +# define BOOST_PREPROCESSOR_ARITHMETIC_INC_HPP +# +# include +# +# /* BOOST_PP_INC */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_INC(x) BOOST_PP_INC_I(x) +# else +# define BOOST_PP_INC(x) BOOST_PP_INC_OO((x)) +# define BOOST_PP_INC_OO(par) BOOST_PP_INC_I ## par +# endif +# +# define BOOST_PP_INC_I(x) BOOST_PP_INC_ ## x +# +# define BOOST_PP_INC_0 1 +# define BOOST_PP_INC_1 2 +# define BOOST_PP_INC_2 3 +# define BOOST_PP_INC_3 4 +# define BOOST_PP_INC_4 5 +# define BOOST_PP_INC_5 6 +# define BOOST_PP_INC_6 7 +# define BOOST_PP_INC_7 8 +# define BOOST_PP_INC_8 9 +# define BOOST_PP_INC_9 10 +# define BOOST_PP_INC_10 11 +# define BOOST_PP_INC_11 12 +# define BOOST_PP_INC_12 13 +# define BOOST_PP_INC_13 14 +# define BOOST_PP_INC_14 15 +# define BOOST_PP_INC_15 16 +# define BOOST_PP_INC_16 17 +# define BOOST_PP_INC_17 18 +# define BOOST_PP_INC_18 19 +# define BOOST_PP_INC_19 20 +# define BOOST_PP_INC_20 21 +# define BOOST_PP_INC_21 22 +# define BOOST_PP_INC_22 23 +# define BOOST_PP_INC_23 24 +# define BOOST_PP_INC_24 25 +# define BOOST_PP_INC_25 26 +# define BOOST_PP_INC_26 27 +# define BOOST_PP_INC_27 28 +# define BOOST_PP_INC_28 29 +# define BOOST_PP_INC_29 30 +# define BOOST_PP_INC_30 31 +# define BOOST_PP_INC_31 32 +# define BOOST_PP_INC_32 33 +# define BOOST_PP_INC_33 34 +# define BOOST_PP_INC_34 35 +# define BOOST_PP_INC_35 36 +# define BOOST_PP_INC_36 37 +# define BOOST_PP_INC_37 38 +# define BOOST_PP_INC_38 39 +# define BOOST_PP_INC_39 40 +# define BOOST_PP_INC_40 41 +# define BOOST_PP_INC_41 42 +# define BOOST_PP_INC_42 43 +# define BOOST_PP_INC_43 44 +# define BOOST_PP_INC_44 45 +# define BOOST_PP_INC_45 46 +# define BOOST_PP_INC_46 47 +# define BOOST_PP_INC_47 48 +# define BOOST_PP_INC_48 49 +# define BOOST_PP_INC_49 50 +# define BOOST_PP_INC_50 51 +# define BOOST_PP_INC_51 52 +# define BOOST_PP_INC_52 53 +# define BOOST_PP_INC_53 54 +# define BOOST_PP_INC_54 55 +# define BOOST_PP_INC_55 56 +# define BOOST_PP_INC_56 57 +# define BOOST_PP_INC_57 58 +# define BOOST_PP_INC_58 59 +# define BOOST_PP_INC_59 60 +# define BOOST_PP_INC_60 61 +# define BOOST_PP_INC_61 62 +# define BOOST_PP_INC_62 63 +# define BOOST_PP_INC_63 64 +# define BOOST_PP_INC_64 65 +# define BOOST_PP_INC_65 66 +# define BOOST_PP_INC_66 67 +# define BOOST_PP_INC_67 68 +# define BOOST_PP_INC_68 69 +# define BOOST_PP_INC_69 70 +# define BOOST_PP_INC_70 71 +# define BOOST_PP_INC_71 72 +# define BOOST_PP_INC_72 73 +# define BOOST_PP_INC_73 74 +# define BOOST_PP_INC_74 75 +# define BOOST_PP_INC_75 76 +# define BOOST_PP_INC_76 77 +# define BOOST_PP_INC_77 78 +# define BOOST_PP_INC_78 79 +# define BOOST_PP_INC_79 80 +# define BOOST_PP_INC_80 81 +# define BOOST_PP_INC_81 82 +# define BOOST_PP_INC_82 83 +# define BOOST_PP_INC_83 84 +# define BOOST_PP_INC_84 85 +# define BOOST_PP_INC_85 86 +# define BOOST_PP_INC_86 87 +# define BOOST_PP_INC_87 88 +# define BOOST_PP_INC_88 89 +# define BOOST_PP_INC_89 90 +# define BOOST_PP_INC_90 91 +# define BOOST_PP_INC_91 92 +# define BOOST_PP_INC_92 93 +# define BOOST_PP_INC_93 94 +# define BOOST_PP_INC_94 95 +# define BOOST_PP_INC_95 96 +# define BOOST_PP_INC_96 97 +# define BOOST_PP_INC_97 98 +# define BOOST_PP_INC_98 99 +# define BOOST_PP_INC_99 100 +# define BOOST_PP_INC_100 101 +# define BOOST_PP_INC_101 102 +# define BOOST_PP_INC_102 103 +# define BOOST_PP_INC_103 104 +# define BOOST_PP_INC_104 105 +# define BOOST_PP_INC_105 106 +# define BOOST_PP_INC_106 107 +# define BOOST_PP_INC_107 108 +# define BOOST_PP_INC_108 109 +# define BOOST_PP_INC_109 110 +# define BOOST_PP_INC_110 111 +# define BOOST_PP_INC_111 112 +# define BOOST_PP_INC_112 113 +# define BOOST_PP_INC_113 114 +# define BOOST_PP_INC_114 115 +# define BOOST_PP_INC_115 116 +# define BOOST_PP_INC_116 117 +# define BOOST_PP_INC_117 118 +# define BOOST_PP_INC_118 119 +# define BOOST_PP_INC_119 120 +# define BOOST_PP_INC_120 121 +# define BOOST_PP_INC_121 122 +# define BOOST_PP_INC_122 123 +# define BOOST_PP_INC_123 124 +# define BOOST_PP_INC_124 125 +# define BOOST_PP_INC_125 126 +# define BOOST_PP_INC_126 127 +# define BOOST_PP_INC_127 128 +# define BOOST_PP_INC_128 129 +# define BOOST_PP_INC_129 130 +# define BOOST_PP_INC_130 131 +# define BOOST_PP_INC_131 132 +# define BOOST_PP_INC_132 133 +# define BOOST_PP_INC_133 134 +# define BOOST_PP_INC_134 135 +# define BOOST_PP_INC_135 136 +# define BOOST_PP_INC_136 137 +# define BOOST_PP_INC_137 138 +# define BOOST_PP_INC_138 139 +# define BOOST_PP_INC_139 140 +# define BOOST_PP_INC_140 141 +# define BOOST_PP_INC_141 142 +# define BOOST_PP_INC_142 143 +# define BOOST_PP_INC_143 144 +# define BOOST_PP_INC_144 145 +# define BOOST_PP_INC_145 146 +# define BOOST_PP_INC_146 147 +# define BOOST_PP_INC_147 148 +# define BOOST_PP_INC_148 149 +# define BOOST_PP_INC_149 150 +# define BOOST_PP_INC_150 151 +# define BOOST_PP_INC_151 152 +# define BOOST_PP_INC_152 153 +# define BOOST_PP_INC_153 154 +# define BOOST_PP_INC_154 155 +# define BOOST_PP_INC_155 156 +# define BOOST_PP_INC_156 157 +# define BOOST_PP_INC_157 158 +# define BOOST_PP_INC_158 159 +# define BOOST_PP_INC_159 160 +# define BOOST_PP_INC_160 161 +# define BOOST_PP_INC_161 162 +# define BOOST_PP_INC_162 163 +# define BOOST_PP_INC_163 164 +# define BOOST_PP_INC_164 165 +# define BOOST_PP_INC_165 166 +# define BOOST_PP_INC_166 167 +# define BOOST_PP_INC_167 168 +# define BOOST_PP_INC_168 169 +# define BOOST_PP_INC_169 170 +# define BOOST_PP_INC_170 171 +# define BOOST_PP_INC_171 172 +# define BOOST_PP_INC_172 173 +# define BOOST_PP_INC_173 174 +# define BOOST_PP_INC_174 175 +# define BOOST_PP_INC_175 176 +# define BOOST_PP_INC_176 177 +# define BOOST_PP_INC_177 178 +# define BOOST_PP_INC_178 179 +# define BOOST_PP_INC_179 180 +# define BOOST_PP_INC_180 181 +# define BOOST_PP_INC_181 182 +# define BOOST_PP_INC_182 183 +# define BOOST_PP_INC_183 184 +# define BOOST_PP_INC_184 185 +# define BOOST_PP_INC_185 186 +# define BOOST_PP_INC_186 187 +# define BOOST_PP_INC_187 188 +# define BOOST_PP_INC_188 189 +# define BOOST_PP_INC_189 190 +# define BOOST_PP_INC_190 191 +# define BOOST_PP_INC_191 192 +# define BOOST_PP_INC_192 193 +# define BOOST_PP_INC_193 194 +# define BOOST_PP_INC_194 195 +# define BOOST_PP_INC_195 196 +# define BOOST_PP_INC_196 197 +# define BOOST_PP_INC_197 198 +# define BOOST_PP_INC_198 199 +# define BOOST_PP_INC_199 200 +# define BOOST_PP_INC_200 201 +# define BOOST_PP_INC_201 202 +# define BOOST_PP_INC_202 203 +# define BOOST_PP_INC_203 204 +# define BOOST_PP_INC_204 205 +# define BOOST_PP_INC_205 206 +# define BOOST_PP_INC_206 207 +# define BOOST_PP_INC_207 208 +# define BOOST_PP_INC_208 209 +# define BOOST_PP_INC_209 210 +# define BOOST_PP_INC_210 211 +# define BOOST_PP_INC_211 212 +# define BOOST_PP_INC_212 213 +# define BOOST_PP_INC_213 214 +# define BOOST_PP_INC_214 215 +# define BOOST_PP_INC_215 216 +# define BOOST_PP_INC_216 217 +# define BOOST_PP_INC_217 218 +# define BOOST_PP_INC_218 219 +# define BOOST_PP_INC_219 220 +# define BOOST_PP_INC_220 221 +# define BOOST_PP_INC_221 222 +# define BOOST_PP_INC_222 223 +# define BOOST_PP_INC_223 224 +# define BOOST_PP_INC_224 225 +# define BOOST_PP_INC_225 226 +# define BOOST_PP_INC_226 227 +# define BOOST_PP_INC_227 228 +# define BOOST_PP_INC_228 229 +# define BOOST_PP_INC_229 230 +# define BOOST_PP_INC_230 231 +# define BOOST_PP_INC_231 232 +# define BOOST_PP_INC_232 233 +# define BOOST_PP_INC_233 234 +# define BOOST_PP_INC_234 235 +# define BOOST_PP_INC_235 236 +# define BOOST_PP_INC_236 237 +# define BOOST_PP_INC_237 238 +# define BOOST_PP_INC_238 239 +# define BOOST_PP_INC_239 240 +# define BOOST_PP_INC_240 241 +# define BOOST_PP_INC_241 242 +# define BOOST_PP_INC_242 243 +# define BOOST_PP_INC_243 244 +# define BOOST_PP_INC_244 245 +# define BOOST_PP_INC_245 246 +# define BOOST_PP_INC_246 247 +# define BOOST_PP_INC_247 248 +# define BOOST_PP_INC_248 249 +# define BOOST_PP_INC_249 250 +# define BOOST_PP_INC_250 251 +# define BOOST_PP_INC_251 252 +# define BOOST_PP_INC_252 253 +# define BOOST_PP_INC_253 254 +# define BOOST_PP_INC_254 255 +# define BOOST_PP_INC_255 256 +# define BOOST_PP_INC_256 256 +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/cat.hpp b/deal.II/contrib/boost/include/boost/preprocessor/cat.hpp new file mode 100644 index 0000000000..946bdcd106 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/cat.hpp @@ -0,0 +1,36 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CAT_HPP +# define BOOST_PREPROCESSOR_CAT_HPP +# +# include +# +# /* BOOST_PP_CAT */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_CAT(a, b) BOOST_PP_CAT_I(a, b) +# else +# define BOOST_PP_CAT(a, b) BOOST_PP_CAT_OO((a, b)) +# define BOOST_PP_CAT_OO(par) BOOST_PP_CAT_I ## par +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_CAT_I(a, b) a ## b +# else +# define BOOST_PP_CAT_I(a, b) BOOST_PP_CAT_II(a ## b) +# define BOOST_PP_CAT_II(res) res +# endif +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/comma_if.hpp b/deal.II/contrib/boost/include/boost/preprocessor/comma_if.hpp new file mode 100644 index 0000000000..e74a52ebba --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/comma_if.hpp @@ -0,0 +1,18 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_COMMA_IF_HPP +# define BOOST_PREPROCESSOR_COMMA_IF_HPP +# +# include +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/config/config.hpp b/deal.II/contrib/boost/include/boost/preprocessor/config/config.hpp new file mode 100644 index 0000000000..2f1d224f76 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/config/config.hpp @@ -0,0 +1,58 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CONFIG_CONFIG_HPP +# define BOOST_PREPROCESSOR_CONFIG_CONFIG_HPP +# +# /* BOOST_PP_CONFIG_FLAGS */ +# +# define BOOST_PP_CONFIG_STRICT() 0x0001 +# define BOOST_PP_CONFIG_IDEAL() 0x0002 +# +# define BOOST_PP_CONFIG_MSVC() 0x0004 +# define BOOST_PP_CONFIG_MWCC() 0x0008 +# define BOOST_PP_CONFIG_BCC() 0x0010 +# define BOOST_PP_CONFIG_EDG() 0x0020 +# +# ifndef BOOST_PP_CONFIG_FLAGS +# if defined(__SPIRIT_PP__) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT()) +# elif defined(__EDG__) || defined(__EDG_VERSION__) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_EDG() | BOOST_PP_CONFIG_STRICT()) +# elif defined(__MWERKS__) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MWCC()) +# elif defined(__BORLANDC__) || defined(__IBMC__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_BCC()) +# elif defined(_MSC_VER) +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MSVC()) +# else +# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT()) +# endif +# endif +# +# /* BOOST_PP_CONFIG_EXTENDED_LINE_INFO */ +# +# ifndef BOOST_PP_CONFIG_EXTENDED_LINE_INFO +# define BOOST_PP_CONFIG_EXTENDED_LINE_INFO 0 +# endif +# +# /* BOOST_PP_CONFIG_ERRORS */ +# +# ifndef BOOST_PP_CONFIG_ERRORS +# ifdef NDEBUG +# define BOOST_PP_CONFIG_ERRORS 0 +# else +# define BOOST_PP_CONFIG_ERRORS 1 +# endif +# endif +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/control/expr_iif.hpp b/deal.II/contrib/boost/include/boost/preprocessor/control/expr_iif.hpp new file mode 100644 index 0000000000..f69b9578ec --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/control/expr_iif.hpp @@ -0,0 +1,32 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP +# define BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP +# +# include +# +# /* BOOST_PP_EXPR_IIF */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_EXPR_IIF(bit, expr) BOOST_PP_EXPR_IIF_I(bit, expr) +# else +# define BOOST_PP_EXPR_IIF(bit, expr) BOOST_PP_EXPR_IIF_OO((bit, expr)) +# define BOOST_PP_EXPR_IIF_OO(par) BOOST_PP_EXPR_IIF_I ## par +# endif +# +# define BOOST_PP_EXPR_IIF_I(bit, expr) BOOST_PP_EXPR_IIF_ ## bit(expr) +# +# define BOOST_PP_EXPR_IIF_0(expr) +# define BOOST_PP_EXPR_IIF_1(expr) expr +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/control/if.hpp b/deal.II/contrib/boost/include/boost/preprocessor/control/if.hpp new file mode 100644 index 0000000000..71b743d1c2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/control/if.hpp @@ -0,0 +1,31 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CONTROL_IF_HPP +# define BOOST_PREPROCESSOR_CONTROL_IF_HPP +# +# include +# include +# include +# +# /* BOOST_PP_IF */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_IF(cond, t, f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f) +# else +# define BOOST_PP_IF(cond, t, f) BOOST_PP_IF_I(cond, t, f) +# define BOOST_PP_IF_I(cond, t, f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f) +# endif +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/control/iif.hpp b/deal.II/contrib/boost/include/boost/preprocessor/control/iif.hpp new file mode 100644 index 0000000000..c60f69f384 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/control/iif.hpp @@ -0,0 +1,35 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_CONTROL_IIF_HPP +# define BOOST_PREPROCESSOR_CONTROL_IIF_HPP +# +# include +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_IIF(bit, t, f) BOOST_PP_IIF_I(bit, t, f) +# else +# define BOOST_PP_IIF(bit, t, f) BOOST_PP_IIF_OO((bit, t, f)) +# define BOOST_PP_IIF_OO(par) BOOST_PP_IIF_I ## par +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_IIF_I(bit, t, f) BOOST_PP_IIF_ ## bit(t, f) +# else +# define BOOST_PP_IIF_I(bit, t, f) BOOST_PP_IIF_II(BOOST_PP_IIF_ ## bit(t, f)) +# define BOOST_PP_IIF_II(id) id +# endif +# +# define BOOST_PP_IIF_0(t, f) f +# define BOOST_PP_IIF_1(t, f) t +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/debug/error.hpp b/deal.II/contrib/boost/include/boost/preprocessor/debug/error.hpp new file mode 100644 index 0000000000..383f836fc4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/debug/error.hpp @@ -0,0 +1,34 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_DEBUG_ERROR_HPP +# define BOOST_PREPROCESSOR_DEBUG_ERROR_HPP +# +# include +# include +# +# /* BOOST_PP_ERROR */ +# +# if BOOST_PP_CONFIG_ERRORS +# define BOOST_PP_ERROR(code) BOOST_PP_CAT(BOOST_PP_ERROR_, code) +# endif +# +# define BOOST_PP_ERROR_0x0000 BOOST_PP_ERROR(0x0000, BOOST_PP_INDEX_OUT_OF_BOUNDS) +# define BOOST_PP_ERROR_0x0001 BOOST_PP_ERROR(0x0001, BOOST_PP_WHILE_OVERFLOW) +# define BOOST_PP_ERROR_0x0002 BOOST_PP_ERROR(0x0002, BOOST_PP_FOR_OVERFLOW) +# define BOOST_PP_ERROR_0x0003 BOOST_PP_ERROR(0x0003, BOOST_PP_REPEAT_OVERFLOW) +# define BOOST_PP_ERROR_0x0004 BOOST_PP_ERROR(0x0004, BOOST_PP_LIST_FOLD_OVERFLOW) +# define BOOST_PP_ERROR_0x0005 BOOST_PP_ERROR(0x0005, BOOST_PP_SEQ_FOLD_OVERFLOW) +# define BOOST_PP_ERROR_0x0006 BOOST_PP_ERROR(0x0006, BOOST_PP_ARITHMETIC_OVERFLOW) +# define BOOST_PP_ERROR_0x0007 BOOST_PP_ERROR(0x0007, BOOST_PP_DIVISION_BY_ZERO) +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/detail/auto_rec.hpp b/deal.II/contrib/boost/include/boost/preprocessor/detail/auto_rec.hpp new file mode 100644 index 0000000000..eaff3fc6a8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/detail/auto_rec.hpp @@ -0,0 +1,287 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP +# define BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP +# +# include +# +# /* BOOST_PP_AUTO_REC */ +# +# define BOOST_PP_AUTO_REC(pred, n) BOOST_PP_NODE_ENTRY_ ## n(pred) +# +# define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_128(p) BOOST_PP_NODE_64(p)(p)(p)(p)(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_64(p) BOOST_PP_NODE_32(p)(p)(p)(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_32(p) BOOST_PP_NODE_16(p)(p)(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_16(p) BOOST_PP_NODE_8(p)(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_8(p) BOOST_PP_NODE_4(p)(p)(p) +# define BOOST_PP_NODE_ENTRY_4(p) BOOST_PP_NODE_2(p)(p) +# define BOOST_PP_NODE_ENTRY_2(p) BOOST_PP_NODE_1(p) +# +# define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192) +# define BOOST_PP_NODE_64(p) BOOST_PP_IIF(p(64), BOOST_PP_NODE_32, BOOST_PP_NODE_96) +# define BOOST_PP_NODE_32(p) BOOST_PP_IIF(p(32), BOOST_PP_NODE_16, BOOST_PP_NODE_48) +# define BOOST_PP_NODE_16(p) BOOST_PP_IIF(p(16), BOOST_PP_NODE_8, BOOST_PP_NODE_24) +# define BOOST_PP_NODE_8(p) BOOST_PP_IIF(p(8), BOOST_PP_NODE_4, BOOST_PP_NODE_12) +# define BOOST_PP_NODE_4(p) BOOST_PP_IIF(p(4), BOOST_PP_NODE_2, BOOST_PP_NODE_6) +# define BOOST_PP_NODE_2(p) BOOST_PP_IIF(p(2), BOOST_PP_NODE_1, BOOST_PP_NODE_3) +# define BOOST_PP_NODE_1(p) BOOST_PP_IIF(p(1), 1, 2) +# define BOOST_PP_NODE_3(p) BOOST_PP_IIF(p(3), 3, 4) +# define BOOST_PP_NODE_6(p) BOOST_PP_IIF(p(6), BOOST_PP_NODE_5, BOOST_PP_NODE_7) +# define BOOST_PP_NODE_5(p) BOOST_PP_IIF(p(5), 5, 6) +# define BOOST_PP_NODE_7(p) BOOST_PP_IIF(p(7), 7, 8) +# define BOOST_PP_NODE_12(p) BOOST_PP_IIF(p(12), BOOST_PP_NODE_10, BOOST_PP_NODE_14) +# define BOOST_PP_NODE_10(p) BOOST_PP_IIF(p(10), BOOST_PP_NODE_9, BOOST_PP_NODE_11) +# define BOOST_PP_NODE_9(p) BOOST_PP_IIF(p(9), 9, 10) +# define BOOST_PP_NODE_11(p) BOOST_PP_IIF(p(11), 11, 12) +# define BOOST_PP_NODE_14(p) BOOST_PP_IIF(p(14), BOOST_PP_NODE_13, BOOST_PP_NODE_15) +# define BOOST_PP_NODE_13(p) BOOST_PP_IIF(p(13), 13, 14) +# define BOOST_PP_NODE_15(p) BOOST_PP_IIF(p(15), 15, 16) +# define BOOST_PP_NODE_24(p) BOOST_PP_IIF(p(24), BOOST_PP_NODE_20, BOOST_PP_NODE_28) +# define BOOST_PP_NODE_20(p) BOOST_PP_IIF(p(20), BOOST_PP_NODE_18, BOOST_PP_NODE_22) +# define BOOST_PP_NODE_18(p) BOOST_PP_IIF(p(18), BOOST_PP_NODE_17, BOOST_PP_NODE_19) +# define BOOST_PP_NODE_17(p) BOOST_PP_IIF(p(17), 17, 18) +# define BOOST_PP_NODE_19(p) BOOST_PP_IIF(p(19), 19, 20) +# define BOOST_PP_NODE_22(p) BOOST_PP_IIF(p(22), BOOST_PP_NODE_21, BOOST_PP_NODE_23) +# define BOOST_PP_NODE_21(p) BOOST_PP_IIF(p(21), 21, 22) +# define BOOST_PP_NODE_23(p) BOOST_PP_IIF(p(23), 23, 24) +# define BOOST_PP_NODE_28(p) BOOST_PP_IIF(p(28), BOOST_PP_NODE_26, BOOST_PP_NODE_30) +# define BOOST_PP_NODE_26(p) BOOST_PP_IIF(p(26), BOOST_PP_NODE_25, BOOST_PP_NODE_27) +# define BOOST_PP_NODE_25(p) BOOST_PP_IIF(p(25), 25, 26) +# define BOOST_PP_NODE_27(p) BOOST_PP_IIF(p(27), 27, 28) +# define BOOST_PP_NODE_30(p) BOOST_PP_IIF(p(30), BOOST_PP_NODE_29, BOOST_PP_NODE_31) +# define BOOST_PP_NODE_29(p) BOOST_PP_IIF(p(29), 29, 30) +# define BOOST_PP_NODE_31(p) BOOST_PP_IIF(p(31), 31, 32) +# define BOOST_PP_NODE_48(p) BOOST_PP_IIF(p(48), BOOST_PP_NODE_40, BOOST_PP_NODE_56) +# define BOOST_PP_NODE_40(p) BOOST_PP_IIF(p(40), BOOST_PP_NODE_36, BOOST_PP_NODE_44) +# define BOOST_PP_NODE_36(p) BOOST_PP_IIF(p(36), BOOST_PP_NODE_34, BOOST_PP_NODE_38) +# define BOOST_PP_NODE_34(p) BOOST_PP_IIF(p(34), BOOST_PP_NODE_33, BOOST_PP_NODE_35) +# define BOOST_PP_NODE_33(p) BOOST_PP_IIF(p(33), 33, 34) +# define BOOST_PP_NODE_35(p) BOOST_PP_IIF(p(35), 35, 36) +# define BOOST_PP_NODE_38(p) BOOST_PP_IIF(p(38), BOOST_PP_NODE_37, BOOST_PP_NODE_39) +# define BOOST_PP_NODE_37(p) BOOST_PP_IIF(p(37), 37, 38) +# define BOOST_PP_NODE_39(p) BOOST_PP_IIF(p(39), 39, 40) +# define BOOST_PP_NODE_44(p) BOOST_PP_IIF(p(44), BOOST_PP_NODE_42, BOOST_PP_NODE_46) +# define BOOST_PP_NODE_42(p) BOOST_PP_IIF(p(42), BOOST_PP_NODE_41, BOOST_PP_NODE_43) +# define BOOST_PP_NODE_41(p) BOOST_PP_IIF(p(41), 41, 42) +# define BOOST_PP_NODE_43(p) BOOST_PP_IIF(p(43), 43, 44) +# define BOOST_PP_NODE_46(p) BOOST_PP_IIF(p(46), BOOST_PP_NODE_45, BOOST_PP_NODE_47) +# define BOOST_PP_NODE_45(p) BOOST_PP_IIF(p(45), 45, 46) +# define BOOST_PP_NODE_47(p) BOOST_PP_IIF(p(47), 47, 48) +# define BOOST_PP_NODE_56(p) BOOST_PP_IIF(p(56), BOOST_PP_NODE_52, BOOST_PP_NODE_60) +# define BOOST_PP_NODE_52(p) BOOST_PP_IIF(p(52), BOOST_PP_NODE_50, BOOST_PP_NODE_54) +# define BOOST_PP_NODE_50(p) BOOST_PP_IIF(p(50), BOOST_PP_NODE_49, BOOST_PP_NODE_51) +# define BOOST_PP_NODE_49(p) BOOST_PP_IIF(p(49), 49, 50) +# define BOOST_PP_NODE_51(p) BOOST_PP_IIF(p(51), 51, 52) +# define BOOST_PP_NODE_54(p) BOOST_PP_IIF(p(54), BOOST_PP_NODE_53, BOOST_PP_NODE_55) +# define BOOST_PP_NODE_53(p) BOOST_PP_IIF(p(53), 53, 54) +# define BOOST_PP_NODE_55(p) BOOST_PP_IIF(p(55), 55, 56) +# define BOOST_PP_NODE_60(p) BOOST_PP_IIF(p(60), BOOST_PP_NODE_58, BOOST_PP_NODE_62) +# define BOOST_PP_NODE_58(p) BOOST_PP_IIF(p(58), BOOST_PP_NODE_57, BOOST_PP_NODE_59) +# define BOOST_PP_NODE_57(p) BOOST_PP_IIF(p(57), 57, 58) +# define BOOST_PP_NODE_59(p) BOOST_PP_IIF(p(59), 59, 60) +# define BOOST_PP_NODE_62(p) BOOST_PP_IIF(p(62), BOOST_PP_NODE_61, BOOST_PP_NODE_63) +# define BOOST_PP_NODE_61(p) BOOST_PP_IIF(p(61), 61, 62) +# define BOOST_PP_NODE_63(p) BOOST_PP_IIF(p(63), 63, 64) +# define BOOST_PP_NODE_96(p) BOOST_PP_IIF(p(96), BOOST_PP_NODE_80, BOOST_PP_NODE_112) +# define BOOST_PP_NODE_80(p) BOOST_PP_IIF(p(80), BOOST_PP_NODE_72, BOOST_PP_NODE_88) +# define BOOST_PP_NODE_72(p) BOOST_PP_IIF(p(72), BOOST_PP_NODE_68, BOOST_PP_NODE_76) +# define BOOST_PP_NODE_68(p) BOOST_PP_IIF(p(68), BOOST_PP_NODE_66, BOOST_PP_NODE_70) +# define BOOST_PP_NODE_66(p) BOOST_PP_IIF(p(66), BOOST_PP_NODE_65, BOOST_PP_NODE_67) +# define BOOST_PP_NODE_65(p) BOOST_PP_IIF(p(65), 65, 66) +# define BOOST_PP_NODE_67(p) BOOST_PP_IIF(p(67), 67, 68) +# define BOOST_PP_NODE_70(p) BOOST_PP_IIF(p(70), BOOST_PP_NODE_69, BOOST_PP_NODE_71) +# define BOOST_PP_NODE_69(p) BOOST_PP_IIF(p(69), 69, 70) +# define BOOST_PP_NODE_71(p) BOOST_PP_IIF(p(71), 71, 72) +# define BOOST_PP_NODE_76(p) BOOST_PP_IIF(p(76), BOOST_PP_NODE_74, BOOST_PP_NODE_78) +# define BOOST_PP_NODE_74(p) BOOST_PP_IIF(p(74), BOOST_PP_NODE_73, BOOST_PP_NODE_75) +# define BOOST_PP_NODE_73(p) BOOST_PP_IIF(p(73), 73, 74) +# define BOOST_PP_NODE_75(p) BOOST_PP_IIF(p(75), 75, 76) +# define BOOST_PP_NODE_78(p) BOOST_PP_IIF(p(78), BOOST_PP_NODE_77, BOOST_PP_NODE_79) +# define BOOST_PP_NODE_77(p) BOOST_PP_IIF(p(77), 77, 78) +# define BOOST_PP_NODE_79(p) BOOST_PP_IIF(p(79), 79, 80) +# define BOOST_PP_NODE_88(p) BOOST_PP_IIF(p(88), BOOST_PP_NODE_84, BOOST_PP_NODE_92) +# define BOOST_PP_NODE_84(p) BOOST_PP_IIF(p(84), BOOST_PP_NODE_82, BOOST_PP_NODE_86) +# define BOOST_PP_NODE_82(p) BOOST_PP_IIF(p(82), BOOST_PP_NODE_81, BOOST_PP_NODE_83) +# define BOOST_PP_NODE_81(p) BOOST_PP_IIF(p(81), 81, 82) +# define BOOST_PP_NODE_83(p) BOOST_PP_IIF(p(83), 83, 84) +# define BOOST_PP_NODE_86(p) BOOST_PP_IIF(p(86), BOOST_PP_NODE_85, BOOST_PP_NODE_87) +# define BOOST_PP_NODE_85(p) BOOST_PP_IIF(p(85), 85, 86) +# define BOOST_PP_NODE_87(p) BOOST_PP_IIF(p(87), 87, 88) +# define BOOST_PP_NODE_92(p) BOOST_PP_IIF(p(92), BOOST_PP_NODE_90, BOOST_PP_NODE_94) +# define BOOST_PP_NODE_90(p) BOOST_PP_IIF(p(90), BOOST_PP_NODE_89, BOOST_PP_NODE_91) +# define BOOST_PP_NODE_89(p) BOOST_PP_IIF(p(89), 89, 90) +# define BOOST_PP_NODE_91(p) BOOST_PP_IIF(p(91), 91, 92) +# define BOOST_PP_NODE_94(p) BOOST_PP_IIF(p(94), BOOST_PP_NODE_93, BOOST_PP_NODE_95) +# define BOOST_PP_NODE_93(p) BOOST_PP_IIF(p(93), 93, 94) +# define BOOST_PP_NODE_95(p) BOOST_PP_IIF(p(95), 95, 96) +# define BOOST_PP_NODE_112(p) BOOST_PP_IIF(p(112), BOOST_PP_NODE_104, BOOST_PP_NODE_120) +# define BOOST_PP_NODE_104(p) BOOST_PP_IIF(p(104), BOOST_PP_NODE_100, BOOST_PP_NODE_108) +# define BOOST_PP_NODE_100(p) BOOST_PP_IIF(p(100), BOOST_PP_NODE_98, BOOST_PP_NODE_102) +# define BOOST_PP_NODE_98(p) BOOST_PP_IIF(p(98), BOOST_PP_NODE_97, BOOST_PP_NODE_99) +# define BOOST_PP_NODE_97(p) BOOST_PP_IIF(p(97), 97, 98) +# define BOOST_PP_NODE_99(p) BOOST_PP_IIF(p(99), 99, 100) +# define BOOST_PP_NODE_102(p) BOOST_PP_IIF(p(102), BOOST_PP_NODE_101, BOOST_PP_NODE_103) +# define BOOST_PP_NODE_101(p) BOOST_PP_IIF(p(101), 101, 102) +# define BOOST_PP_NODE_103(p) BOOST_PP_IIF(p(103), 103, 104) +# define BOOST_PP_NODE_108(p) BOOST_PP_IIF(p(108), BOOST_PP_NODE_106, BOOST_PP_NODE_110) +# define BOOST_PP_NODE_106(p) BOOST_PP_IIF(p(106), BOOST_PP_NODE_105, BOOST_PP_NODE_107) +# define BOOST_PP_NODE_105(p) BOOST_PP_IIF(p(105), 105, 106) +# define BOOST_PP_NODE_107(p) BOOST_PP_IIF(p(107), 107, 108) +# define BOOST_PP_NODE_110(p) BOOST_PP_IIF(p(110), BOOST_PP_NODE_109, BOOST_PP_NODE_111) +# define BOOST_PP_NODE_109(p) BOOST_PP_IIF(p(109), 109, 110) +# define BOOST_PP_NODE_111(p) BOOST_PP_IIF(p(111), 111, 112) +# define BOOST_PP_NODE_120(p) BOOST_PP_IIF(p(120), BOOST_PP_NODE_116, BOOST_PP_NODE_124) +# define BOOST_PP_NODE_116(p) BOOST_PP_IIF(p(116), BOOST_PP_NODE_114, BOOST_PP_NODE_118) +# define BOOST_PP_NODE_114(p) BOOST_PP_IIF(p(114), BOOST_PP_NODE_113, BOOST_PP_NODE_115) +# define BOOST_PP_NODE_113(p) BOOST_PP_IIF(p(113), 113, 114) +# define BOOST_PP_NODE_115(p) BOOST_PP_IIF(p(115), 115, 116) +# define BOOST_PP_NODE_118(p) BOOST_PP_IIF(p(118), BOOST_PP_NODE_117, BOOST_PP_NODE_119) +# define BOOST_PP_NODE_117(p) BOOST_PP_IIF(p(117), 117, 118) +# define BOOST_PP_NODE_119(p) BOOST_PP_IIF(p(119), 119, 120) +# define BOOST_PP_NODE_124(p) BOOST_PP_IIF(p(124), BOOST_PP_NODE_122, BOOST_PP_NODE_126) +# define BOOST_PP_NODE_122(p) BOOST_PP_IIF(p(122), BOOST_PP_NODE_121, BOOST_PP_NODE_123) +# define BOOST_PP_NODE_121(p) BOOST_PP_IIF(p(121), 121, 122) +# define BOOST_PP_NODE_123(p) BOOST_PP_IIF(p(123), 123, 124) +# define BOOST_PP_NODE_126(p) BOOST_PP_IIF(p(126), BOOST_PP_NODE_125, BOOST_PP_NODE_127) +# define BOOST_PP_NODE_125(p) BOOST_PP_IIF(p(125), 125, 126) +# define BOOST_PP_NODE_127(p) BOOST_PP_IIF(p(127), 127, 128) +# define BOOST_PP_NODE_192(p) BOOST_PP_IIF(p(192), BOOST_PP_NODE_160, BOOST_PP_NODE_224) +# define BOOST_PP_NODE_160(p) BOOST_PP_IIF(p(160), BOOST_PP_NODE_144, BOOST_PP_NODE_176) +# define BOOST_PP_NODE_144(p) BOOST_PP_IIF(p(144), BOOST_PP_NODE_136, BOOST_PP_NODE_152) +# define BOOST_PP_NODE_136(p) BOOST_PP_IIF(p(136), BOOST_PP_NODE_132, BOOST_PP_NODE_140) +# define BOOST_PP_NODE_132(p) BOOST_PP_IIF(p(132), BOOST_PP_NODE_130, BOOST_PP_NODE_134) +# define BOOST_PP_NODE_130(p) BOOST_PP_IIF(p(130), BOOST_PP_NODE_129, BOOST_PP_NODE_131) +# define BOOST_PP_NODE_129(p) BOOST_PP_IIF(p(129), 129, 130) +# define BOOST_PP_NODE_131(p) BOOST_PP_IIF(p(131), 131, 132) +# define BOOST_PP_NODE_134(p) BOOST_PP_IIF(p(134), BOOST_PP_NODE_133, BOOST_PP_NODE_135) +# define BOOST_PP_NODE_133(p) BOOST_PP_IIF(p(133), 133, 134) +# define BOOST_PP_NODE_135(p) BOOST_PP_IIF(p(135), 135, 136) +# define BOOST_PP_NODE_140(p) BOOST_PP_IIF(p(140), BOOST_PP_NODE_138, BOOST_PP_NODE_142) +# define BOOST_PP_NODE_138(p) BOOST_PP_IIF(p(138), BOOST_PP_NODE_137, BOOST_PP_NODE_139) +# define BOOST_PP_NODE_137(p) BOOST_PP_IIF(p(137), 137, 138) +# define BOOST_PP_NODE_139(p) BOOST_PP_IIF(p(139), 139, 140) +# define BOOST_PP_NODE_142(p) BOOST_PP_IIF(p(142), BOOST_PP_NODE_141, BOOST_PP_NODE_143) +# define BOOST_PP_NODE_141(p) BOOST_PP_IIF(p(141), 141, 142) +# define BOOST_PP_NODE_143(p) BOOST_PP_IIF(p(143), 143, 144) +# define BOOST_PP_NODE_152(p) BOOST_PP_IIF(p(152), BOOST_PP_NODE_148, BOOST_PP_NODE_156) +# define BOOST_PP_NODE_148(p) BOOST_PP_IIF(p(148), BOOST_PP_NODE_146, BOOST_PP_NODE_150) +# define BOOST_PP_NODE_146(p) BOOST_PP_IIF(p(146), BOOST_PP_NODE_145, BOOST_PP_NODE_147) +# define BOOST_PP_NODE_145(p) BOOST_PP_IIF(p(145), 145, 146) +# define BOOST_PP_NODE_147(p) BOOST_PP_IIF(p(147), 147, 148) +# define BOOST_PP_NODE_150(p) BOOST_PP_IIF(p(150), BOOST_PP_NODE_149, BOOST_PP_NODE_151) +# define BOOST_PP_NODE_149(p) BOOST_PP_IIF(p(149), 149, 150) +# define BOOST_PP_NODE_151(p) BOOST_PP_IIF(p(151), 151, 152) +# define BOOST_PP_NODE_156(p) BOOST_PP_IIF(p(156), BOOST_PP_NODE_154, BOOST_PP_NODE_158) +# define BOOST_PP_NODE_154(p) BOOST_PP_IIF(p(154), BOOST_PP_NODE_153, BOOST_PP_NODE_155) +# define BOOST_PP_NODE_153(p) BOOST_PP_IIF(p(153), 153, 154) +# define BOOST_PP_NODE_155(p) BOOST_PP_IIF(p(155), 155, 156) +# define BOOST_PP_NODE_158(p) BOOST_PP_IIF(p(158), BOOST_PP_NODE_157, BOOST_PP_NODE_159) +# define BOOST_PP_NODE_157(p) BOOST_PP_IIF(p(157), 157, 158) +# define BOOST_PP_NODE_159(p) BOOST_PP_IIF(p(159), 159, 160) +# define BOOST_PP_NODE_176(p) BOOST_PP_IIF(p(176), BOOST_PP_NODE_168, BOOST_PP_NODE_184) +# define BOOST_PP_NODE_168(p) BOOST_PP_IIF(p(168), BOOST_PP_NODE_164, BOOST_PP_NODE_172) +# define BOOST_PP_NODE_164(p) BOOST_PP_IIF(p(164), BOOST_PP_NODE_162, BOOST_PP_NODE_166) +# define BOOST_PP_NODE_162(p) BOOST_PP_IIF(p(162), BOOST_PP_NODE_161, BOOST_PP_NODE_163) +# define BOOST_PP_NODE_161(p) BOOST_PP_IIF(p(161), 161, 162) +# define BOOST_PP_NODE_163(p) BOOST_PP_IIF(p(163), 163, 164) +# define BOOST_PP_NODE_166(p) BOOST_PP_IIF(p(166), BOOST_PP_NODE_165, BOOST_PP_NODE_167) +# define BOOST_PP_NODE_165(p) BOOST_PP_IIF(p(165), 165, 166) +# define BOOST_PP_NODE_167(p) BOOST_PP_IIF(p(167), 167, 168) +# define BOOST_PP_NODE_172(p) BOOST_PP_IIF(p(172), BOOST_PP_NODE_170, BOOST_PP_NODE_174) +# define BOOST_PP_NODE_170(p) BOOST_PP_IIF(p(170), BOOST_PP_NODE_169, BOOST_PP_NODE_171) +# define BOOST_PP_NODE_169(p) BOOST_PP_IIF(p(169), 169, 170) +# define BOOST_PP_NODE_171(p) BOOST_PP_IIF(p(171), 171, 172) +# define BOOST_PP_NODE_174(p) BOOST_PP_IIF(p(174), BOOST_PP_NODE_173, BOOST_PP_NODE_175) +# define BOOST_PP_NODE_173(p) BOOST_PP_IIF(p(173), 173, 174) +# define BOOST_PP_NODE_175(p) BOOST_PP_IIF(p(175), 175, 176) +# define BOOST_PP_NODE_184(p) BOOST_PP_IIF(p(184), BOOST_PP_NODE_180, BOOST_PP_NODE_188) +# define BOOST_PP_NODE_180(p) BOOST_PP_IIF(p(180), BOOST_PP_NODE_178, BOOST_PP_NODE_182) +# define BOOST_PP_NODE_178(p) BOOST_PP_IIF(p(178), BOOST_PP_NODE_177, BOOST_PP_NODE_179) +# define BOOST_PP_NODE_177(p) BOOST_PP_IIF(p(177), 177, 178) +# define BOOST_PP_NODE_179(p) BOOST_PP_IIF(p(179), 179, 180) +# define BOOST_PP_NODE_182(p) BOOST_PP_IIF(p(182), BOOST_PP_NODE_181, BOOST_PP_NODE_183) +# define BOOST_PP_NODE_181(p) BOOST_PP_IIF(p(181), 181, 182) +# define BOOST_PP_NODE_183(p) BOOST_PP_IIF(p(183), 183, 184) +# define BOOST_PP_NODE_188(p) BOOST_PP_IIF(p(188), BOOST_PP_NODE_186, BOOST_PP_NODE_190) +# define BOOST_PP_NODE_186(p) BOOST_PP_IIF(p(186), BOOST_PP_NODE_185, BOOST_PP_NODE_187) +# define BOOST_PP_NODE_185(p) BOOST_PP_IIF(p(185), 185, 186) +# define BOOST_PP_NODE_187(p) BOOST_PP_IIF(p(187), 187, 188) +# define BOOST_PP_NODE_190(p) BOOST_PP_IIF(p(190), BOOST_PP_NODE_189, BOOST_PP_NODE_191) +# define BOOST_PP_NODE_189(p) BOOST_PP_IIF(p(189), 189, 190) +# define BOOST_PP_NODE_191(p) BOOST_PP_IIF(p(191), 191, 192) +# define BOOST_PP_NODE_224(p) BOOST_PP_IIF(p(224), BOOST_PP_NODE_208, BOOST_PP_NODE_240) +# define BOOST_PP_NODE_208(p) BOOST_PP_IIF(p(208), BOOST_PP_NODE_200, BOOST_PP_NODE_216) +# define BOOST_PP_NODE_200(p) BOOST_PP_IIF(p(200), BOOST_PP_NODE_196, BOOST_PP_NODE_204) +# define BOOST_PP_NODE_196(p) BOOST_PP_IIF(p(196), BOOST_PP_NODE_194, BOOST_PP_NODE_198) +# define BOOST_PP_NODE_194(p) BOOST_PP_IIF(p(194), BOOST_PP_NODE_193, BOOST_PP_NODE_195) +# define BOOST_PP_NODE_193(p) BOOST_PP_IIF(p(193), 193, 194) +# define BOOST_PP_NODE_195(p) BOOST_PP_IIF(p(195), 195, 196) +# define BOOST_PP_NODE_198(p) BOOST_PP_IIF(p(198), BOOST_PP_NODE_197, BOOST_PP_NODE_199) +# define BOOST_PP_NODE_197(p) BOOST_PP_IIF(p(197), 197, 198) +# define BOOST_PP_NODE_199(p) BOOST_PP_IIF(p(199), 199, 200) +# define BOOST_PP_NODE_204(p) BOOST_PP_IIF(p(204), BOOST_PP_NODE_202, BOOST_PP_NODE_206) +# define BOOST_PP_NODE_202(p) BOOST_PP_IIF(p(202), BOOST_PP_NODE_201, BOOST_PP_NODE_203) +# define BOOST_PP_NODE_201(p) BOOST_PP_IIF(p(201), 201, 202) +# define BOOST_PP_NODE_203(p) BOOST_PP_IIF(p(203), 203, 204) +# define BOOST_PP_NODE_206(p) BOOST_PP_IIF(p(206), BOOST_PP_NODE_205, BOOST_PP_NODE_207) +# define BOOST_PP_NODE_205(p) BOOST_PP_IIF(p(205), 205, 206) +# define BOOST_PP_NODE_207(p) BOOST_PP_IIF(p(207), 207, 208) +# define BOOST_PP_NODE_216(p) BOOST_PP_IIF(p(216), BOOST_PP_NODE_212, BOOST_PP_NODE_220) +# define BOOST_PP_NODE_212(p) BOOST_PP_IIF(p(212), BOOST_PP_NODE_210, BOOST_PP_NODE_214) +# define BOOST_PP_NODE_210(p) BOOST_PP_IIF(p(210), BOOST_PP_NODE_209, BOOST_PP_NODE_211) +# define BOOST_PP_NODE_209(p) BOOST_PP_IIF(p(209), 209, 210) +# define BOOST_PP_NODE_211(p) BOOST_PP_IIF(p(211), 211, 212) +# define BOOST_PP_NODE_214(p) BOOST_PP_IIF(p(214), BOOST_PP_NODE_213, BOOST_PP_NODE_215) +# define BOOST_PP_NODE_213(p) BOOST_PP_IIF(p(213), 213, 214) +# define BOOST_PP_NODE_215(p) BOOST_PP_IIF(p(215), 215, 216) +# define BOOST_PP_NODE_220(p) BOOST_PP_IIF(p(220), BOOST_PP_NODE_218, BOOST_PP_NODE_222) +# define BOOST_PP_NODE_218(p) BOOST_PP_IIF(p(218), BOOST_PP_NODE_217, BOOST_PP_NODE_219) +# define BOOST_PP_NODE_217(p) BOOST_PP_IIF(p(217), 217, 218) +# define BOOST_PP_NODE_219(p) BOOST_PP_IIF(p(219), 219, 220) +# define BOOST_PP_NODE_222(p) BOOST_PP_IIF(p(222), BOOST_PP_NODE_221, BOOST_PP_NODE_223) +# define BOOST_PP_NODE_221(p) BOOST_PP_IIF(p(221), 221, 222) +# define BOOST_PP_NODE_223(p) BOOST_PP_IIF(p(223), 223, 224) +# define BOOST_PP_NODE_240(p) BOOST_PP_IIF(p(240), BOOST_PP_NODE_232, BOOST_PP_NODE_248) +# define BOOST_PP_NODE_232(p) BOOST_PP_IIF(p(232), BOOST_PP_NODE_228, BOOST_PP_NODE_236) +# define BOOST_PP_NODE_228(p) BOOST_PP_IIF(p(228), BOOST_PP_NODE_226, BOOST_PP_NODE_230) +# define BOOST_PP_NODE_226(p) BOOST_PP_IIF(p(226), BOOST_PP_NODE_225, BOOST_PP_NODE_227) +# define BOOST_PP_NODE_225(p) BOOST_PP_IIF(p(225), 225, 226) +# define BOOST_PP_NODE_227(p) BOOST_PP_IIF(p(227), 227, 228) +# define BOOST_PP_NODE_230(p) BOOST_PP_IIF(p(230), BOOST_PP_NODE_229, BOOST_PP_NODE_231) +# define BOOST_PP_NODE_229(p) BOOST_PP_IIF(p(229), 229, 230) +# define BOOST_PP_NODE_231(p) BOOST_PP_IIF(p(231), 231, 232) +# define BOOST_PP_NODE_236(p) BOOST_PP_IIF(p(236), BOOST_PP_NODE_234, BOOST_PP_NODE_238) +# define BOOST_PP_NODE_234(p) BOOST_PP_IIF(p(234), BOOST_PP_NODE_233, BOOST_PP_NODE_235) +# define BOOST_PP_NODE_233(p) BOOST_PP_IIF(p(233), 233, 234) +# define BOOST_PP_NODE_235(p) BOOST_PP_IIF(p(235), 235, 236) +# define BOOST_PP_NODE_238(p) BOOST_PP_IIF(p(238), BOOST_PP_NODE_237, BOOST_PP_NODE_239) +# define BOOST_PP_NODE_237(p) BOOST_PP_IIF(p(237), 237, 238) +# define BOOST_PP_NODE_239(p) BOOST_PP_IIF(p(239), 239, 240) +# define BOOST_PP_NODE_248(p) BOOST_PP_IIF(p(248), BOOST_PP_NODE_244, BOOST_PP_NODE_252) +# define BOOST_PP_NODE_244(p) BOOST_PP_IIF(p(244), BOOST_PP_NODE_242, BOOST_PP_NODE_246) +# define BOOST_PP_NODE_242(p) BOOST_PP_IIF(p(242), BOOST_PP_NODE_241, BOOST_PP_NODE_243) +# define BOOST_PP_NODE_241(p) BOOST_PP_IIF(p(241), 241, 242) +# define BOOST_PP_NODE_243(p) BOOST_PP_IIF(p(243), 243, 244) +# define BOOST_PP_NODE_246(p) BOOST_PP_IIF(p(246), BOOST_PP_NODE_245, BOOST_PP_NODE_247) +# define BOOST_PP_NODE_245(p) BOOST_PP_IIF(p(245), 245, 246) +# define BOOST_PP_NODE_247(p) BOOST_PP_IIF(p(247), 247, 248) +# define BOOST_PP_NODE_252(p) BOOST_PP_IIF(p(252), BOOST_PP_NODE_250, BOOST_PP_NODE_254) +# define BOOST_PP_NODE_250(p) BOOST_PP_IIF(p(250), BOOST_PP_NODE_249, BOOST_PP_NODE_251) +# define BOOST_PP_NODE_249(p) BOOST_PP_IIF(p(249), 249, 250) +# define BOOST_PP_NODE_251(p) BOOST_PP_IIF(p(251), 251, 252) +# define BOOST_PP_NODE_254(p) BOOST_PP_IIF(p(254), BOOST_PP_NODE_253, BOOST_PP_NODE_255) +# define BOOST_PP_NODE_253(p) BOOST_PP_IIF(p(253), 253, 254) +# define BOOST_PP_NODE_255(p) BOOST_PP_IIF(p(255), 255, 256) +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/detail/check.hpp b/deal.II/contrib/boost/include/boost/preprocessor/detail/check.hpp new file mode 100644 index 0000000000..1a12e26d24 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/detail/check.hpp @@ -0,0 +1,43 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_DETAIL_CHECK_HPP +# define BOOST_PREPROCESSOR_DETAIL_CHECK_HPP +# +# include +# include +# +# /* BOOST_PP_CHECK */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_CHECK(x, type) BOOST_PP_CHECK_D(x, type) +# else +# define BOOST_PP_CHECK(x, type) BOOST_PP_CHECK_OO((x, type)) +# define BOOST_PP_CHECK_OO(par) BOOST_PP_CHECK_D ## par +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_CHECK_D(x, type) BOOST_PP_CHECK_1(BOOST_PP_CAT(BOOST_PP_CHECK_RESULT_, type x)) +# define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk) +# define BOOST_PP_CHECK_2(res, _) res +# else +# define BOOST_PP_CHECK_D(x, type) BOOST_PP_CHECK_1(type x) +# define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk) +# define BOOST_PP_CHECK_2(chk) BOOST_PP_CHECK_3((BOOST_PP_CHECK_RESULT_ ## chk)) +# define BOOST_PP_CHECK_3(im) BOOST_PP_CHECK_5(BOOST_PP_CHECK_4 im) +# define BOOST_PP_CHECK_4(res, _) res +# define BOOST_PP_CHECK_5(res) res +# endif +# +# define BOOST_PP_CHECK_RESULT_1 1, BOOST_PP_NIL +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/detail/is_binary.hpp b/deal.II/contrib/boost/include/boost/preprocessor/detail/is_binary.hpp new file mode 100644 index 0000000000..8a2f267a4f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/detail/is_binary.hpp @@ -0,0 +1,31 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP +# define BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP +# +# include +# include +# +# /* BOOST_PP_IS_BINARY */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_IS_BINARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK) +# else +# define BOOST_PP_IS_BINARY(x) BOOST_PP_IS_BINARY_I(x) +# define BOOST_PP_IS_BINARY_I(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK) +# endif +# +# define BOOST_PP_IS_BINARY_CHECK(a, b) 1 +# define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_BINARY_CHECK 0, BOOST_PP_NIL +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/empty.hpp b/deal.II/contrib/boost/include/boost/preprocessor/empty.hpp new file mode 100644 index 0000000000..cbd9ab3dae --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/empty.hpp @@ -0,0 +1,18 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_EMPTY_HPP +# define BOOST_PREPROCESSOR_EMPTY_HPP +# +# include +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/facilities/empty.hpp b/deal.II/contrib/boost/include/boost/preprocessor/facilities/empty.hpp new file mode 100644 index 0000000000..715fb691be --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/facilities/empty.hpp @@ -0,0 +1,22 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP +# define BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP +# +# /* BOOST_PP_EMPTY */ +# +# define BOOST_PP_EMPTY() +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/facilities/identity.hpp b/deal.II/contrib/boost/include/boost/preprocessor/facilities/identity.hpp new file mode 100644 index 0000000000..d1b911f0cc --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/facilities/identity.hpp @@ -0,0 +1,24 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP +# define BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP +# +# include +# +# /* BOOST_PP_IDENTITY */ +# +# define BOOST_PP_IDENTITY(item) item BOOST_PP_EMPTY +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/identity.hpp b/deal.II/contrib/boost/include/boost/preprocessor/identity.hpp new file mode 100644 index 0000000000..a08687b2d0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/identity.hpp @@ -0,0 +1,18 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_IDENTITY_HPP +# define BOOST_PREPROCESSOR_IDENTITY_HPP +# +# include +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/list/adt.hpp b/deal.II/contrib/boost/include/boost/preprocessor/list/adt.hpp new file mode 100644 index 0000000000..1caec1c82c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/list/adt.hpp @@ -0,0 +1,74 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# * +# * See http://www.boost.org for most recent version. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# ifndef BOOST_PREPROCESSOR_LIST_ADT_HPP +# define BOOST_PREPROCESSOR_LIST_ADT_HPP +# +# include +# include +# include +# include +# +# /* BOOST_PP_LIST_CONS */ +# +# define BOOST_PP_LIST_CONS(head, tail) (head, tail) +# +# /* BOOST_PP_LIST_NIL */ +# +# define BOOST_PP_LIST_NIL BOOST_PP_NIL +# +# /* BOOST_PP_LIST_FIRST */ +# +# define BOOST_PP_LIST_FIRST(list) BOOST_PP_LIST_FIRST_D(list) +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_LIST_FIRST_D(list) BOOST_PP_LIST_FIRST_I list +# else +# define BOOST_PP_LIST_FIRST_D(list) BOOST_PP_LIST_FIRST_I ## list +# endif +# +# define BOOST_PP_LIST_FIRST_I(head, tail) head +# +# /* BOOST_PP_LIST_REST */ +# +# define BOOST_PP_LIST_REST(list) BOOST_PP_LIST_REST_D(list) +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_LIST_REST_D(list) BOOST_PP_LIST_REST_I list +# else +# define BOOST_PP_LIST_REST_D(list) BOOST_PP_LIST_REST_I ## list +# endif +# +# define BOOST_PP_LIST_REST_I(head, tail) tail +# +# /* BOOST_PP_LIST_IS_CONS */ +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_BCC() +# define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_LIST_IS_CONS_D(list) +# define BOOST_PP_LIST_IS_CONS_D(list) BOOST_PP_LIST_IS_CONS_ ## list +# define BOOST_PP_LIST_IS_CONS_(head, tail) 1 +# define BOOST_PP_LIST_IS_CONS_BOOST_PP_NIL 0 +# else +# define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_IS_BINARY(list) +# endif +# +# /* BOOST_PP_LIST_IS_NIL */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_BCC() +# define BOOST_PP_LIST_IS_NIL(list) BOOST_PP_COMPL(BOOST_PP_IS_BINARY(list)) +# else +# define BOOST_PP_LIST_IS_NIL(list) BOOST_PP_COMPL(BOOST_PP_LIST_IS_CONS(list)) +# endif +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/list/for_each_i.hpp b/deal.II/contrib/boost/include/boost/preprocessor/list/for_each_i.hpp new file mode 100644 index 0000000000..b2e420ba05 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/list/for_each_i.hpp @@ -0,0 +1,66 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LIST_LIST_FOR_EACH_I_HPP +# define BOOST_PREPROCESSOR_LIST_LIST_FOR_EACH_I_HPP +# +# include +# include +# include +# include +# include +# include +# +# /* BOOST_PP_LIST_FOR_EACH_I */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_LIST_FOR_EACH_I(macro, data, list) BOOST_PP_FOR((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) +# else +# define BOOST_PP_LIST_FOR_EACH_I(macro, data, list) BOOST_PP_LIST_FOR_EACH_I_I(macro, data, list) +# define BOOST_PP_LIST_FOR_EACH_I_I(macro, data, list) BOOST_PP_FOR((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) +# endif +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() +# define BOOST_PP_LIST_FOR_EACH_I_P(r, x) BOOST_PP_LIST_FOR_EACH_I_P_D x +# define BOOST_PP_LIST_FOR_EACH_I_P_D(m, d, l, i) BOOST_PP_LIST_IS_CONS(l) +# else +# define BOOST_PP_LIST_FOR_EACH_I_P(r, x) BOOST_PP_LIST_IS_CONS(BOOST_PP_TUPLE_ELEM(4, 2, x)) +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_LIST_FOR_EACH_I_O(r, x) BOOST_PP_LIST_FOR_EACH_I_O_D x +# define BOOST_PP_LIST_FOR_EACH_I_O_D(m, d, l, i) (m, d, BOOST_PP_LIST_REST(l), BOOST_PP_INC(i)) +# else +# define BOOST_PP_LIST_FOR_EACH_I_O(r, x) (BOOST_PP_TUPLE_ELEM(4, 0, x), BOOST_PP_TUPLE_ELEM(4, 1, x), BOOST_PP_LIST_REST(BOOST_PP_TUPLE_ELEM(4, 2, x)), BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 3, x))) +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_LIST_FOR_EACH_I_M(r, x) BOOST_PP_LIST_FOR_EACH_I_M_D(r, BOOST_PP_TUPLE_ELEM(4, 0, x), BOOST_PP_TUPLE_ELEM(4, 1, x), BOOST_PP_TUPLE_ELEM(4, 2, x), BOOST_PP_TUPLE_ELEM(4, 3, x)) +# else +# define BOOST_PP_LIST_FOR_EACH_I_M(r, x) BOOST_PP_LIST_FOR_EACH_I_M_I(r, BOOST_PP_TUPLE_REM_4 x) +# define BOOST_PP_LIST_FOR_EACH_I_M_I(r, x_e) BOOST_PP_LIST_FOR_EACH_I_M_D(r, x_e) +# endif +# +# define BOOST_PP_LIST_FOR_EACH_I_M_D(r, m, d, l, i) m(r, d, i, BOOST_PP_LIST_FIRST(l)) +# +# /* BOOST_PP_LIST_FOR_EACH_I_R */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_LIST_FOR_EACH_I_R(r, macro, data, list) BOOST_PP_FOR_ ## r((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) +# else +# define BOOST_PP_LIST_FOR_EACH_I_R(r, macro, data, list) BOOST_PP_LIST_FOR_EACH_I_R_I(r, macro, data, list) +# define BOOST_PP_LIST_FOR_EACH_I_R_I(r, macro, data, list) BOOST_PP_FOR_ ## r((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) +# endif +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/logical/and.hpp b/deal.II/contrib/boost/include/boost/preprocessor/logical/and.hpp new file mode 100644 index 0000000000..61bf381347 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/logical/and.hpp @@ -0,0 +1,31 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LOGICAL_AND_HPP +# define BOOST_PREPROCESSOR_LOGICAL_AND_HPP +# +# include +# include +# include +# +# /* BOOST_PP_AND */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_AND(p, q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) +# else +# define BOOST_PP_AND(p, q) BOOST_PP_AND_I(p, q) +# define BOOST_PP_AND_I(p, q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) +# endif +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/logical/bitand.hpp b/deal.II/contrib/boost/include/boost/preprocessor/logical/bitand.hpp new file mode 100644 index 0000000000..c6eeae3b3c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/logical/bitand.hpp @@ -0,0 +1,39 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LOGICAL_BITAND_HPP +# define BOOST_PREPROCESSOR_LOGICAL_BITAND_HPP +# +# include +# +# /* BOOST_PP_BITAND */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_BITAND(x, y) BOOST_PP_BITAND_I(x, y) +# else +# define BOOST_PP_BITAND(x, y) BOOST_PP_BITAND_OO((x, y)) +# define BOOST_PP_BITAND_OO(par) BOOST_PP_BITAND_I ## par +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_BITAND_I(x, y) BOOST_PP_BITAND_ ## x ## y +# else +# define BOOST_PP_BITAND_I(x, y) BOOST_PP_BITAND_ID(BOOST_PP_BITAND_ ## x ## y) +# define BOOST_PP_BITAND_ID(res) res +# endif +# +# define BOOST_PP_BITAND_00 0 +# define BOOST_PP_BITAND_01 0 +# define BOOST_PP_BITAND_10 0 +# define BOOST_PP_BITAND_11 1 +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/logical/bool.hpp b/deal.II/contrib/boost/include/boost/preprocessor/logical/bool.hpp new file mode 100644 index 0000000000..a20736c25a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/logical/bool.hpp @@ -0,0 +1,289 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LOGICAL_BOOL_HPP +# define BOOST_PREPROCESSOR_LOGICAL_BOOL_HPP +# +# include +# +# /* BOOST_PP_BOOL */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_BOOL(x) BOOST_PP_BOOL_I(x) +# else +# define BOOST_PP_BOOL(x) BOOST_PP_BOOL_OO((x)) +# define BOOST_PP_BOOL_OO(par) BOOST_PP_BOOL_I ## par +# endif +# +# define BOOST_PP_BOOL_I(x) BOOST_PP_BOOL_ ## x +# +# define BOOST_PP_BOOL_0 0 +# define BOOST_PP_BOOL_1 1 +# define BOOST_PP_BOOL_2 1 +# define BOOST_PP_BOOL_3 1 +# define BOOST_PP_BOOL_4 1 +# define BOOST_PP_BOOL_5 1 +# define BOOST_PP_BOOL_6 1 +# define BOOST_PP_BOOL_7 1 +# define BOOST_PP_BOOL_8 1 +# define BOOST_PP_BOOL_9 1 +# define BOOST_PP_BOOL_10 1 +# define BOOST_PP_BOOL_11 1 +# define BOOST_PP_BOOL_12 1 +# define BOOST_PP_BOOL_13 1 +# define BOOST_PP_BOOL_14 1 +# define BOOST_PP_BOOL_15 1 +# define BOOST_PP_BOOL_16 1 +# define BOOST_PP_BOOL_17 1 +# define BOOST_PP_BOOL_18 1 +# define BOOST_PP_BOOL_19 1 +# define BOOST_PP_BOOL_20 1 +# define BOOST_PP_BOOL_21 1 +# define BOOST_PP_BOOL_22 1 +# define BOOST_PP_BOOL_23 1 +# define BOOST_PP_BOOL_24 1 +# define BOOST_PP_BOOL_25 1 +# define BOOST_PP_BOOL_26 1 +# define BOOST_PP_BOOL_27 1 +# define BOOST_PP_BOOL_28 1 +# define BOOST_PP_BOOL_29 1 +# define BOOST_PP_BOOL_30 1 +# define BOOST_PP_BOOL_31 1 +# define BOOST_PP_BOOL_32 1 +# define BOOST_PP_BOOL_33 1 +# define BOOST_PP_BOOL_34 1 +# define BOOST_PP_BOOL_35 1 +# define BOOST_PP_BOOL_36 1 +# define BOOST_PP_BOOL_37 1 +# define BOOST_PP_BOOL_38 1 +# define BOOST_PP_BOOL_39 1 +# define BOOST_PP_BOOL_40 1 +# define BOOST_PP_BOOL_41 1 +# define BOOST_PP_BOOL_42 1 +# define BOOST_PP_BOOL_43 1 +# define BOOST_PP_BOOL_44 1 +# define BOOST_PP_BOOL_45 1 +# define BOOST_PP_BOOL_46 1 +# define BOOST_PP_BOOL_47 1 +# define BOOST_PP_BOOL_48 1 +# define BOOST_PP_BOOL_49 1 +# define BOOST_PP_BOOL_50 1 +# define BOOST_PP_BOOL_51 1 +# define BOOST_PP_BOOL_52 1 +# define BOOST_PP_BOOL_53 1 +# define BOOST_PP_BOOL_54 1 +# define BOOST_PP_BOOL_55 1 +# define BOOST_PP_BOOL_56 1 +# define BOOST_PP_BOOL_57 1 +# define BOOST_PP_BOOL_58 1 +# define BOOST_PP_BOOL_59 1 +# define BOOST_PP_BOOL_60 1 +# define BOOST_PP_BOOL_61 1 +# define BOOST_PP_BOOL_62 1 +# define BOOST_PP_BOOL_63 1 +# define BOOST_PP_BOOL_64 1 +# define BOOST_PP_BOOL_65 1 +# define BOOST_PP_BOOL_66 1 +# define BOOST_PP_BOOL_67 1 +# define BOOST_PP_BOOL_68 1 +# define BOOST_PP_BOOL_69 1 +# define BOOST_PP_BOOL_70 1 +# define BOOST_PP_BOOL_71 1 +# define BOOST_PP_BOOL_72 1 +# define BOOST_PP_BOOL_73 1 +# define BOOST_PP_BOOL_74 1 +# define BOOST_PP_BOOL_75 1 +# define BOOST_PP_BOOL_76 1 +# define BOOST_PP_BOOL_77 1 +# define BOOST_PP_BOOL_78 1 +# define BOOST_PP_BOOL_79 1 +# define BOOST_PP_BOOL_80 1 +# define BOOST_PP_BOOL_81 1 +# define BOOST_PP_BOOL_82 1 +# define BOOST_PP_BOOL_83 1 +# define BOOST_PP_BOOL_84 1 +# define BOOST_PP_BOOL_85 1 +# define BOOST_PP_BOOL_86 1 +# define BOOST_PP_BOOL_87 1 +# define BOOST_PP_BOOL_88 1 +# define BOOST_PP_BOOL_89 1 +# define BOOST_PP_BOOL_90 1 +# define BOOST_PP_BOOL_91 1 +# define BOOST_PP_BOOL_92 1 +# define BOOST_PP_BOOL_93 1 +# define BOOST_PP_BOOL_94 1 +# define BOOST_PP_BOOL_95 1 +# define BOOST_PP_BOOL_96 1 +# define BOOST_PP_BOOL_97 1 +# define BOOST_PP_BOOL_98 1 +# define BOOST_PP_BOOL_99 1 +# define BOOST_PP_BOOL_100 1 +# define BOOST_PP_BOOL_101 1 +# define BOOST_PP_BOOL_102 1 +# define BOOST_PP_BOOL_103 1 +# define BOOST_PP_BOOL_104 1 +# define BOOST_PP_BOOL_105 1 +# define BOOST_PP_BOOL_106 1 +# define BOOST_PP_BOOL_107 1 +# define BOOST_PP_BOOL_108 1 +# define BOOST_PP_BOOL_109 1 +# define BOOST_PP_BOOL_110 1 +# define BOOST_PP_BOOL_111 1 +# define BOOST_PP_BOOL_112 1 +# define BOOST_PP_BOOL_113 1 +# define BOOST_PP_BOOL_114 1 +# define BOOST_PP_BOOL_115 1 +# define BOOST_PP_BOOL_116 1 +# define BOOST_PP_BOOL_117 1 +# define BOOST_PP_BOOL_118 1 +# define BOOST_PP_BOOL_119 1 +# define BOOST_PP_BOOL_120 1 +# define BOOST_PP_BOOL_121 1 +# define BOOST_PP_BOOL_122 1 +# define BOOST_PP_BOOL_123 1 +# define BOOST_PP_BOOL_124 1 +# define BOOST_PP_BOOL_125 1 +# define BOOST_PP_BOOL_126 1 +# define BOOST_PP_BOOL_127 1 +# define BOOST_PP_BOOL_128 1 +# define BOOST_PP_BOOL_129 1 +# define BOOST_PP_BOOL_130 1 +# define BOOST_PP_BOOL_131 1 +# define BOOST_PP_BOOL_132 1 +# define BOOST_PP_BOOL_133 1 +# define BOOST_PP_BOOL_134 1 +# define BOOST_PP_BOOL_135 1 +# define BOOST_PP_BOOL_136 1 +# define BOOST_PP_BOOL_137 1 +# define BOOST_PP_BOOL_138 1 +# define BOOST_PP_BOOL_139 1 +# define BOOST_PP_BOOL_140 1 +# define BOOST_PP_BOOL_141 1 +# define BOOST_PP_BOOL_142 1 +# define BOOST_PP_BOOL_143 1 +# define BOOST_PP_BOOL_144 1 +# define BOOST_PP_BOOL_145 1 +# define BOOST_PP_BOOL_146 1 +# define BOOST_PP_BOOL_147 1 +# define BOOST_PP_BOOL_148 1 +# define BOOST_PP_BOOL_149 1 +# define BOOST_PP_BOOL_150 1 +# define BOOST_PP_BOOL_151 1 +# define BOOST_PP_BOOL_152 1 +# define BOOST_PP_BOOL_153 1 +# define BOOST_PP_BOOL_154 1 +# define BOOST_PP_BOOL_155 1 +# define BOOST_PP_BOOL_156 1 +# define BOOST_PP_BOOL_157 1 +# define BOOST_PP_BOOL_158 1 +# define BOOST_PP_BOOL_159 1 +# define BOOST_PP_BOOL_160 1 +# define BOOST_PP_BOOL_161 1 +# define BOOST_PP_BOOL_162 1 +# define BOOST_PP_BOOL_163 1 +# define BOOST_PP_BOOL_164 1 +# define BOOST_PP_BOOL_165 1 +# define BOOST_PP_BOOL_166 1 +# define BOOST_PP_BOOL_167 1 +# define BOOST_PP_BOOL_168 1 +# define BOOST_PP_BOOL_169 1 +# define BOOST_PP_BOOL_170 1 +# define BOOST_PP_BOOL_171 1 +# define BOOST_PP_BOOL_172 1 +# define BOOST_PP_BOOL_173 1 +# define BOOST_PP_BOOL_174 1 +# define BOOST_PP_BOOL_175 1 +# define BOOST_PP_BOOL_176 1 +# define BOOST_PP_BOOL_177 1 +# define BOOST_PP_BOOL_178 1 +# define BOOST_PP_BOOL_179 1 +# define BOOST_PP_BOOL_180 1 +# define BOOST_PP_BOOL_181 1 +# define BOOST_PP_BOOL_182 1 +# define BOOST_PP_BOOL_183 1 +# define BOOST_PP_BOOL_184 1 +# define BOOST_PP_BOOL_185 1 +# define BOOST_PP_BOOL_186 1 +# define BOOST_PP_BOOL_187 1 +# define BOOST_PP_BOOL_188 1 +# define BOOST_PP_BOOL_189 1 +# define BOOST_PP_BOOL_190 1 +# define BOOST_PP_BOOL_191 1 +# define BOOST_PP_BOOL_192 1 +# define BOOST_PP_BOOL_193 1 +# define BOOST_PP_BOOL_194 1 +# define BOOST_PP_BOOL_195 1 +# define BOOST_PP_BOOL_196 1 +# define BOOST_PP_BOOL_197 1 +# define BOOST_PP_BOOL_198 1 +# define BOOST_PP_BOOL_199 1 +# define BOOST_PP_BOOL_200 1 +# define BOOST_PP_BOOL_201 1 +# define BOOST_PP_BOOL_202 1 +# define BOOST_PP_BOOL_203 1 +# define BOOST_PP_BOOL_204 1 +# define BOOST_PP_BOOL_205 1 +# define BOOST_PP_BOOL_206 1 +# define BOOST_PP_BOOL_207 1 +# define BOOST_PP_BOOL_208 1 +# define BOOST_PP_BOOL_209 1 +# define BOOST_PP_BOOL_210 1 +# define BOOST_PP_BOOL_211 1 +# define BOOST_PP_BOOL_212 1 +# define BOOST_PP_BOOL_213 1 +# define BOOST_PP_BOOL_214 1 +# define BOOST_PP_BOOL_215 1 +# define BOOST_PP_BOOL_216 1 +# define BOOST_PP_BOOL_217 1 +# define BOOST_PP_BOOL_218 1 +# define BOOST_PP_BOOL_219 1 +# define BOOST_PP_BOOL_220 1 +# define BOOST_PP_BOOL_221 1 +# define BOOST_PP_BOOL_222 1 +# define BOOST_PP_BOOL_223 1 +# define BOOST_PP_BOOL_224 1 +# define BOOST_PP_BOOL_225 1 +# define BOOST_PP_BOOL_226 1 +# define BOOST_PP_BOOL_227 1 +# define BOOST_PP_BOOL_228 1 +# define BOOST_PP_BOOL_229 1 +# define BOOST_PP_BOOL_230 1 +# define BOOST_PP_BOOL_231 1 +# define BOOST_PP_BOOL_232 1 +# define BOOST_PP_BOOL_233 1 +# define BOOST_PP_BOOL_234 1 +# define BOOST_PP_BOOL_235 1 +# define BOOST_PP_BOOL_236 1 +# define BOOST_PP_BOOL_237 1 +# define BOOST_PP_BOOL_238 1 +# define BOOST_PP_BOOL_239 1 +# define BOOST_PP_BOOL_240 1 +# define BOOST_PP_BOOL_241 1 +# define BOOST_PP_BOOL_242 1 +# define BOOST_PP_BOOL_243 1 +# define BOOST_PP_BOOL_244 1 +# define BOOST_PP_BOOL_245 1 +# define BOOST_PP_BOOL_246 1 +# define BOOST_PP_BOOL_247 1 +# define BOOST_PP_BOOL_248 1 +# define BOOST_PP_BOOL_249 1 +# define BOOST_PP_BOOL_250 1 +# define BOOST_PP_BOOL_251 1 +# define BOOST_PP_BOOL_252 1 +# define BOOST_PP_BOOL_253 1 +# define BOOST_PP_BOOL_254 1 +# define BOOST_PP_BOOL_255 1 +# define BOOST_PP_BOOL_256 1 +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/logical/compl.hpp b/deal.II/contrib/boost/include/boost/preprocessor/logical/compl.hpp new file mode 100644 index 0000000000..acf6b87953 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/logical/compl.hpp @@ -0,0 +1,37 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP +# define BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP +# +# include +# +# /* BOOST_PP_COMPL */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_COMPL(x) BOOST_PP_COMPL_I(x) +# else +# define BOOST_PP_COMPL(x) BOOST_PP_COMPL_OO((x)) +# define BOOST_PP_COMPL_OO(par) BOOST_PP_COMPL_I ## par +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ ## x +# else +# define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ID(BOOST_PP_COMPL_ ## x) +# define BOOST_PP_COMPL_ID(id) id +# endif +# +# define BOOST_PP_COMPL_0 1 +# define BOOST_PP_COMPL_1 0 +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/punctuation/comma.hpp b/deal.II/contrib/boost/include/boost/preprocessor/punctuation/comma.hpp new file mode 100644 index 0000000000..e6acfb57d8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/punctuation/comma.hpp @@ -0,0 +1,22 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP +# define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP +# +# /* BOOST_PP_COMMA */ +# +# define BOOST_PP_COMMA() , +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/punctuation/comma_if.hpp b/deal.II/contrib/boost/include/boost/preprocessor/punctuation/comma_if.hpp new file mode 100644 index 0000000000..7db8b3699c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/punctuation/comma_if.hpp @@ -0,0 +1,32 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP +# define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP +# +# include +# include +# include +# include +# +# /* BOOST_PP_COMMA_IF */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_COMMA_IF(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)() +# else +# define BOOST_PP_COMMA_IF(cond) BOOST_PP_COMMA_IF_I(cond) +# define BOOST_PP_COMMA_IF_I(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)() +# endif +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/repetition/detail/for.hpp b/deal.II/contrib/boost/include/boost/preprocessor/repetition/detail/for.hpp new file mode 100644 index 0000000000..f517ab0566 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/repetition/detail/for.hpp @@ -0,0 +1,537 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_REPETITION_DETAIL_FOR_HPP +# define BOOST_PREPROCESSOR_REPETITION_DETAIL_FOR_HPP +# +# include +# include +# include +# include +# +# define BOOST_PP_FOR_1(s, p, o, m) BOOST_PP_FOR_1_C(BOOST_PP_BOOL(p(2, s)), s, p, o, m) +# define BOOST_PP_FOR_2(s, p, o, m) BOOST_PP_FOR_2_C(BOOST_PP_BOOL(p(3, s)), s, p, o, m) +# define BOOST_PP_FOR_3(s, p, o, m) BOOST_PP_FOR_3_C(BOOST_PP_BOOL(p(4, s)), s, p, o, m) +# define BOOST_PP_FOR_4(s, p, o, m) BOOST_PP_FOR_4_C(BOOST_PP_BOOL(p(5, s)), s, p, o, m) +# define BOOST_PP_FOR_5(s, p, o, m) BOOST_PP_FOR_5_C(BOOST_PP_BOOL(p(6, s)), s, p, o, m) +# define BOOST_PP_FOR_6(s, p, o, m) BOOST_PP_FOR_6_C(BOOST_PP_BOOL(p(7, s)), s, p, o, m) +# define BOOST_PP_FOR_7(s, p, o, m) BOOST_PP_FOR_7_C(BOOST_PP_BOOL(p(8, s)), s, p, o, m) +# define BOOST_PP_FOR_8(s, p, o, m) BOOST_PP_FOR_8_C(BOOST_PP_BOOL(p(9, s)), s, p, o, m) +# define BOOST_PP_FOR_9(s, p, o, m) BOOST_PP_FOR_9_C(BOOST_PP_BOOL(p(10, s)), s, p, o, m) +# define BOOST_PP_FOR_10(s, p, o, m) BOOST_PP_FOR_10_C(BOOST_PP_BOOL(p(11, s)), s, p, o, m) +# define BOOST_PP_FOR_11(s, p, o, m) BOOST_PP_FOR_11_C(BOOST_PP_BOOL(p(12, s)), s, p, o, m) +# define BOOST_PP_FOR_12(s, p, o, m) BOOST_PP_FOR_12_C(BOOST_PP_BOOL(p(13, s)), s, p, o, m) +# define BOOST_PP_FOR_13(s, p, o, m) BOOST_PP_FOR_13_C(BOOST_PP_BOOL(p(14, s)), s, p, o, m) +# define BOOST_PP_FOR_14(s, p, o, m) BOOST_PP_FOR_14_C(BOOST_PP_BOOL(p(15, s)), s, p, o, m) +# define BOOST_PP_FOR_15(s, p, o, m) BOOST_PP_FOR_15_C(BOOST_PP_BOOL(p(16, s)), s, p, o, m) +# define BOOST_PP_FOR_16(s, p, o, m) BOOST_PP_FOR_16_C(BOOST_PP_BOOL(p(17, s)), s, p, o, m) +# define BOOST_PP_FOR_17(s, p, o, m) BOOST_PP_FOR_17_C(BOOST_PP_BOOL(p(18, s)), s, p, o, m) +# define BOOST_PP_FOR_18(s, p, o, m) BOOST_PP_FOR_18_C(BOOST_PP_BOOL(p(19, s)), s, p, o, m) +# define BOOST_PP_FOR_19(s, p, o, m) BOOST_PP_FOR_19_C(BOOST_PP_BOOL(p(20, s)), s, p, o, m) +# define BOOST_PP_FOR_20(s, p, o, m) BOOST_PP_FOR_20_C(BOOST_PP_BOOL(p(21, s)), s, p, o, m) +# define BOOST_PP_FOR_21(s, p, o, m) BOOST_PP_FOR_21_C(BOOST_PP_BOOL(p(22, s)), s, p, o, m) +# define BOOST_PP_FOR_22(s, p, o, m) BOOST_PP_FOR_22_C(BOOST_PP_BOOL(p(23, s)), s, p, o, m) +# define BOOST_PP_FOR_23(s, p, o, m) BOOST_PP_FOR_23_C(BOOST_PP_BOOL(p(24, s)), s, p, o, m) +# define BOOST_PP_FOR_24(s, p, o, m) BOOST_PP_FOR_24_C(BOOST_PP_BOOL(p(25, s)), s, p, o, m) +# define BOOST_PP_FOR_25(s, p, o, m) BOOST_PP_FOR_25_C(BOOST_PP_BOOL(p(26, s)), s, p, o, m) +# define BOOST_PP_FOR_26(s, p, o, m) BOOST_PP_FOR_26_C(BOOST_PP_BOOL(p(27, s)), s, p, o, m) +# define BOOST_PP_FOR_27(s, p, o, m) BOOST_PP_FOR_27_C(BOOST_PP_BOOL(p(28, s)), s, p, o, m) +# define BOOST_PP_FOR_28(s, p, o, m) BOOST_PP_FOR_28_C(BOOST_PP_BOOL(p(29, s)), s, p, o, m) +# define BOOST_PP_FOR_29(s, p, o, m) BOOST_PP_FOR_29_C(BOOST_PP_BOOL(p(30, s)), s, p, o, m) +# define BOOST_PP_FOR_30(s, p, o, m) BOOST_PP_FOR_30_C(BOOST_PP_BOOL(p(31, s)), s, p, o, m) +# define BOOST_PP_FOR_31(s, p, o, m) BOOST_PP_FOR_31_C(BOOST_PP_BOOL(p(32, s)), s, p, o, m) +# define BOOST_PP_FOR_32(s, p, o, m) BOOST_PP_FOR_32_C(BOOST_PP_BOOL(p(33, s)), s, p, o, m) +# define BOOST_PP_FOR_33(s, p, o, m) BOOST_PP_FOR_33_C(BOOST_PP_BOOL(p(34, s)), s, p, o, m) +# define BOOST_PP_FOR_34(s, p, o, m) BOOST_PP_FOR_34_C(BOOST_PP_BOOL(p(35, s)), s, p, o, m) +# define BOOST_PP_FOR_35(s, p, o, m) BOOST_PP_FOR_35_C(BOOST_PP_BOOL(p(36, s)), s, p, o, m) +# define BOOST_PP_FOR_36(s, p, o, m) BOOST_PP_FOR_36_C(BOOST_PP_BOOL(p(37, s)), s, p, o, m) +# define BOOST_PP_FOR_37(s, p, o, m) BOOST_PP_FOR_37_C(BOOST_PP_BOOL(p(38, s)), s, p, o, m) +# define BOOST_PP_FOR_38(s, p, o, m) BOOST_PP_FOR_38_C(BOOST_PP_BOOL(p(39, s)), s, p, o, m) +# define BOOST_PP_FOR_39(s, p, o, m) BOOST_PP_FOR_39_C(BOOST_PP_BOOL(p(40, s)), s, p, o, m) +# define BOOST_PP_FOR_40(s, p, o, m) BOOST_PP_FOR_40_C(BOOST_PP_BOOL(p(41, s)), s, p, o, m) +# define BOOST_PP_FOR_41(s, p, o, m) BOOST_PP_FOR_41_C(BOOST_PP_BOOL(p(42, s)), s, p, o, m) +# define BOOST_PP_FOR_42(s, p, o, m) BOOST_PP_FOR_42_C(BOOST_PP_BOOL(p(43, s)), s, p, o, m) +# define BOOST_PP_FOR_43(s, p, o, m) BOOST_PP_FOR_43_C(BOOST_PP_BOOL(p(44, s)), s, p, o, m) +# define BOOST_PP_FOR_44(s, p, o, m) BOOST_PP_FOR_44_C(BOOST_PP_BOOL(p(45, s)), s, p, o, m) +# define BOOST_PP_FOR_45(s, p, o, m) BOOST_PP_FOR_45_C(BOOST_PP_BOOL(p(46, s)), s, p, o, m) +# define BOOST_PP_FOR_46(s, p, o, m) BOOST_PP_FOR_46_C(BOOST_PP_BOOL(p(47, s)), s, p, o, m) +# define BOOST_PP_FOR_47(s, p, o, m) BOOST_PP_FOR_47_C(BOOST_PP_BOOL(p(48, s)), s, p, o, m) +# define BOOST_PP_FOR_48(s, p, o, m) BOOST_PP_FOR_48_C(BOOST_PP_BOOL(p(49, s)), s, p, o, m) +# define BOOST_PP_FOR_49(s, p, o, m) BOOST_PP_FOR_49_C(BOOST_PP_BOOL(p(50, s)), s, p, o, m) +# define BOOST_PP_FOR_50(s, p, o, m) BOOST_PP_FOR_50_C(BOOST_PP_BOOL(p(51, s)), s, p, o, m) +# define BOOST_PP_FOR_51(s, p, o, m) BOOST_PP_FOR_51_C(BOOST_PP_BOOL(p(52, s)), s, p, o, m) +# define BOOST_PP_FOR_52(s, p, o, m) BOOST_PP_FOR_52_C(BOOST_PP_BOOL(p(53, s)), s, p, o, m) +# define BOOST_PP_FOR_53(s, p, o, m) BOOST_PP_FOR_53_C(BOOST_PP_BOOL(p(54, s)), s, p, o, m) +# define BOOST_PP_FOR_54(s, p, o, m) BOOST_PP_FOR_54_C(BOOST_PP_BOOL(p(55, s)), s, p, o, m) +# define BOOST_PP_FOR_55(s, p, o, m) BOOST_PP_FOR_55_C(BOOST_PP_BOOL(p(56, s)), s, p, o, m) +# define BOOST_PP_FOR_56(s, p, o, m) BOOST_PP_FOR_56_C(BOOST_PP_BOOL(p(57, s)), s, p, o, m) +# define BOOST_PP_FOR_57(s, p, o, m) BOOST_PP_FOR_57_C(BOOST_PP_BOOL(p(58, s)), s, p, o, m) +# define BOOST_PP_FOR_58(s, p, o, m) BOOST_PP_FOR_58_C(BOOST_PP_BOOL(p(59, s)), s, p, o, m) +# define BOOST_PP_FOR_59(s, p, o, m) BOOST_PP_FOR_59_C(BOOST_PP_BOOL(p(60, s)), s, p, o, m) +# define BOOST_PP_FOR_60(s, p, o, m) BOOST_PP_FOR_60_C(BOOST_PP_BOOL(p(61, s)), s, p, o, m) +# define BOOST_PP_FOR_61(s, p, o, m) BOOST_PP_FOR_61_C(BOOST_PP_BOOL(p(62, s)), s, p, o, m) +# define BOOST_PP_FOR_62(s, p, o, m) BOOST_PP_FOR_62_C(BOOST_PP_BOOL(p(63, s)), s, p, o, m) +# define BOOST_PP_FOR_63(s, p, o, m) BOOST_PP_FOR_63_C(BOOST_PP_BOOL(p(64, s)), s, p, o, m) +# define BOOST_PP_FOR_64(s, p, o, m) BOOST_PP_FOR_64_C(BOOST_PP_BOOL(p(65, s)), s, p, o, m) +# define BOOST_PP_FOR_65(s, p, o, m) BOOST_PP_FOR_65_C(BOOST_PP_BOOL(p(66, s)), s, p, o, m) +# define BOOST_PP_FOR_66(s, p, o, m) BOOST_PP_FOR_66_C(BOOST_PP_BOOL(p(67, s)), s, p, o, m) +# define BOOST_PP_FOR_67(s, p, o, m) BOOST_PP_FOR_67_C(BOOST_PP_BOOL(p(68, s)), s, p, o, m) +# define BOOST_PP_FOR_68(s, p, o, m) BOOST_PP_FOR_68_C(BOOST_PP_BOOL(p(69, s)), s, p, o, m) +# define BOOST_PP_FOR_69(s, p, o, m) BOOST_PP_FOR_69_C(BOOST_PP_BOOL(p(70, s)), s, p, o, m) +# define BOOST_PP_FOR_70(s, p, o, m) BOOST_PP_FOR_70_C(BOOST_PP_BOOL(p(71, s)), s, p, o, m) +# define BOOST_PP_FOR_71(s, p, o, m) BOOST_PP_FOR_71_C(BOOST_PP_BOOL(p(72, s)), s, p, o, m) +# define BOOST_PP_FOR_72(s, p, o, m) BOOST_PP_FOR_72_C(BOOST_PP_BOOL(p(73, s)), s, p, o, m) +# define BOOST_PP_FOR_73(s, p, o, m) BOOST_PP_FOR_73_C(BOOST_PP_BOOL(p(74, s)), s, p, o, m) +# define BOOST_PP_FOR_74(s, p, o, m) BOOST_PP_FOR_74_C(BOOST_PP_BOOL(p(75, s)), s, p, o, m) +# define BOOST_PP_FOR_75(s, p, o, m) BOOST_PP_FOR_75_C(BOOST_PP_BOOL(p(76, s)), s, p, o, m) +# define BOOST_PP_FOR_76(s, p, o, m) BOOST_PP_FOR_76_C(BOOST_PP_BOOL(p(77, s)), s, p, o, m) +# define BOOST_PP_FOR_77(s, p, o, m) BOOST_PP_FOR_77_C(BOOST_PP_BOOL(p(78, s)), s, p, o, m) +# define BOOST_PP_FOR_78(s, p, o, m) BOOST_PP_FOR_78_C(BOOST_PP_BOOL(p(79, s)), s, p, o, m) +# define BOOST_PP_FOR_79(s, p, o, m) BOOST_PP_FOR_79_C(BOOST_PP_BOOL(p(80, s)), s, p, o, m) +# define BOOST_PP_FOR_80(s, p, o, m) BOOST_PP_FOR_80_C(BOOST_PP_BOOL(p(81, s)), s, p, o, m) +# define BOOST_PP_FOR_81(s, p, o, m) BOOST_PP_FOR_81_C(BOOST_PP_BOOL(p(82, s)), s, p, o, m) +# define BOOST_PP_FOR_82(s, p, o, m) BOOST_PP_FOR_82_C(BOOST_PP_BOOL(p(83, s)), s, p, o, m) +# define BOOST_PP_FOR_83(s, p, o, m) BOOST_PP_FOR_83_C(BOOST_PP_BOOL(p(84, s)), s, p, o, m) +# define BOOST_PP_FOR_84(s, p, o, m) BOOST_PP_FOR_84_C(BOOST_PP_BOOL(p(85, s)), s, p, o, m) +# define BOOST_PP_FOR_85(s, p, o, m) BOOST_PP_FOR_85_C(BOOST_PP_BOOL(p(86, s)), s, p, o, m) +# define BOOST_PP_FOR_86(s, p, o, m) BOOST_PP_FOR_86_C(BOOST_PP_BOOL(p(87, s)), s, p, o, m) +# define BOOST_PP_FOR_87(s, p, o, m) BOOST_PP_FOR_87_C(BOOST_PP_BOOL(p(88, s)), s, p, o, m) +# define BOOST_PP_FOR_88(s, p, o, m) BOOST_PP_FOR_88_C(BOOST_PP_BOOL(p(89, s)), s, p, o, m) +# define BOOST_PP_FOR_89(s, p, o, m) BOOST_PP_FOR_89_C(BOOST_PP_BOOL(p(90, s)), s, p, o, m) +# define BOOST_PP_FOR_90(s, p, o, m) BOOST_PP_FOR_90_C(BOOST_PP_BOOL(p(91, s)), s, p, o, m) +# define BOOST_PP_FOR_91(s, p, o, m) BOOST_PP_FOR_91_C(BOOST_PP_BOOL(p(92, s)), s, p, o, m) +# define BOOST_PP_FOR_92(s, p, o, m) BOOST_PP_FOR_92_C(BOOST_PP_BOOL(p(93, s)), s, p, o, m) +# define BOOST_PP_FOR_93(s, p, o, m) BOOST_PP_FOR_93_C(BOOST_PP_BOOL(p(94, s)), s, p, o, m) +# define BOOST_PP_FOR_94(s, p, o, m) BOOST_PP_FOR_94_C(BOOST_PP_BOOL(p(95, s)), s, p, o, m) +# define BOOST_PP_FOR_95(s, p, o, m) BOOST_PP_FOR_95_C(BOOST_PP_BOOL(p(96, s)), s, p, o, m) +# define BOOST_PP_FOR_96(s, p, o, m) BOOST_PP_FOR_96_C(BOOST_PP_BOOL(p(97, s)), s, p, o, m) +# define BOOST_PP_FOR_97(s, p, o, m) BOOST_PP_FOR_97_C(BOOST_PP_BOOL(p(98, s)), s, p, o, m) +# define BOOST_PP_FOR_98(s, p, o, m) BOOST_PP_FOR_98_C(BOOST_PP_BOOL(p(99, s)), s, p, o, m) +# define BOOST_PP_FOR_99(s, p, o, m) BOOST_PP_FOR_99_C(BOOST_PP_BOOL(p(100, s)), s, p, o, m) +# define BOOST_PP_FOR_100(s, p, o, m) BOOST_PP_FOR_100_C(BOOST_PP_BOOL(p(101, s)), s, p, o, m) +# define BOOST_PP_FOR_101(s, p, o, m) BOOST_PP_FOR_101_C(BOOST_PP_BOOL(p(102, s)), s, p, o, m) +# define BOOST_PP_FOR_102(s, p, o, m) BOOST_PP_FOR_102_C(BOOST_PP_BOOL(p(103, s)), s, p, o, m) +# define BOOST_PP_FOR_103(s, p, o, m) BOOST_PP_FOR_103_C(BOOST_PP_BOOL(p(104, s)), s, p, o, m) +# define BOOST_PP_FOR_104(s, p, o, m) BOOST_PP_FOR_104_C(BOOST_PP_BOOL(p(105, s)), s, p, o, m) +# define BOOST_PP_FOR_105(s, p, o, m) BOOST_PP_FOR_105_C(BOOST_PP_BOOL(p(106, s)), s, p, o, m) +# define BOOST_PP_FOR_106(s, p, o, m) BOOST_PP_FOR_106_C(BOOST_PP_BOOL(p(107, s)), s, p, o, m) +# define BOOST_PP_FOR_107(s, p, o, m) BOOST_PP_FOR_107_C(BOOST_PP_BOOL(p(108, s)), s, p, o, m) +# define BOOST_PP_FOR_108(s, p, o, m) BOOST_PP_FOR_108_C(BOOST_PP_BOOL(p(109, s)), s, p, o, m) +# define BOOST_PP_FOR_109(s, p, o, m) BOOST_PP_FOR_109_C(BOOST_PP_BOOL(p(110, s)), s, p, o, m) +# define BOOST_PP_FOR_110(s, p, o, m) BOOST_PP_FOR_110_C(BOOST_PP_BOOL(p(111, s)), s, p, o, m) +# define BOOST_PP_FOR_111(s, p, o, m) BOOST_PP_FOR_111_C(BOOST_PP_BOOL(p(112, s)), s, p, o, m) +# define BOOST_PP_FOR_112(s, p, o, m) BOOST_PP_FOR_112_C(BOOST_PP_BOOL(p(113, s)), s, p, o, m) +# define BOOST_PP_FOR_113(s, p, o, m) BOOST_PP_FOR_113_C(BOOST_PP_BOOL(p(114, s)), s, p, o, m) +# define BOOST_PP_FOR_114(s, p, o, m) BOOST_PP_FOR_114_C(BOOST_PP_BOOL(p(115, s)), s, p, o, m) +# define BOOST_PP_FOR_115(s, p, o, m) BOOST_PP_FOR_115_C(BOOST_PP_BOOL(p(116, s)), s, p, o, m) +# define BOOST_PP_FOR_116(s, p, o, m) BOOST_PP_FOR_116_C(BOOST_PP_BOOL(p(117, s)), s, p, o, m) +# define BOOST_PP_FOR_117(s, p, o, m) BOOST_PP_FOR_117_C(BOOST_PP_BOOL(p(118, s)), s, p, o, m) +# define BOOST_PP_FOR_118(s, p, o, m) BOOST_PP_FOR_118_C(BOOST_PP_BOOL(p(119, s)), s, p, o, m) +# define BOOST_PP_FOR_119(s, p, o, m) BOOST_PP_FOR_119_C(BOOST_PP_BOOL(p(120, s)), s, p, o, m) +# define BOOST_PP_FOR_120(s, p, o, m) BOOST_PP_FOR_120_C(BOOST_PP_BOOL(p(121, s)), s, p, o, m) +# define BOOST_PP_FOR_121(s, p, o, m) BOOST_PP_FOR_121_C(BOOST_PP_BOOL(p(122, s)), s, p, o, m) +# define BOOST_PP_FOR_122(s, p, o, m) BOOST_PP_FOR_122_C(BOOST_PP_BOOL(p(123, s)), s, p, o, m) +# define BOOST_PP_FOR_123(s, p, o, m) BOOST_PP_FOR_123_C(BOOST_PP_BOOL(p(124, s)), s, p, o, m) +# define BOOST_PP_FOR_124(s, p, o, m) BOOST_PP_FOR_124_C(BOOST_PP_BOOL(p(125, s)), s, p, o, m) +# define BOOST_PP_FOR_125(s, p, o, m) BOOST_PP_FOR_125_C(BOOST_PP_BOOL(p(126, s)), s, p, o, m) +# define BOOST_PP_FOR_126(s, p, o, m) BOOST_PP_FOR_126_C(BOOST_PP_BOOL(p(127, s)), s, p, o, m) +# define BOOST_PP_FOR_127(s, p, o, m) BOOST_PP_FOR_127_C(BOOST_PP_BOOL(p(128, s)), s, p, o, m) +# define BOOST_PP_FOR_128(s, p, o, m) BOOST_PP_FOR_128_C(BOOST_PP_BOOL(p(129, s)), s, p, o, m) +# define BOOST_PP_FOR_129(s, p, o, m) BOOST_PP_FOR_129_C(BOOST_PP_BOOL(p(130, s)), s, p, o, m) +# define BOOST_PP_FOR_130(s, p, o, m) BOOST_PP_FOR_130_C(BOOST_PP_BOOL(p(131, s)), s, p, o, m) +# define BOOST_PP_FOR_131(s, p, o, m) BOOST_PP_FOR_131_C(BOOST_PP_BOOL(p(132, s)), s, p, o, m) +# define BOOST_PP_FOR_132(s, p, o, m) BOOST_PP_FOR_132_C(BOOST_PP_BOOL(p(133, s)), s, p, o, m) +# define BOOST_PP_FOR_133(s, p, o, m) BOOST_PP_FOR_133_C(BOOST_PP_BOOL(p(134, s)), s, p, o, m) +# define BOOST_PP_FOR_134(s, p, o, m) BOOST_PP_FOR_134_C(BOOST_PP_BOOL(p(135, s)), s, p, o, m) +# define BOOST_PP_FOR_135(s, p, o, m) BOOST_PP_FOR_135_C(BOOST_PP_BOOL(p(136, s)), s, p, o, m) +# define BOOST_PP_FOR_136(s, p, o, m) BOOST_PP_FOR_136_C(BOOST_PP_BOOL(p(137, s)), s, p, o, m) +# define BOOST_PP_FOR_137(s, p, o, m) BOOST_PP_FOR_137_C(BOOST_PP_BOOL(p(138, s)), s, p, o, m) +# define BOOST_PP_FOR_138(s, p, o, m) BOOST_PP_FOR_138_C(BOOST_PP_BOOL(p(139, s)), s, p, o, m) +# define BOOST_PP_FOR_139(s, p, o, m) BOOST_PP_FOR_139_C(BOOST_PP_BOOL(p(140, s)), s, p, o, m) +# define BOOST_PP_FOR_140(s, p, o, m) BOOST_PP_FOR_140_C(BOOST_PP_BOOL(p(141, s)), s, p, o, m) +# define BOOST_PP_FOR_141(s, p, o, m) BOOST_PP_FOR_141_C(BOOST_PP_BOOL(p(142, s)), s, p, o, m) +# define BOOST_PP_FOR_142(s, p, o, m) BOOST_PP_FOR_142_C(BOOST_PP_BOOL(p(143, s)), s, p, o, m) +# define BOOST_PP_FOR_143(s, p, o, m) BOOST_PP_FOR_143_C(BOOST_PP_BOOL(p(144, s)), s, p, o, m) +# define BOOST_PP_FOR_144(s, p, o, m) BOOST_PP_FOR_144_C(BOOST_PP_BOOL(p(145, s)), s, p, o, m) +# define BOOST_PP_FOR_145(s, p, o, m) BOOST_PP_FOR_145_C(BOOST_PP_BOOL(p(146, s)), s, p, o, m) +# define BOOST_PP_FOR_146(s, p, o, m) BOOST_PP_FOR_146_C(BOOST_PP_BOOL(p(147, s)), s, p, o, m) +# define BOOST_PP_FOR_147(s, p, o, m) BOOST_PP_FOR_147_C(BOOST_PP_BOOL(p(148, s)), s, p, o, m) +# define BOOST_PP_FOR_148(s, p, o, m) BOOST_PP_FOR_148_C(BOOST_PP_BOOL(p(149, s)), s, p, o, m) +# define BOOST_PP_FOR_149(s, p, o, m) BOOST_PP_FOR_149_C(BOOST_PP_BOOL(p(150, s)), s, p, o, m) +# define BOOST_PP_FOR_150(s, p, o, m) BOOST_PP_FOR_150_C(BOOST_PP_BOOL(p(151, s)), s, p, o, m) +# define BOOST_PP_FOR_151(s, p, o, m) BOOST_PP_FOR_151_C(BOOST_PP_BOOL(p(152, s)), s, p, o, m) +# define BOOST_PP_FOR_152(s, p, o, m) BOOST_PP_FOR_152_C(BOOST_PP_BOOL(p(153, s)), s, p, o, m) +# define BOOST_PP_FOR_153(s, p, o, m) BOOST_PP_FOR_153_C(BOOST_PP_BOOL(p(154, s)), s, p, o, m) +# define BOOST_PP_FOR_154(s, p, o, m) BOOST_PP_FOR_154_C(BOOST_PP_BOOL(p(155, s)), s, p, o, m) +# define BOOST_PP_FOR_155(s, p, o, m) BOOST_PP_FOR_155_C(BOOST_PP_BOOL(p(156, s)), s, p, o, m) +# define BOOST_PP_FOR_156(s, p, o, m) BOOST_PP_FOR_156_C(BOOST_PP_BOOL(p(157, s)), s, p, o, m) +# define BOOST_PP_FOR_157(s, p, o, m) BOOST_PP_FOR_157_C(BOOST_PP_BOOL(p(158, s)), s, p, o, m) +# define BOOST_PP_FOR_158(s, p, o, m) BOOST_PP_FOR_158_C(BOOST_PP_BOOL(p(159, s)), s, p, o, m) +# define BOOST_PP_FOR_159(s, p, o, m) BOOST_PP_FOR_159_C(BOOST_PP_BOOL(p(160, s)), s, p, o, m) +# define BOOST_PP_FOR_160(s, p, o, m) BOOST_PP_FOR_160_C(BOOST_PP_BOOL(p(161, s)), s, p, o, m) +# define BOOST_PP_FOR_161(s, p, o, m) BOOST_PP_FOR_161_C(BOOST_PP_BOOL(p(162, s)), s, p, o, m) +# define BOOST_PP_FOR_162(s, p, o, m) BOOST_PP_FOR_162_C(BOOST_PP_BOOL(p(163, s)), s, p, o, m) +# define BOOST_PP_FOR_163(s, p, o, m) BOOST_PP_FOR_163_C(BOOST_PP_BOOL(p(164, s)), s, p, o, m) +# define BOOST_PP_FOR_164(s, p, o, m) BOOST_PP_FOR_164_C(BOOST_PP_BOOL(p(165, s)), s, p, o, m) +# define BOOST_PP_FOR_165(s, p, o, m) BOOST_PP_FOR_165_C(BOOST_PP_BOOL(p(166, s)), s, p, o, m) +# define BOOST_PP_FOR_166(s, p, o, m) BOOST_PP_FOR_166_C(BOOST_PP_BOOL(p(167, s)), s, p, o, m) +# define BOOST_PP_FOR_167(s, p, o, m) BOOST_PP_FOR_167_C(BOOST_PP_BOOL(p(168, s)), s, p, o, m) +# define BOOST_PP_FOR_168(s, p, o, m) BOOST_PP_FOR_168_C(BOOST_PP_BOOL(p(169, s)), s, p, o, m) +# define BOOST_PP_FOR_169(s, p, o, m) BOOST_PP_FOR_169_C(BOOST_PP_BOOL(p(170, s)), s, p, o, m) +# define BOOST_PP_FOR_170(s, p, o, m) BOOST_PP_FOR_170_C(BOOST_PP_BOOL(p(171, s)), s, p, o, m) +# define BOOST_PP_FOR_171(s, p, o, m) BOOST_PP_FOR_171_C(BOOST_PP_BOOL(p(172, s)), s, p, o, m) +# define BOOST_PP_FOR_172(s, p, o, m) BOOST_PP_FOR_172_C(BOOST_PP_BOOL(p(173, s)), s, p, o, m) +# define BOOST_PP_FOR_173(s, p, o, m) BOOST_PP_FOR_173_C(BOOST_PP_BOOL(p(174, s)), s, p, o, m) +# define BOOST_PP_FOR_174(s, p, o, m) BOOST_PP_FOR_174_C(BOOST_PP_BOOL(p(175, s)), s, p, o, m) +# define BOOST_PP_FOR_175(s, p, o, m) BOOST_PP_FOR_175_C(BOOST_PP_BOOL(p(176, s)), s, p, o, m) +# define BOOST_PP_FOR_176(s, p, o, m) BOOST_PP_FOR_176_C(BOOST_PP_BOOL(p(177, s)), s, p, o, m) +# define BOOST_PP_FOR_177(s, p, o, m) BOOST_PP_FOR_177_C(BOOST_PP_BOOL(p(178, s)), s, p, o, m) +# define BOOST_PP_FOR_178(s, p, o, m) BOOST_PP_FOR_178_C(BOOST_PP_BOOL(p(179, s)), s, p, o, m) +# define BOOST_PP_FOR_179(s, p, o, m) BOOST_PP_FOR_179_C(BOOST_PP_BOOL(p(180, s)), s, p, o, m) +# define BOOST_PP_FOR_180(s, p, o, m) BOOST_PP_FOR_180_C(BOOST_PP_BOOL(p(181, s)), s, p, o, m) +# define BOOST_PP_FOR_181(s, p, o, m) BOOST_PP_FOR_181_C(BOOST_PP_BOOL(p(182, s)), s, p, o, m) +# define BOOST_PP_FOR_182(s, p, o, m) BOOST_PP_FOR_182_C(BOOST_PP_BOOL(p(183, s)), s, p, o, m) +# define BOOST_PP_FOR_183(s, p, o, m) BOOST_PP_FOR_183_C(BOOST_PP_BOOL(p(184, s)), s, p, o, m) +# define BOOST_PP_FOR_184(s, p, o, m) BOOST_PP_FOR_184_C(BOOST_PP_BOOL(p(185, s)), s, p, o, m) +# define BOOST_PP_FOR_185(s, p, o, m) BOOST_PP_FOR_185_C(BOOST_PP_BOOL(p(186, s)), s, p, o, m) +# define BOOST_PP_FOR_186(s, p, o, m) BOOST_PP_FOR_186_C(BOOST_PP_BOOL(p(187, s)), s, p, o, m) +# define BOOST_PP_FOR_187(s, p, o, m) BOOST_PP_FOR_187_C(BOOST_PP_BOOL(p(188, s)), s, p, o, m) +# define BOOST_PP_FOR_188(s, p, o, m) BOOST_PP_FOR_188_C(BOOST_PP_BOOL(p(189, s)), s, p, o, m) +# define BOOST_PP_FOR_189(s, p, o, m) BOOST_PP_FOR_189_C(BOOST_PP_BOOL(p(190, s)), s, p, o, m) +# define BOOST_PP_FOR_190(s, p, o, m) BOOST_PP_FOR_190_C(BOOST_PP_BOOL(p(191, s)), s, p, o, m) +# define BOOST_PP_FOR_191(s, p, o, m) BOOST_PP_FOR_191_C(BOOST_PP_BOOL(p(192, s)), s, p, o, m) +# define BOOST_PP_FOR_192(s, p, o, m) BOOST_PP_FOR_192_C(BOOST_PP_BOOL(p(193, s)), s, p, o, m) +# define BOOST_PP_FOR_193(s, p, o, m) BOOST_PP_FOR_193_C(BOOST_PP_BOOL(p(194, s)), s, p, o, m) +# define BOOST_PP_FOR_194(s, p, o, m) BOOST_PP_FOR_194_C(BOOST_PP_BOOL(p(195, s)), s, p, o, m) +# define BOOST_PP_FOR_195(s, p, o, m) BOOST_PP_FOR_195_C(BOOST_PP_BOOL(p(196, s)), s, p, o, m) +# define BOOST_PP_FOR_196(s, p, o, m) BOOST_PP_FOR_196_C(BOOST_PP_BOOL(p(197, s)), s, p, o, m) +# define BOOST_PP_FOR_197(s, p, o, m) BOOST_PP_FOR_197_C(BOOST_PP_BOOL(p(198, s)), s, p, o, m) +# define BOOST_PP_FOR_198(s, p, o, m) BOOST_PP_FOR_198_C(BOOST_PP_BOOL(p(199, s)), s, p, o, m) +# define BOOST_PP_FOR_199(s, p, o, m) BOOST_PP_FOR_199_C(BOOST_PP_BOOL(p(200, s)), s, p, o, m) +# define BOOST_PP_FOR_200(s, p, o, m) BOOST_PP_FOR_200_C(BOOST_PP_BOOL(p(201, s)), s, p, o, m) +# define BOOST_PP_FOR_201(s, p, o, m) BOOST_PP_FOR_201_C(BOOST_PP_BOOL(p(202, s)), s, p, o, m) +# define BOOST_PP_FOR_202(s, p, o, m) BOOST_PP_FOR_202_C(BOOST_PP_BOOL(p(203, s)), s, p, o, m) +# define BOOST_PP_FOR_203(s, p, o, m) BOOST_PP_FOR_203_C(BOOST_PP_BOOL(p(204, s)), s, p, o, m) +# define BOOST_PP_FOR_204(s, p, o, m) BOOST_PP_FOR_204_C(BOOST_PP_BOOL(p(205, s)), s, p, o, m) +# define BOOST_PP_FOR_205(s, p, o, m) BOOST_PP_FOR_205_C(BOOST_PP_BOOL(p(206, s)), s, p, o, m) +# define BOOST_PP_FOR_206(s, p, o, m) BOOST_PP_FOR_206_C(BOOST_PP_BOOL(p(207, s)), s, p, o, m) +# define BOOST_PP_FOR_207(s, p, o, m) BOOST_PP_FOR_207_C(BOOST_PP_BOOL(p(208, s)), s, p, o, m) +# define BOOST_PP_FOR_208(s, p, o, m) BOOST_PP_FOR_208_C(BOOST_PP_BOOL(p(209, s)), s, p, o, m) +# define BOOST_PP_FOR_209(s, p, o, m) BOOST_PP_FOR_209_C(BOOST_PP_BOOL(p(210, s)), s, p, o, m) +# define BOOST_PP_FOR_210(s, p, o, m) BOOST_PP_FOR_210_C(BOOST_PP_BOOL(p(211, s)), s, p, o, m) +# define BOOST_PP_FOR_211(s, p, o, m) BOOST_PP_FOR_211_C(BOOST_PP_BOOL(p(212, s)), s, p, o, m) +# define BOOST_PP_FOR_212(s, p, o, m) BOOST_PP_FOR_212_C(BOOST_PP_BOOL(p(213, s)), s, p, o, m) +# define BOOST_PP_FOR_213(s, p, o, m) BOOST_PP_FOR_213_C(BOOST_PP_BOOL(p(214, s)), s, p, o, m) +# define BOOST_PP_FOR_214(s, p, o, m) BOOST_PP_FOR_214_C(BOOST_PP_BOOL(p(215, s)), s, p, o, m) +# define BOOST_PP_FOR_215(s, p, o, m) BOOST_PP_FOR_215_C(BOOST_PP_BOOL(p(216, s)), s, p, o, m) +# define BOOST_PP_FOR_216(s, p, o, m) BOOST_PP_FOR_216_C(BOOST_PP_BOOL(p(217, s)), s, p, o, m) +# define BOOST_PP_FOR_217(s, p, o, m) BOOST_PP_FOR_217_C(BOOST_PP_BOOL(p(218, s)), s, p, o, m) +# define BOOST_PP_FOR_218(s, p, o, m) BOOST_PP_FOR_218_C(BOOST_PP_BOOL(p(219, s)), s, p, o, m) +# define BOOST_PP_FOR_219(s, p, o, m) BOOST_PP_FOR_219_C(BOOST_PP_BOOL(p(220, s)), s, p, o, m) +# define BOOST_PP_FOR_220(s, p, o, m) BOOST_PP_FOR_220_C(BOOST_PP_BOOL(p(221, s)), s, p, o, m) +# define BOOST_PP_FOR_221(s, p, o, m) BOOST_PP_FOR_221_C(BOOST_PP_BOOL(p(222, s)), s, p, o, m) +# define BOOST_PP_FOR_222(s, p, o, m) BOOST_PP_FOR_222_C(BOOST_PP_BOOL(p(223, s)), s, p, o, m) +# define BOOST_PP_FOR_223(s, p, o, m) BOOST_PP_FOR_223_C(BOOST_PP_BOOL(p(224, s)), s, p, o, m) +# define BOOST_PP_FOR_224(s, p, o, m) BOOST_PP_FOR_224_C(BOOST_PP_BOOL(p(225, s)), s, p, o, m) +# define BOOST_PP_FOR_225(s, p, o, m) BOOST_PP_FOR_225_C(BOOST_PP_BOOL(p(226, s)), s, p, o, m) +# define BOOST_PP_FOR_226(s, p, o, m) BOOST_PP_FOR_226_C(BOOST_PP_BOOL(p(227, s)), s, p, o, m) +# define BOOST_PP_FOR_227(s, p, o, m) BOOST_PP_FOR_227_C(BOOST_PP_BOOL(p(228, s)), s, p, o, m) +# define BOOST_PP_FOR_228(s, p, o, m) BOOST_PP_FOR_228_C(BOOST_PP_BOOL(p(229, s)), s, p, o, m) +# define BOOST_PP_FOR_229(s, p, o, m) BOOST_PP_FOR_229_C(BOOST_PP_BOOL(p(230, s)), s, p, o, m) +# define BOOST_PP_FOR_230(s, p, o, m) BOOST_PP_FOR_230_C(BOOST_PP_BOOL(p(231, s)), s, p, o, m) +# define BOOST_PP_FOR_231(s, p, o, m) BOOST_PP_FOR_231_C(BOOST_PP_BOOL(p(232, s)), s, p, o, m) +# define BOOST_PP_FOR_232(s, p, o, m) BOOST_PP_FOR_232_C(BOOST_PP_BOOL(p(233, s)), s, p, o, m) +# define BOOST_PP_FOR_233(s, p, o, m) BOOST_PP_FOR_233_C(BOOST_PP_BOOL(p(234, s)), s, p, o, m) +# define BOOST_PP_FOR_234(s, p, o, m) BOOST_PP_FOR_234_C(BOOST_PP_BOOL(p(235, s)), s, p, o, m) +# define BOOST_PP_FOR_235(s, p, o, m) BOOST_PP_FOR_235_C(BOOST_PP_BOOL(p(236, s)), s, p, o, m) +# define BOOST_PP_FOR_236(s, p, o, m) BOOST_PP_FOR_236_C(BOOST_PP_BOOL(p(237, s)), s, p, o, m) +# define BOOST_PP_FOR_237(s, p, o, m) BOOST_PP_FOR_237_C(BOOST_PP_BOOL(p(238, s)), s, p, o, m) +# define BOOST_PP_FOR_238(s, p, o, m) BOOST_PP_FOR_238_C(BOOST_PP_BOOL(p(239, s)), s, p, o, m) +# define BOOST_PP_FOR_239(s, p, o, m) BOOST_PP_FOR_239_C(BOOST_PP_BOOL(p(240, s)), s, p, o, m) +# define BOOST_PP_FOR_240(s, p, o, m) BOOST_PP_FOR_240_C(BOOST_PP_BOOL(p(241, s)), s, p, o, m) +# define BOOST_PP_FOR_241(s, p, o, m) BOOST_PP_FOR_241_C(BOOST_PP_BOOL(p(242, s)), s, p, o, m) +# define BOOST_PP_FOR_242(s, p, o, m) BOOST_PP_FOR_242_C(BOOST_PP_BOOL(p(243, s)), s, p, o, m) +# define BOOST_PP_FOR_243(s, p, o, m) BOOST_PP_FOR_243_C(BOOST_PP_BOOL(p(244, s)), s, p, o, m) +# define BOOST_PP_FOR_244(s, p, o, m) BOOST_PP_FOR_244_C(BOOST_PP_BOOL(p(245, s)), s, p, o, m) +# define BOOST_PP_FOR_245(s, p, o, m) BOOST_PP_FOR_245_C(BOOST_PP_BOOL(p(246, s)), s, p, o, m) +# define BOOST_PP_FOR_246(s, p, o, m) BOOST_PP_FOR_246_C(BOOST_PP_BOOL(p(247, s)), s, p, o, m) +# define BOOST_PP_FOR_247(s, p, o, m) BOOST_PP_FOR_247_C(BOOST_PP_BOOL(p(248, s)), s, p, o, m) +# define BOOST_PP_FOR_248(s, p, o, m) BOOST_PP_FOR_248_C(BOOST_PP_BOOL(p(249, s)), s, p, o, m) +# define BOOST_PP_FOR_249(s, p, o, m) BOOST_PP_FOR_249_C(BOOST_PP_BOOL(p(250, s)), s, p, o, m) +# define BOOST_PP_FOR_250(s, p, o, m) BOOST_PP_FOR_250_C(BOOST_PP_BOOL(p(251, s)), s, p, o, m) +# define BOOST_PP_FOR_251(s, p, o, m) BOOST_PP_FOR_251_C(BOOST_PP_BOOL(p(252, s)), s, p, o, m) +# define BOOST_PP_FOR_252(s, p, o, m) BOOST_PP_FOR_252_C(BOOST_PP_BOOL(p(253, s)), s, p, o, m) +# define BOOST_PP_FOR_253(s, p, o, m) BOOST_PP_FOR_253_C(BOOST_PP_BOOL(p(254, s)), s, p, o, m) +# define BOOST_PP_FOR_254(s, p, o, m) BOOST_PP_FOR_254_C(BOOST_PP_BOOL(p(255, s)), s, p, o, m) +# define BOOST_PP_FOR_255(s, p, o, m) BOOST_PP_FOR_255_C(BOOST_PP_BOOL(p(256, s)), s, p, o, m) +# define BOOST_PP_FOR_256(s, p, o, m) BOOST_PP_FOR_256_C(BOOST_PP_BOOL(p(257, s)), s, p, o, m) +# +# define BOOST_PP_FOR_1_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(2, s) BOOST_PP_IIF(c, BOOST_PP_FOR_2, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(2, s), p, o, m) +# define BOOST_PP_FOR_2_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(3, s) BOOST_PP_IIF(c, BOOST_PP_FOR_3, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(3, s), p, o, m) +# define BOOST_PP_FOR_3_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(4, s) BOOST_PP_IIF(c, BOOST_PP_FOR_4, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(4, s), p, o, m) +# define BOOST_PP_FOR_4_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(5, s) BOOST_PP_IIF(c, BOOST_PP_FOR_5, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(5, s), p, o, m) +# define BOOST_PP_FOR_5_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(6, s) BOOST_PP_IIF(c, BOOST_PP_FOR_6, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(6, s), p, o, m) +# define BOOST_PP_FOR_6_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(7, s) BOOST_PP_IIF(c, BOOST_PP_FOR_7, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(7, s), p, o, m) +# define BOOST_PP_FOR_7_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(8, s) BOOST_PP_IIF(c, BOOST_PP_FOR_8, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(8, s), p, o, m) +# define BOOST_PP_FOR_8_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(9, s) BOOST_PP_IIF(c, BOOST_PP_FOR_9, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(9, s), p, o, m) +# define BOOST_PP_FOR_9_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(10, s) BOOST_PP_IIF(c, BOOST_PP_FOR_10, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(10, s), p, o, m) +# define BOOST_PP_FOR_10_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(11, s) BOOST_PP_IIF(c, BOOST_PP_FOR_11, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(11, s), p, o, m) +# define BOOST_PP_FOR_11_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(12, s) BOOST_PP_IIF(c, BOOST_PP_FOR_12, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(12, s), p, o, m) +# define BOOST_PP_FOR_12_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(13, s) BOOST_PP_IIF(c, BOOST_PP_FOR_13, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(13, s), p, o, m) +# define BOOST_PP_FOR_13_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(14, s) BOOST_PP_IIF(c, BOOST_PP_FOR_14, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(14, s), p, o, m) +# define BOOST_PP_FOR_14_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(15, s) BOOST_PP_IIF(c, BOOST_PP_FOR_15, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(15, s), p, o, m) +# define BOOST_PP_FOR_15_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(16, s) BOOST_PP_IIF(c, BOOST_PP_FOR_16, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(16, s), p, o, m) +# define BOOST_PP_FOR_16_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(17, s) BOOST_PP_IIF(c, BOOST_PP_FOR_17, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(17, s), p, o, m) +# define BOOST_PP_FOR_17_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(18, s) BOOST_PP_IIF(c, BOOST_PP_FOR_18, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(18, s), p, o, m) +# define BOOST_PP_FOR_18_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(19, s) BOOST_PP_IIF(c, BOOST_PP_FOR_19, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(19, s), p, o, m) +# define BOOST_PP_FOR_19_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(20, s) BOOST_PP_IIF(c, BOOST_PP_FOR_20, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(20, s), p, o, m) +# define BOOST_PP_FOR_20_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(21, s) BOOST_PP_IIF(c, BOOST_PP_FOR_21, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(21, s), p, o, m) +# define BOOST_PP_FOR_21_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(22, s) BOOST_PP_IIF(c, BOOST_PP_FOR_22, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(22, s), p, o, m) +# define BOOST_PP_FOR_22_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(23, s) BOOST_PP_IIF(c, BOOST_PP_FOR_23, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(23, s), p, o, m) +# define BOOST_PP_FOR_23_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(24, s) BOOST_PP_IIF(c, BOOST_PP_FOR_24, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(24, s), p, o, m) +# define BOOST_PP_FOR_24_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(25, s) BOOST_PP_IIF(c, BOOST_PP_FOR_25, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(25, s), p, o, m) +# define BOOST_PP_FOR_25_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(26, s) BOOST_PP_IIF(c, BOOST_PP_FOR_26, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(26, s), p, o, m) +# define BOOST_PP_FOR_26_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(27, s) BOOST_PP_IIF(c, BOOST_PP_FOR_27, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(27, s), p, o, m) +# define BOOST_PP_FOR_27_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(28, s) BOOST_PP_IIF(c, BOOST_PP_FOR_28, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(28, s), p, o, m) +# define BOOST_PP_FOR_28_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(29, s) BOOST_PP_IIF(c, BOOST_PP_FOR_29, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(29, s), p, o, m) +# define BOOST_PP_FOR_29_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(30, s) BOOST_PP_IIF(c, BOOST_PP_FOR_30, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(30, s), p, o, m) +# define BOOST_PP_FOR_30_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(31, s) BOOST_PP_IIF(c, BOOST_PP_FOR_31, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(31, s), p, o, m) +# define BOOST_PP_FOR_31_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(32, s) BOOST_PP_IIF(c, BOOST_PP_FOR_32, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(32, s), p, o, m) +# define BOOST_PP_FOR_32_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(33, s) BOOST_PP_IIF(c, BOOST_PP_FOR_33, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(33, s), p, o, m) +# define BOOST_PP_FOR_33_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(34, s) BOOST_PP_IIF(c, BOOST_PP_FOR_34, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(34, s), p, o, m) +# define BOOST_PP_FOR_34_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(35, s) BOOST_PP_IIF(c, BOOST_PP_FOR_35, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(35, s), p, o, m) +# define BOOST_PP_FOR_35_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(36, s) BOOST_PP_IIF(c, BOOST_PP_FOR_36, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(36, s), p, o, m) +# define BOOST_PP_FOR_36_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(37, s) BOOST_PP_IIF(c, BOOST_PP_FOR_37, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(37, s), p, o, m) +# define BOOST_PP_FOR_37_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(38, s) BOOST_PP_IIF(c, BOOST_PP_FOR_38, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(38, s), p, o, m) +# define BOOST_PP_FOR_38_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(39, s) BOOST_PP_IIF(c, BOOST_PP_FOR_39, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(39, s), p, o, m) +# define BOOST_PP_FOR_39_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(40, s) BOOST_PP_IIF(c, BOOST_PP_FOR_40, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(40, s), p, o, m) +# define BOOST_PP_FOR_40_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(41, s) BOOST_PP_IIF(c, BOOST_PP_FOR_41, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(41, s), p, o, m) +# define BOOST_PP_FOR_41_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(42, s) BOOST_PP_IIF(c, BOOST_PP_FOR_42, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(42, s), p, o, m) +# define BOOST_PP_FOR_42_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(43, s) BOOST_PP_IIF(c, BOOST_PP_FOR_43, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(43, s), p, o, m) +# define BOOST_PP_FOR_43_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(44, s) BOOST_PP_IIF(c, BOOST_PP_FOR_44, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(44, s), p, o, m) +# define BOOST_PP_FOR_44_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(45, s) BOOST_PP_IIF(c, BOOST_PP_FOR_45, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(45, s), p, o, m) +# define BOOST_PP_FOR_45_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(46, s) BOOST_PP_IIF(c, BOOST_PP_FOR_46, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(46, s), p, o, m) +# define BOOST_PP_FOR_46_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(47, s) BOOST_PP_IIF(c, BOOST_PP_FOR_47, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(47, s), p, o, m) +# define BOOST_PP_FOR_47_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(48, s) BOOST_PP_IIF(c, BOOST_PP_FOR_48, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(48, s), p, o, m) +# define BOOST_PP_FOR_48_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(49, s) BOOST_PP_IIF(c, BOOST_PP_FOR_49, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(49, s), p, o, m) +# define BOOST_PP_FOR_49_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(50, s) BOOST_PP_IIF(c, BOOST_PP_FOR_50, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(50, s), p, o, m) +# define BOOST_PP_FOR_50_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(51, s) BOOST_PP_IIF(c, BOOST_PP_FOR_51, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(51, s), p, o, m) +# define BOOST_PP_FOR_51_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(52, s) BOOST_PP_IIF(c, BOOST_PP_FOR_52, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(52, s), p, o, m) +# define BOOST_PP_FOR_52_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(53, s) BOOST_PP_IIF(c, BOOST_PP_FOR_53, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(53, s), p, o, m) +# define BOOST_PP_FOR_53_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(54, s) BOOST_PP_IIF(c, BOOST_PP_FOR_54, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(54, s), p, o, m) +# define BOOST_PP_FOR_54_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(55, s) BOOST_PP_IIF(c, BOOST_PP_FOR_55, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(55, s), p, o, m) +# define BOOST_PP_FOR_55_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(56, s) BOOST_PP_IIF(c, BOOST_PP_FOR_56, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(56, s), p, o, m) +# define BOOST_PP_FOR_56_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(57, s) BOOST_PP_IIF(c, BOOST_PP_FOR_57, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(57, s), p, o, m) +# define BOOST_PP_FOR_57_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(58, s) BOOST_PP_IIF(c, BOOST_PP_FOR_58, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(58, s), p, o, m) +# define BOOST_PP_FOR_58_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(59, s) BOOST_PP_IIF(c, BOOST_PP_FOR_59, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(59, s), p, o, m) +# define BOOST_PP_FOR_59_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(60, s) BOOST_PP_IIF(c, BOOST_PP_FOR_60, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(60, s), p, o, m) +# define BOOST_PP_FOR_60_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(61, s) BOOST_PP_IIF(c, BOOST_PP_FOR_61, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(61, s), p, o, m) +# define BOOST_PP_FOR_61_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(62, s) BOOST_PP_IIF(c, BOOST_PP_FOR_62, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(62, s), p, o, m) +# define BOOST_PP_FOR_62_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(63, s) BOOST_PP_IIF(c, BOOST_PP_FOR_63, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(63, s), p, o, m) +# define BOOST_PP_FOR_63_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(64, s) BOOST_PP_IIF(c, BOOST_PP_FOR_64, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(64, s), p, o, m) +# define BOOST_PP_FOR_64_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(65, s) BOOST_PP_IIF(c, BOOST_PP_FOR_65, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(65, s), p, o, m) +# define BOOST_PP_FOR_65_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(66, s) BOOST_PP_IIF(c, BOOST_PP_FOR_66, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(66, s), p, o, m) +# define BOOST_PP_FOR_66_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(67, s) BOOST_PP_IIF(c, BOOST_PP_FOR_67, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(67, s), p, o, m) +# define BOOST_PP_FOR_67_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(68, s) BOOST_PP_IIF(c, BOOST_PP_FOR_68, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(68, s), p, o, m) +# define BOOST_PP_FOR_68_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(69, s) BOOST_PP_IIF(c, BOOST_PP_FOR_69, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(69, s), p, o, m) +# define BOOST_PP_FOR_69_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(70, s) BOOST_PP_IIF(c, BOOST_PP_FOR_70, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(70, s), p, o, m) +# define BOOST_PP_FOR_70_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(71, s) BOOST_PP_IIF(c, BOOST_PP_FOR_71, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(71, s), p, o, m) +# define BOOST_PP_FOR_71_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(72, s) BOOST_PP_IIF(c, BOOST_PP_FOR_72, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(72, s), p, o, m) +# define BOOST_PP_FOR_72_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(73, s) BOOST_PP_IIF(c, BOOST_PP_FOR_73, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(73, s), p, o, m) +# define BOOST_PP_FOR_73_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(74, s) BOOST_PP_IIF(c, BOOST_PP_FOR_74, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(74, s), p, o, m) +# define BOOST_PP_FOR_74_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(75, s) BOOST_PP_IIF(c, BOOST_PP_FOR_75, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(75, s), p, o, m) +# define BOOST_PP_FOR_75_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(76, s) BOOST_PP_IIF(c, BOOST_PP_FOR_76, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(76, s), p, o, m) +# define BOOST_PP_FOR_76_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(77, s) BOOST_PP_IIF(c, BOOST_PP_FOR_77, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(77, s), p, o, m) +# define BOOST_PP_FOR_77_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(78, s) BOOST_PP_IIF(c, BOOST_PP_FOR_78, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(78, s), p, o, m) +# define BOOST_PP_FOR_78_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(79, s) BOOST_PP_IIF(c, BOOST_PP_FOR_79, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(79, s), p, o, m) +# define BOOST_PP_FOR_79_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(80, s) BOOST_PP_IIF(c, BOOST_PP_FOR_80, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(80, s), p, o, m) +# define BOOST_PP_FOR_80_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(81, s) BOOST_PP_IIF(c, BOOST_PP_FOR_81, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(81, s), p, o, m) +# define BOOST_PP_FOR_81_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(82, s) BOOST_PP_IIF(c, BOOST_PP_FOR_82, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(82, s), p, o, m) +# define BOOST_PP_FOR_82_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(83, s) BOOST_PP_IIF(c, BOOST_PP_FOR_83, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(83, s), p, o, m) +# define BOOST_PP_FOR_83_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(84, s) BOOST_PP_IIF(c, BOOST_PP_FOR_84, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(84, s), p, o, m) +# define BOOST_PP_FOR_84_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(85, s) BOOST_PP_IIF(c, BOOST_PP_FOR_85, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(85, s), p, o, m) +# define BOOST_PP_FOR_85_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(86, s) BOOST_PP_IIF(c, BOOST_PP_FOR_86, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(86, s), p, o, m) +# define BOOST_PP_FOR_86_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(87, s) BOOST_PP_IIF(c, BOOST_PP_FOR_87, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(87, s), p, o, m) +# define BOOST_PP_FOR_87_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(88, s) BOOST_PP_IIF(c, BOOST_PP_FOR_88, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(88, s), p, o, m) +# define BOOST_PP_FOR_88_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(89, s) BOOST_PP_IIF(c, BOOST_PP_FOR_89, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(89, s), p, o, m) +# define BOOST_PP_FOR_89_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(90, s) BOOST_PP_IIF(c, BOOST_PP_FOR_90, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(90, s), p, o, m) +# define BOOST_PP_FOR_90_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(91, s) BOOST_PP_IIF(c, BOOST_PP_FOR_91, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(91, s), p, o, m) +# define BOOST_PP_FOR_91_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(92, s) BOOST_PP_IIF(c, BOOST_PP_FOR_92, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(92, s), p, o, m) +# define BOOST_PP_FOR_92_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(93, s) BOOST_PP_IIF(c, BOOST_PP_FOR_93, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(93, s), p, o, m) +# define BOOST_PP_FOR_93_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(94, s) BOOST_PP_IIF(c, BOOST_PP_FOR_94, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(94, s), p, o, m) +# define BOOST_PP_FOR_94_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(95, s) BOOST_PP_IIF(c, BOOST_PP_FOR_95, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(95, s), p, o, m) +# define BOOST_PP_FOR_95_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(96, s) BOOST_PP_IIF(c, BOOST_PP_FOR_96, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(96, s), p, o, m) +# define BOOST_PP_FOR_96_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(97, s) BOOST_PP_IIF(c, BOOST_PP_FOR_97, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(97, s), p, o, m) +# define BOOST_PP_FOR_97_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(98, s) BOOST_PP_IIF(c, BOOST_PP_FOR_98, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(98, s), p, o, m) +# define BOOST_PP_FOR_98_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(99, s) BOOST_PP_IIF(c, BOOST_PP_FOR_99, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(99, s), p, o, m) +# define BOOST_PP_FOR_99_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(100, s) BOOST_PP_IIF(c, BOOST_PP_FOR_100, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(100, s), p, o, m) +# define BOOST_PP_FOR_100_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(101, s) BOOST_PP_IIF(c, BOOST_PP_FOR_101, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(101, s), p, o, m) +# define BOOST_PP_FOR_101_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(102, s) BOOST_PP_IIF(c, BOOST_PP_FOR_102, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(102, s), p, o, m) +# define BOOST_PP_FOR_102_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(103, s) BOOST_PP_IIF(c, BOOST_PP_FOR_103, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(103, s), p, o, m) +# define BOOST_PP_FOR_103_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(104, s) BOOST_PP_IIF(c, BOOST_PP_FOR_104, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(104, s), p, o, m) +# define BOOST_PP_FOR_104_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(105, s) BOOST_PP_IIF(c, BOOST_PP_FOR_105, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(105, s), p, o, m) +# define BOOST_PP_FOR_105_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(106, s) BOOST_PP_IIF(c, BOOST_PP_FOR_106, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(106, s), p, o, m) +# define BOOST_PP_FOR_106_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(107, s) BOOST_PP_IIF(c, BOOST_PP_FOR_107, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(107, s), p, o, m) +# define BOOST_PP_FOR_107_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(108, s) BOOST_PP_IIF(c, BOOST_PP_FOR_108, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(108, s), p, o, m) +# define BOOST_PP_FOR_108_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(109, s) BOOST_PP_IIF(c, BOOST_PP_FOR_109, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(109, s), p, o, m) +# define BOOST_PP_FOR_109_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(110, s) BOOST_PP_IIF(c, BOOST_PP_FOR_110, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(110, s), p, o, m) +# define BOOST_PP_FOR_110_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(111, s) BOOST_PP_IIF(c, BOOST_PP_FOR_111, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(111, s), p, o, m) +# define BOOST_PP_FOR_111_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(112, s) BOOST_PP_IIF(c, BOOST_PP_FOR_112, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(112, s), p, o, m) +# define BOOST_PP_FOR_112_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(113, s) BOOST_PP_IIF(c, BOOST_PP_FOR_113, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(113, s), p, o, m) +# define BOOST_PP_FOR_113_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(114, s) BOOST_PP_IIF(c, BOOST_PP_FOR_114, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(114, s), p, o, m) +# define BOOST_PP_FOR_114_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(115, s) BOOST_PP_IIF(c, BOOST_PP_FOR_115, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(115, s), p, o, m) +# define BOOST_PP_FOR_115_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(116, s) BOOST_PP_IIF(c, BOOST_PP_FOR_116, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(116, s), p, o, m) +# define BOOST_PP_FOR_116_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(117, s) BOOST_PP_IIF(c, BOOST_PP_FOR_117, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(117, s), p, o, m) +# define BOOST_PP_FOR_117_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(118, s) BOOST_PP_IIF(c, BOOST_PP_FOR_118, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(118, s), p, o, m) +# define BOOST_PP_FOR_118_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(119, s) BOOST_PP_IIF(c, BOOST_PP_FOR_119, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(119, s), p, o, m) +# define BOOST_PP_FOR_119_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(120, s) BOOST_PP_IIF(c, BOOST_PP_FOR_120, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(120, s), p, o, m) +# define BOOST_PP_FOR_120_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(121, s) BOOST_PP_IIF(c, BOOST_PP_FOR_121, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(121, s), p, o, m) +# define BOOST_PP_FOR_121_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(122, s) BOOST_PP_IIF(c, BOOST_PP_FOR_122, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(122, s), p, o, m) +# define BOOST_PP_FOR_122_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(123, s) BOOST_PP_IIF(c, BOOST_PP_FOR_123, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(123, s), p, o, m) +# define BOOST_PP_FOR_123_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(124, s) BOOST_PP_IIF(c, BOOST_PP_FOR_124, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(124, s), p, o, m) +# define BOOST_PP_FOR_124_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(125, s) BOOST_PP_IIF(c, BOOST_PP_FOR_125, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(125, s), p, o, m) +# define BOOST_PP_FOR_125_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(126, s) BOOST_PP_IIF(c, BOOST_PP_FOR_126, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(126, s), p, o, m) +# define BOOST_PP_FOR_126_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(127, s) BOOST_PP_IIF(c, BOOST_PP_FOR_127, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(127, s), p, o, m) +# define BOOST_PP_FOR_127_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(128, s) BOOST_PP_IIF(c, BOOST_PP_FOR_128, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(128, s), p, o, m) +# define BOOST_PP_FOR_128_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(129, s) BOOST_PP_IIF(c, BOOST_PP_FOR_129, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(129, s), p, o, m) +# define BOOST_PP_FOR_129_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(130, s) BOOST_PP_IIF(c, BOOST_PP_FOR_130, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(130, s), p, o, m) +# define BOOST_PP_FOR_130_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(131, s) BOOST_PP_IIF(c, BOOST_PP_FOR_131, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(131, s), p, o, m) +# define BOOST_PP_FOR_131_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(132, s) BOOST_PP_IIF(c, BOOST_PP_FOR_132, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(132, s), p, o, m) +# define BOOST_PP_FOR_132_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(133, s) BOOST_PP_IIF(c, BOOST_PP_FOR_133, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(133, s), p, o, m) +# define BOOST_PP_FOR_133_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(134, s) BOOST_PP_IIF(c, BOOST_PP_FOR_134, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(134, s), p, o, m) +# define BOOST_PP_FOR_134_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(135, s) BOOST_PP_IIF(c, BOOST_PP_FOR_135, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(135, s), p, o, m) +# define BOOST_PP_FOR_135_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(136, s) BOOST_PP_IIF(c, BOOST_PP_FOR_136, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(136, s), p, o, m) +# define BOOST_PP_FOR_136_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(137, s) BOOST_PP_IIF(c, BOOST_PP_FOR_137, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(137, s), p, o, m) +# define BOOST_PP_FOR_137_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(138, s) BOOST_PP_IIF(c, BOOST_PP_FOR_138, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(138, s), p, o, m) +# define BOOST_PP_FOR_138_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(139, s) BOOST_PP_IIF(c, BOOST_PP_FOR_139, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(139, s), p, o, m) +# define BOOST_PP_FOR_139_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(140, s) BOOST_PP_IIF(c, BOOST_PP_FOR_140, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(140, s), p, o, m) +# define BOOST_PP_FOR_140_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(141, s) BOOST_PP_IIF(c, BOOST_PP_FOR_141, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(141, s), p, o, m) +# define BOOST_PP_FOR_141_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(142, s) BOOST_PP_IIF(c, BOOST_PP_FOR_142, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(142, s), p, o, m) +# define BOOST_PP_FOR_142_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(143, s) BOOST_PP_IIF(c, BOOST_PP_FOR_143, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(143, s), p, o, m) +# define BOOST_PP_FOR_143_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(144, s) BOOST_PP_IIF(c, BOOST_PP_FOR_144, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(144, s), p, o, m) +# define BOOST_PP_FOR_144_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(145, s) BOOST_PP_IIF(c, BOOST_PP_FOR_145, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(145, s), p, o, m) +# define BOOST_PP_FOR_145_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(146, s) BOOST_PP_IIF(c, BOOST_PP_FOR_146, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(146, s), p, o, m) +# define BOOST_PP_FOR_146_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(147, s) BOOST_PP_IIF(c, BOOST_PP_FOR_147, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(147, s), p, o, m) +# define BOOST_PP_FOR_147_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(148, s) BOOST_PP_IIF(c, BOOST_PP_FOR_148, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(148, s), p, o, m) +# define BOOST_PP_FOR_148_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(149, s) BOOST_PP_IIF(c, BOOST_PP_FOR_149, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(149, s), p, o, m) +# define BOOST_PP_FOR_149_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(150, s) BOOST_PP_IIF(c, BOOST_PP_FOR_150, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(150, s), p, o, m) +# define BOOST_PP_FOR_150_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(151, s) BOOST_PP_IIF(c, BOOST_PP_FOR_151, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(151, s), p, o, m) +# define BOOST_PP_FOR_151_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(152, s) BOOST_PP_IIF(c, BOOST_PP_FOR_152, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(152, s), p, o, m) +# define BOOST_PP_FOR_152_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(153, s) BOOST_PP_IIF(c, BOOST_PP_FOR_153, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(153, s), p, o, m) +# define BOOST_PP_FOR_153_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(154, s) BOOST_PP_IIF(c, BOOST_PP_FOR_154, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(154, s), p, o, m) +# define BOOST_PP_FOR_154_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(155, s) BOOST_PP_IIF(c, BOOST_PP_FOR_155, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(155, s), p, o, m) +# define BOOST_PP_FOR_155_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(156, s) BOOST_PP_IIF(c, BOOST_PP_FOR_156, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(156, s), p, o, m) +# define BOOST_PP_FOR_156_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(157, s) BOOST_PP_IIF(c, BOOST_PP_FOR_157, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(157, s), p, o, m) +# define BOOST_PP_FOR_157_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(158, s) BOOST_PP_IIF(c, BOOST_PP_FOR_158, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(158, s), p, o, m) +# define BOOST_PP_FOR_158_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(159, s) BOOST_PP_IIF(c, BOOST_PP_FOR_159, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(159, s), p, o, m) +# define BOOST_PP_FOR_159_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(160, s) BOOST_PP_IIF(c, BOOST_PP_FOR_160, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(160, s), p, o, m) +# define BOOST_PP_FOR_160_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(161, s) BOOST_PP_IIF(c, BOOST_PP_FOR_161, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(161, s), p, o, m) +# define BOOST_PP_FOR_161_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(162, s) BOOST_PP_IIF(c, BOOST_PP_FOR_162, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(162, s), p, o, m) +# define BOOST_PP_FOR_162_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(163, s) BOOST_PP_IIF(c, BOOST_PP_FOR_163, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(163, s), p, o, m) +# define BOOST_PP_FOR_163_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(164, s) BOOST_PP_IIF(c, BOOST_PP_FOR_164, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(164, s), p, o, m) +# define BOOST_PP_FOR_164_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(165, s) BOOST_PP_IIF(c, BOOST_PP_FOR_165, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(165, s), p, o, m) +# define BOOST_PP_FOR_165_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(166, s) BOOST_PP_IIF(c, BOOST_PP_FOR_166, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(166, s), p, o, m) +# define BOOST_PP_FOR_166_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(167, s) BOOST_PP_IIF(c, BOOST_PP_FOR_167, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(167, s), p, o, m) +# define BOOST_PP_FOR_167_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(168, s) BOOST_PP_IIF(c, BOOST_PP_FOR_168, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(168, s), p, o, m) +# define BOOST_PP_FOR_168_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(169, s) BOOST_PP_IIF(c, BOOST_PP_FOR_169, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(169, s), p, o, m) +# define BOOST_PP_FOR_169_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(170, s) BOOST_PP_IIF(c, BOOST_PP_FOR_170, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(170, s), p, o, m) +# define BOOST_PP_FOR_170_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(171, s) BOOST_PP_IIF(c, BOOST_PP_FOR_171, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(171, s), p, o, m) +# define BOOST_PP_FOR_171_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(172, s) BOOST_PP_IIF(c, BOOST_PP_FOR_172, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(172, s), p, o, m) +# define BOOST_PP_FOR_172_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(173, s) BOOST_PP_IIF(c, BOOST_PP_FOR_173, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(173, s), p, o, m) +# define BOOST_PP_FOR_173_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(174, s) BOOST_PP_IIF(c, BOOST_PP_FOR_174, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(174, s), p, o, m) +# define BOOST_PP_FOR_174_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(175, s) BOOST_PP_IIF(c, BOOST_PP_FOR_175, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(175, s), p, o, m) +# define BOOST_PP_FOR_175_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(176, s) BOOST_PP_IIF(c, BOOST_PP_FOR_176, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(176, s), p, o, m) +# define BOOST_PP_FOR_176_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(177, s) BOOST_PP_IIF(c, BOOST_PP_FOR_177, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(177, s), p, o, m) +# define BOOST_PP_FOR_177_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(178, s) BOOST_PP_IIF(c, BOOST_PP_FOR_178, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(178, s), p, o, m) +# define BOOST_PP_FOR_178_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(179, s) BOOST_PP_IIF(c, BOOST_PP_FOR_179, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(179, s), p, o, m) +# define BOOST_PP_FOR_179_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(180, s) BOOST_PP_IIF(c, BOOST_PP_FOR_180, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(180, s), p, o, m) +# define BOOST_PP_FOR_180_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(181, s) BOOST_PP_IIF(c, BOOST_PP_FOR_181, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(181, s), p, o, m) +# define BOOST_PP_FOR_181_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(182, s) BOOST_PP_IIF(c, BOOST_PP_FOR_182, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(182, s), p, o, m) +# define BOOST_PP_FOR_182_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(183, s) BOOST_PP_IIF(c, BOOST_PP_FOR_183, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(183, s), p, o, m) +# define BOOST_PP_FOR_183_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(184, s) BOOST_PP_IIF(c, BOOST_PP_FOR_184, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(184, s), p, o, m) +# define BOOST_PP_FOR_184_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(185, s) BOOST_PP_IIF(c, BOOST_PP_FOR_185, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(185, s), p, o, m) +# define BOOST_PP_FOR_185_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(186, s) BOOST_PP_IIF(c, BOOST_PP_FOR_186, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(186, s), p, o, m) +# define BOOST_PP_FOR_186_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(187, s) BOOST_PP_IIF(c, BOOST_PP_FOR_187, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(187, s), p, o, m) +# define BOOST_PP_FOR_187_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(188, s) BOOST_PP_IIF(c, BOOST_PP_FOR_188, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(188, s), p, o, m) +# define BOOST_PP_FOR_188_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(189, s) BOOST_PP_IIF(c, BOOST_PP_FOR_189, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(189, s), p, o, m) +# define BOOST_PP_FOR_189_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(190, s) BOOST_PP_IIF(c, BOOST_PP_FOR_190, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(190, s), p, o, m) +# define BOOST_PP_FOR_190_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(191, s) BOOST_PP_IIF(c, BOOST_PP_FOR_191, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(191, s), p, o, m) +# define BOOST_PP_FOR_191_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(192, s) BOOST_PP_IIF(c, BOOST_PP_FOR_192, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(192, s), p, o, m) +# define BOOST_PP_FOR_192_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(193, s) BOOST_PP_IIF(c, BOOST_PP_FOR_193, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(193, s), p, o, m) +# define BOOST_PP_FOR_193_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(194, s) BOOST_PP_IIF(c, BOOST_PP_FOR_194, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(194, s), p, o, m) +# define BOOST_PP_FOR_194_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(195, s) BOOST_PP_IIF(c, BOOST_PP_FOR_195, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(195, s), p, o, m) +# define BOOST_PP_FOR_195_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(196, s) BOOST_PP_IIF(c, BOOST_PP_FOR_196, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(196, s), p, o, m) +# define BOOST_PP_FOR_196_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(197, s) BOOST_PP_IIF(c, BOOST_PP_FOR_197, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(197, s), p, o, m) +# define BOOST_PP_FOR_197_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(198, s) BOOST_PP_IIF(c, BOOST_PP_FOR_198, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(198, s), p, o, m) +# define BOOST_PP_FOR_198_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(199, s) BOOST_PP_IIF(c, BOOST_PP_FOR_199, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(199, s), p, o, m) +# define BOOST_PP_FOR_199_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(200, s) BOOST_PP_IIF(c, BOOST_PP_FOR_200, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(200, s), p, o, m) +# define BOOST_PP_FOR_200_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(201, s) BOOST_PP_IIF(c, BOOST_PP_FOR_201, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(201, s), p, o, m) +# define BOOST_PP_FOR_201_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(202, s) BOOST_PP_IIF(c, BOOST_PP_FOR_202, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(202, s), p, o, m) +# define BOOST_PP_FOR_202_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(203, s) BOOST_PP_IIF(c, BOOST_PP_FOR_203, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(203, s), p, o, m) +# define BOOST_PP_FOR_203_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(204, s) BOOST_PP_IIF(c, BOOST_PP_FOR_204, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(204, s), p, o, m) +# define BOOST_PP_FOR_204_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(205, s) BOOST_PP_IIF(c, BOOST_PP_FOR_205, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(205, s), p, o, m) +# define BOOST_PP_FOR_205_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(206, s) BOOST_PP_IIF(c, BOOST_PP_FOR_206, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(206, s), p, o, m) +# define BOOST_PP_FOR_206_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(207, s) BOOST_PP_IIF(c, BOOST_PP_FOR_207, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(207, s), p, o, m) +# define BOOST_PP_FOR_207_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(208, s) BOOST_PP_IIF(c, BOOST_PP_FOR_208, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(208, s), p, o, m) +# define BOOST_PP_FOR_208_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(209, s) BOOST_PP_IIF(c, BOOST_PP_FOR_209, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(209, s), p, o, m) +# define BOOST_PP_FOR_209_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(210, s) BOOST_PP_IIF(c, BOOST_PP_FOR_210, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(210, s), p, o, m) +# define BOOST_PP_FOR_210_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(211, s) BOOST_PP_IIF(c, BOOST_PP_FOR_211, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(211, s), p, o, m) +# define BOOST_PP_FOR_211_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(212, s) BOOST_PP_IIF(c, BOOST_PP_FOR_212, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(212, s), p, o, m) +# define BOOST_PP_FOR_212_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(213, s) BOOST_PP_IIF(c, BOOST_PP_FOR_213, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(213, s), p, o, m) +# define BOOST_PP_FOR_213_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(214, s) BOOST_PP_IIF(c, BOOST_PP_FOR_214, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(214, s), p, o, m) +# define BOOST_PP_FOR_214_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(215, s) BOOST_PP_IIF(c, BOOST_PP_FOR_215, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(215, s), p, o, m) +# define BOOST_PP_FOR_215_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(216, s) BOOST_PP_IIF(c, BOOST_PP_FOR_216, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(216, s), p, o, m) +# define BOOST_PP_FOR_216_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(217, s) BOOST_PP_IIF(c, BOOST_PP_FOR_217, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(217, s), p, o, m) +# define BOOST_PP_FOR_217_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(218, s) BOOST_PP_IIF(c, BOOST_PP_FOR_218, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(218, s), p, o, m) +# define BOOST_PP_FOR_218_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(219, s) BOOST_PP_IIF(c, BOOST_PP_FOR_219, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(219, s), p, o, m) +# define BOOST_PP_FOR_219_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(220, s) BOOST_PP_IIF(c, BOOST_PP_FOR_220, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(220, s), p, o, m) +# define BOOST_PP_FOR_220_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(221, s) BOOST_PP_IIF(c, BOOST_PP_FOR_221, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(221, s), p, o, m) +# define BOOST_PP_FOR_221_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(222, s) BOOST_PP_IIF(c, BOOST_PP_FOR_222, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(222, s), p, o, m) +# define BOOST_PP_FOR_222_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(223, s) BOOST_PP_IIF(c, BOOST_PP_FOR_223, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(223, s), p, o, m) +# define BOOST_PP_FOR_223_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(224, s) BOOST_PP_IIF(c, BOOST_PP_FOR_224, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(224, s), p, o, m) +# define BOOST_PP_FOR_224_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(225, s) BOOST_PP_IIF(c, BOOST_PP_FOR_225, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(225, s), p, o, m) +# define BOOST_PP_FOR_225_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(226, s) BOOST_PP_IIF(c, BOOST_PP_FOR_226, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(226, s), p, o, m) +# define BOOST_PP_FOR_226_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(227, s) BOOST_PP_IIF(c, BOOST_PP_FOR_227, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(227, s), p, o, m) +# define BOOST_PP_FOR_227_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(228, s) BOOST_PP_IIF(c, BOOST_PP_FOR_228, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(228, s), p, o, m) +# define BOOST_PP_FOR_228_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(229, s) BOOST_PP_IIF(c, BOOST_PP_FOR_229, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(229, s), p, o, m) +# define BOOST_PP_FOR_229_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(230, s) BOOST_PP_IIF(c, BOOST_PP_FOR_230, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(230, s), p, o, m) +# define BOOST_PP_FOR_230_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(231, s) BOOST_PP_IIF(c, BOOST_PP_FOR_231, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(231, s), p, o, m) +# define BOOST_PP_FOR_231_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(232, s) BOOST_PP_IIF(c, BOOST_PP_FOR_232, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(232, s), p, o, m) +# define BOOST_PP_FOR_232_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(233, s) BOOST_PP_IIF(c, BOOST_PP_FOR_233, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(233, s), p, o, m) +# define BOOST_PP_FOR_233_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(234, s) BOOST_PP_IIF(c, BOOST_PP_FOR_234, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(234, s), p, o, m) +# define BOOST_PP_FOR_234_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(235, s) BOOST_PP_IIF(c, BOOST_PP_FOR_235, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(235, s), p, o, m) +# define BOOST_PP_FOR_235_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(236, s) BOOST_PP_IIF(c, BOOST_PP_FOR_236, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(236, s), p, o, m) +# define BOOST_PP_FOR_236_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(237, s) BOOST_PP_IIF(c, BOOST_PP_FOR_237, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(237, s), p, o, m) +# define BOOST_PP_FOR_237_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(238, s) BOOST_PP_IIF(c, BOOST_PP_FOR_238, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(238, s), p, o, m) +# define BOOST_PP_FOR_238_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(239, s) BOOST_PP_IIF(c, BOOST_PP_FOR_239, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(239, s), p, o, m) +# define BOOST_PP_FOR_239_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(240, s) BOOST_PP_IIF(c, BOOST_PP_FOR_240, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(240, s), p, o, m) +# define BOOST_PP_FOR_240_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(241, s) BOOST_PP_IIF(c, BOOST_PP_FOR_241, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(241, s), p, o, m) +# define BOOST_PP_FOR_241_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(242, s) BOOST_PP_IIF(c, BOOST_PP_FOR_242, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(242, s), p, o, m) +# define BOOST_PP_FOR_242_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(243, s) BOOST_PP_IIF(c, BOOST_PP_FOR_243, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(243, s), p, o, m) +# define BOOST_PP_FOR_243_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(244, s) BOOST_PP_IIF(c, BOOST_PP_FOR_244, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(244, s), p, o, m) +# define BOOST_PP_FOR_244_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(245, s) BOOST_PP_IIF(c, BOOST_PP_FOR_245, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(245, s), p, o, m) +# define BOOST_PP_FOR_245_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(246, s) BOOST_PP_IIF(c, BOOST_PP_FOR_246, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(246, s), p, o, m) +# define BOOST_PP_FOR_246_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(247, s) BOOST_PP_IIF(c, BOOST_PP_FOR_247, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(247, s), p, o, m) +# define BOOST_PP_FOR_247_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(248, s) BOOST_PP_IIF(c, BOOST_PP_FOR_248, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(248, s), p, o, m) +# define BOOST_PP_FOR_248_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(249, s) BOOST_PP_IIF(c, BOOST_PP_FOR_249, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(249, s), p, o, m) +# define BOOST_PP_FOR_249_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(250, s) BOOST_PP_IIF(c, BOOST_PP_FOR_250, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(250, s), p, o, m) +# define BOOST_PP_FOR_250_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(251, s) BOOST_PP_IIF(c, BOOST_PP_FOR_251, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(251, s), p, o, m) +# define BOOST_PP_FOR_251_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(252, s) BOOST_PP_IIF(c, BOOST_PP_FOR_252, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(252, s), p, o, m) +# define BOOST_PP_FOR_252_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(253, s) BOOST_PP_IIF(c, BOOST_PP_FOR_253, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(253, s), p, o, m) +# define BOOST_PP_FOR_253_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(254, s) BOOST_PP_IIF(c, BOOST_PP_FOR_254, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(254, s), p, o, m) +# define BOOST_PP_FOR_254_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(255, s) BOOST_PP_IIF(c, BOOST_PP_FOR_255, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(255, s), p, o, m) +# define BOOST_PP_FOR_255_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(256, s) BOOST_PP_IIF(c, BOOST_PP_FOR_256, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(256, s), p, o, m) +# define BOOST_PP_FOR_256_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(257, s) BOOST_PP_IIF(c, BOOST_PP_FOR_257, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(257, s), p, o, m) +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/repetition/for.hpp b/deal.II/contrib/boost/include/boost/preprocessor/repetition/for.hpp new file mode 100644 index 0000000000..9624f4bf2e --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/repetition/for.hpp @@ -0,0 +1,305 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_REPETITION_FOR_HPP +# define BOOST_PREPROCESSOR_REPETITION_FOR_HPP +# +# include +# include +# include +# +# /* BOOST_PP_FOR */ +# +# if 0 +# define BOOST_PP_FOR(state, pred, op, macro) +# endif +# +# define BOOST_PP_FOR BOOST_PP_CAT(BOOST_PP_FOR_, BOOST_PP_AUTO_REC(BOOST_PP_FOR_P, 256)) +# +# define BOOST_PP_FOR_P(n) BOOST_PP_CAT(BOOST_PP_FOR_CHECK_, BOOST_PP_FOR_ ## n(1, BOOST_PP_FOR_SR_P, BOOST_PP_FOR_SR_O, BOOST_PP_FOR_SR_M)) +# +# define BOOST_PP_FOR_SR_P(r, s) s +# define BOOST_PP_FOR_SR_O(r, s) 0 +# define BOOST_PP_FOR_SR_M(r, s) BOOST_PP_NIL +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# include +# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# include +# else +# include +# endif +# +# define BOOST_PP_FOR_257(s, p, o, m) BOOST_PP_ERROR(0x0002) +# +# define BOOST_PP_FOR_CHECK_BOOST_PP_NIL 1 +# +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_1(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_2(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_3(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_4(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_5(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_6(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_7(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_8(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_9(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_10(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_11(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_12(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_13(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_14(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_15(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_16(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_17(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_18(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_19(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_20(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_21(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_22(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_23(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_24(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_25(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_26(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_27(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_28(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_29(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_30(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_31(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_32(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_33(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_34(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_35(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_36(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_37(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_38(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_39(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_40(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_41(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_42(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_43(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_44(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_45(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_46(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_47(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_48(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_49(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_50(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_51(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_52(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_53(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_54(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_55(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_56(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_57(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_58(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_59(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_60(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_61(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_62(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_63(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_64(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_65(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_66(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_67(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_68(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_69(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_70(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_71(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_72(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_73(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_74(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_75(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_76(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_77(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_78(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_79(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_80(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_81(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_82(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_83(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_84(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_85(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_86(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_87(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_88(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_89(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_90(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_91(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_92(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_93(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_94(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_95(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_96(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_97(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_98(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_99(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_100(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_101(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_102(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_103(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_104(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_105(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_106(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_107(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_108(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_109(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_110(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_111(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_112(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_113(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_114(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_115(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_116(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_117(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_118(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_119(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_120(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_121(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_122(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_123(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_124(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_125(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_126(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_127(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_128(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_129(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_130(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_131(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_132(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_133(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_134(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_135(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_136(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_137(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_138(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_139(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_140(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_141(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_142(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_143(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_144(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_145(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_146(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_147(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_148(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_149(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_150(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_151(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_152(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_153(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_154(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_155(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_156(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_157(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_158(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_159(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_160(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_161(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_162(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_163(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_164(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_165(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_166(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_167(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_168(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_169(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_170(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_171(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_172(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_173(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_174(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_175(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_176(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_177(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_178(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_179(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_180(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_181(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_182(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_183(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_184(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_185(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_186(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_187(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_188(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_189(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_190(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_191(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_192(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_193(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_194(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_195(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_196(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_197(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_198(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_199(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_200(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_201(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_202(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_203(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_204(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_205(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_206(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_207(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_208(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_209(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_210(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_211(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_212(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_213(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_214(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_215(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_216(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_217(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_218(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_219(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_220(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_221(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_222(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_223(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_224(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_225(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_226(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_227(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_228(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_229(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_230(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_231(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_232(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_233(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_234(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_235(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_236(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_237(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_238(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_239(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_240(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_241(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_242(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_243(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_244(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_245(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_246(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_247(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_248(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_249(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_250(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_251(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_252(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_253(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_254(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_255(s, p, o, m) 0 +# define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_256(s, p, o, m) 0 +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/tuple/eat.hpp b/deal.II/contrib/boost/include/boost/preprocessor/tuple/eat.hpp new file mode 100644 index 0000000000..6fd20a7e60 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/tuple/eat.hpp @@ -0,0 +1,58 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_EAT_HPP +# define BOOST_PREPROCESSOR_TUPLE_EAT_HPP +# +# include +# +# /* BOOST_PP_TUPLE_EAT */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_TUPLE_EAT(size) BOOST_PP_TUPLE_EAT_I(size) +# else +# define BOOST_PP_TUPLE_EAT(size) BOOST_PP_TUPLE_EAT_OO((size)) +# define BOOST_PP_TUPLE_EAT_OO(par) BOOST_PP_TUPLE_EAT_I ## par +# endif +# +# define BOOST_PP_TUPLE_EAT_I(size) BOOST_PP_TUPLE_EAT_ ## size +# +# define BOOST_PP_TUPLE_EAT_0() +# define BOOST_PP_TUPLE_EAT_1(a) +# define BOOST_PP_TUPLE_EAT_2(a, b) +# define BOOST_PP_TUPLE_EAT_3(a, b, c) +# define BOOST_PP_TUPLE_EAT_4(a, b, c, d) +# define BOOST_PP_TUPLE_EAT_5(a, b, c, d, e) +# define BOOST_PP_TUPLE_EAT_6(a, b, c, d, e, f) +# define BOOST_PP_TUPLE_EAT_7(a, b, c, d, e, f, g) +# define BOOST_PP_TUPLE_EAT_8(a, b, c, d, e, f, g, h) +# define BOOST_PP_TUPLE_EAT_9(a, b, c, d, e, f, g, h, i) +# define BOOST_PP_TUPLE_EAT_10(a, b, c, d, e, f, g, h, i, j) +# define BOOST_PP_TUPLE_EAT_11(a, b, c, d, e, f, g, h, i, j, k) +# define BOOST_PP_TUPLE_EAT_12(a, b, c, d, e, f, g, h, i, j, k, l) +# define BOOST_PP_TUPLE_EAT_13(a, b, c, d, e, f, g, h, i, j, k, l, m) +# define BOOST_PP_TUPLE_EAT_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n) +# define BOOST_PP_TUPLE_EAT_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) +# define BOOST_PP_TUPLE_EAT_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) +# define BOOST_PP_TUPLE_EAT_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) +# define BOOST_PP_TUPLE_EAT_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) +# define BOOST_PP_TUPLE_EAT_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) +# define BOOST_PP_TUPLE_EAT_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) +# define BOOST_PP_TUPLE_EAT_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) +# define BOOST_PP_TUPLE_EAT_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) +# define BOOST_PP_TUPLE_EAT_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) +# define BOOST_PP_TUPLE_EAT_24(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) +# define BOOST_PP_TUPLE_EAT_25(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/tuple/elem.hpp b/deal.II/contrib/boost/include/boost/preprocessor/tuple/elem.hpp new file mode 100644 index 0000000000..4fefe6990d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/tuple/elem.hpp @@ -0,0 +1,386 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_ELEM_HPP +# define BOOST_PREPROCESSOR_TUPLE_ELEM_HPP +# +# include +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_TUPLE_ELEM(size, index, tuple) BOOST_PP_TUPLE_ELEM_I(size, index, tuple) +# else +# define BOOST_PP_TUPLE_ELEM(size, index, tuple) BOOST_PP_TUPLE_ELEM_OO((size, index, tuple)) +# define BOOST_PP_TUPLE_ELEM_OO(par) BOOST_PP_TUPLE_ELEM_I ## par +# endif +# +# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_TUPLE_ELEM_I(s, i, t) BOOST_PP_TUPLE_ELEM_ ## s ## _ ## i ## t +# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_TUPLE_ELEM_I(s, i, t) BOOST_PP_TUPLE_ELEM_II(BOOST_PP_TUPLE_ELEM_ ## s ## _ ## i t) +# define BOOST_PP_TUPLE_ELEM_II(res) res +# else +# define BOOST_PP_TUPLE_ELEM_I(s, i, t) BOOST_PP_TUPLE_ELEM_ ## s ## _ ## i t +# endif +# +# define BOOST_PP_TUPLE_ELEM_1_0(a) a +# +# define BOOST_PP_TUPLE_ELEM_2_0(a, b) a +# define BOOST_PP_TUPLE_ELEM_2_1(a, b) b +# +# define BOOST_PP_TUPLE_ELEM_3_0(a, b, c) a +# define BOOST_PP_TUPLE_ELEM_3_1(a, b, c) b +# define BOOST_PP_TUPLE_ELEM_3_2(a, b, c) c +# +# define BOOST_PP_TUPLE_ELEM_4_0(a, b, c, d) a +# define BOOST_PP_TUPLE_ELEM_4_1(a, b, c, d) b +# define BOOST_PP_TUPLE_ELEM_4_2(a, b, c, d) c +# define BOOST_PP_TUPLE_ELEM_4_3(a, b, c, d) d +# +# define BOOST_PP_TUPLE_ELEM_5_0(a, b, c, d, e) a +# define BOOST_PP_TUPLE_ELEM_5_1(a, b, c, d, e) b +# define BOOST_PP_TUPLE_ELEM_5_2(a, b, c, d, e) c +# define BOOST_PP_TUPLE_ELEM_5_3(a, b, c, d, e) d +# define BOOST_PP_TUPLE_ELEM_5_4(a, b, c, d, e) e +# +# define BOOST_PP_TUPLE_ELEM_6_0(a, b, c, d, e, f) a +# define BOOST_PP_TUPLE_ELEM_6_1(a, b, c, d, e, f) b +# define BOOST_PP_TUPLE_ELEM_6_2(a, b, c, d, e, f) c +# define BOOST_PP_TUPLE_ELEM_6_3(a, b, c, d, e, f) d +# define BOOST_PP_TUPLE_ELEM_6_4(a, b, c, d, e, f) e +# define BOOST_PP_TUPLE_ELEM_6_5(a, b, c, d, e, f) f +# +# define BOOST_PP_TUPLE_ELEM_7_0(a, b, c, d, e, f, g) a +# define BOOST_PP_TUPLE_ELEM_7_1(a, b, c, d, e, f, g) b +# define BOOST_PP_TUPLE_ELEM_7_2(a, b, c, d, e, f, g) c +# define BOOST_PP_TUPLE_ELEM_7_3(a, b, c, d, e, f, g) d +# define BOOST_PP_TUPLE_ELEM_7_4(a, b, c, d, e, f, g) e +# define BOOST_PP_TUPLE_ELEM_7_5(a, b, c, d, e, f, g) f +# define BOOST_PP_TUPLE_ELEM_7_6(a, b, c, d, e, f, g) g +# +# define BOOST_PP_TUPLE_ELEM_8_0(a, b, c, d, e, f, g, h) a +# define BOOST_PP_TUPLE_ELEM_8_1(a, b, c, d, e, f, g, h) b +# define BOOST_PP_TUPLE_ELEM_8_2(a, b, c, d, e, f, g, h) c +# define BOOST_PP_TUPLE_ELEM_8_3(a, b, c, d, e, f, g, h) d +# define BOOST_PP_TUPLE_ELEM_8_4(a, b, c, d, e, f, g, h) e +# define BOOST_PP_TUPLE_ELEM_8_5(a, b, c, d, e, f, g, h) f +# define BOOST_PP_TUPLE_ELEM_8_6(a, b, c, d, e, f, g, h) g +# define BOOST_PP_TUPLE_ELEM_8_7(a, b, c, d, e, f, g, h) h +# +# define BOOST_PP_TUPLE_ELEM_9_0(a, b, c, d, e, f, g, h, i) a +# define BOOST_PP_TUPLE_ELEM_9_1(a, b, c, d, e, f, g, h, i) b +# define BOOST_PP_TUPLE_ELEM_9_2(a, b, c, d, e, f, g, h, i) c +# define BOOST_PP_TUPLE_ELEM_9_3(a, b, c, d, e, f, g, h, i) d +# define BOOST_PP_TUPLE_ELEM_9_4(a, b, c, d, e, f, g, h, i) e +# define BOOST_PP_TUPLE_ELEM_9_5(a, b, c, d, e, f, g, h, i) f +# define BOOST_PP_TUPLE_ELEM_9_6(a, b, c, d, e, f, g, h, i) g +# define BOOST_PP_TUPLE_ELEM_9_7(a, b, c, d, e, f, g, h, i) h +# define BOOST_PP_TUPLE_ELEM_9_8(a, b, c, d, e, f, g, h, i) i +# +# define BOOST_PP_TUPLE_ELEM_10_0(a, b, c, d, e, f, g, h, i, j) a +# define BOOST_PP_TUPLE_ELEM_10_1(a, b, c, d, e, f, g, h, i, j) b +# define BOOST_PP_TUPLE_ELEM_10_2(a, b, c, d, e, f, g, h, i, j) c +# define BOOST_PP_TUPLE_ELEM_10_3(a, b, c, d, e, f, g, h, i, j) d +# define BOOST_PP_TUPLE_ELEM_10_4(a, b, c, d, e, f, g, h, i, j) e +# define BOOST_PP_TUPLE_ELEM_10_5(a, b, c, d, e, f, g, h, i, j) f +# define BOOST_PP_TUPLE_ELEM_10_6(a, b, c, d, e, f, g, h, i, j) g +# define BOOST_PP_TUPLE_ELEM_10_7(a, b, c, d, e, f, g, h, i, j) h +# define BOOST_PP_TUPLE_ELEM_10_8(a, b, c, d, e, f, g, h, i, j) i +# define BOOST_PP_TUPLE_ELEM_10_9(a, b, c, d, e, f, g, h, i, j) j +# +# define BOOST_PP_TUPLE_ELEM_11_0(a, b, c, d, e, f, g, h, i, j, k) a +# define BOOST_PP_TUPLE_ELEM_11_1(a, b, c, d, e, f, g, h, i, j, k) b +# define BOOST_PP_TUPLE_ELEM_11_2(a, b, c, d, e, f, g, h, i, j, k) c +# define BOOST_PP_TUPLE_ELEM_11_3(a, b, c, d, e, f, g, h, i, j, k) d +# define BOOST_PP_TUPLE_ELEM_11_4(a, b, c, d, e, f, g, h, i, j, k) e +# define BOOST_PP_TUPLE_ELEM_11_5(a, b, c, d, e, f, g, h, i, j, k) f +# define BOOST_PP_TUPLE_ELEM_11_6(a, b, c, d, e, f, g, h, i, j, k) g +# define BOOST_PP_TUPLE_ELEM_11_7(a, b, c, d, e, f, g, h, i, j, k) h +# define BOOST_PP_TUPLE_ELEM_11_8(a, b, c, d, e, f, g, h, i, j, k) i +# define BOOST_PP_TUPLE_ELEM_11_9(a, b, c, d, e, f, g, h, i, j, k) j +# define BOOST_PP_TUPLE_ELEM_11_10(a, b, c, d, e, f, g, h, i, j, k) k +# +# define BOOST_PP_TUPLE_ELEM_12_0(a, b, c, d, e, f, g, h, i, j, k, l) a +# define BOOST_PP_TUPLE_ELEM_12_1(a, b, c, d, e, f, g, h, i, j, k, l) b +# define BOOST_PP_TUPLE_ELEM_12_2(a, b, c, d, e, f, g, h, i, j, k, l) c +# define BOOST_PP_TUPLE_ELEM_12_3(a, b, c, d, e, f, g, h, i, j, k, l) d +# define BOOST_PP_TUPLE_ELEM_12_4(a, b, c, d, e, f, g, h, i, j, k, l) e +# define BOOST_PP_TUPLE_ELEM_12_5(a, b, c, d, e, f, g, h, i, j, k, l) f +# define BOOST_PP_TUPLE_ELEM_12_6(a, b, c, d, e, f, g, h, i, j, k, l) g +# define BOOST_PP_TUPLE_ELEM_12_7(a, b, c, d, e, f, g, h, i, j, k, l) h +# define BOOST_PP_TUPLE_ELEM_12_8(a, b, c, d, e, f, g, h, i, j, k, l) i +# define BOOST_PP_TUPLE_ELEM_12_9(a, b, c, d, e, f, g, h, i, j, k, l) j +# define BOOST_PP_TUPLE_ELEM_12_10(a, b, c, d, e, f, g, h, i, j, k, l) k +# define BOOST_PP_TUPLE_ELEM_12_11(a, b, c, d, e, f, g, h, i, j, k, l) l +# +# define BOOST_PP_TUPLE_ELEM_13_0(a, b, c, d, e, f, g, h, i, j, k, l, m) a +# define BOOST_PP_TUPLE_ELEM_13_1(a, b, c, d, e, f, g, h, i, j, k, l, m) b +# define BOOST_PP_TUPLE_ELEM_13_2(a, b, c, d, e, f, g, h, i, j, k, l, m) c +# define BOOST_PP_TUPLE_ELEM_13_3(a, b, c, d, e, f, g, h, i, j, k, l, m) d +# define BOOST_PP_TUPLE_ELEM_13_4(a, b, c, d, e, f, g, h, i, j, k, l, m) e +# define BOOST_PP_TUPLE_ELEM_13_5(a, b, c, d, e, f, g, h, i, j, k, l, m) f +# define BOOST_PP_TUPLE_ELEM_13_6(a, b, c, d, e, f, g, h, i, j, k, l, m) g +# define BOOST_PP_TUPLE_ELEM_13_7(a, b, c, d, e, f, g, h, i, j, k, l, m) h +# define BOOST_PP_TUPLE_ELEM_13_8(a, b, c, d, e, f, g, h, i, j, k, l, m) i +# define BOOST_PP_TUPLE_ELEM_13_9(a, b, c, d, e, f, g, h, i, j, k, l, m) j +# define BOOST_PP_TUPLE_ELEM_13_10(a, b, c, d, e, f, g, h, i, j, k, l, m) k +# define BOOST_PP_TUPLE_ELEM_13_11(a, b, c, d, e, f, g, h, i, j, k, l, m) l +# define BOOST_PP_TUPLE_ELEM_13_12(a, b, c, d, e, f, g, h, i, j, k, l, m) m +# +# define BOOST_PP_TUPLE_ELEM_14_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n) a +# define BOOST_PP_TUPLE_ELEM_14_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n) b +# define BOOST_PP_TUPLE_ELEM_14_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n) c +# define BOOST_PP_TUPLE_ELEM_14_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n) d +# define BOOST_PP_TUPLE_ELEM_14_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n) e +# define BOOST_PP_TUPLE_ELEM_14_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n) f +# define BOOST_PP_TUPLE_ELEM_14_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n) g +# define BOOST_PP_TUPLE_ELEM_14_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n) h +# define BOOST_PP_TUPLE_ELEM_14_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n) i +# define BOOST_PP_TUPLE_ELEM_14_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n) j +# define BOOST_PP_TUPLE_ELEM_14_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n) k +# define BOOST_PP_TUPLE_ELEM_14_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n) l +# define BOOST_PP_TUPLE_ELEM_14_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n) m +# define BOOST_PP_TUPLE_ELEM_14_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n) n +# +# define BOOST_PP_TUPLE_ELEM_15_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) a +# define BOOST_PP_TUPLE_ELEM_15_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) b +# define BOOST_PP_TUPLE_ELEM_15_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) c +# define BOOST_PP_TUPLE_ELEM_15_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) d +# define BOOST_PP_TUPLE_ELEM_15_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) e +# define BOOST_PP_TUPLE_ELEM_15_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) f +# define BOOST_PP_TUPLE_ELEM_15_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) g +# define BOOST_PP_TUPLE_ELEM_15_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) h +# define BOOST_PP_TUPLE_ELEM_15_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) i +# define BOOST_PP_TUPLE_ELEM_15_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) j +# define BOOST_PP_TUPLE_ELEM_15_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) k +# define BOOST_PP_TUPLE_ELEM_15_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) l +# define BOOST_PP_TUPLE_ELEM_15_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) m +# define BOOST_PP_TUPLE_ELEM_15_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) n +# define BOOST_PP_TUPLE_ELEM_15_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) o +# +# define BOOST_PP_TUPLE_ELEM_16_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) a +# define BOOST_PP_TUPLE_ELEM_16_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) b +# define BOOST_PP_TUPLE_ELEM_16_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) c +# define BOOST_PP_TUPLE_ELEM_16_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) d +# define BOOST_PP_TUPLE_ELEM_16_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) e +# define BOOST_PP_TUPLE_ELEM_16_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) f +# define BOOST_PP_TUPLE_ELEM_16_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) g +# define BOOST_PP_TUPLE_ELEM_16_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) h +# define BOOST_PP_TUPLE_ELEM_16_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) i +# define BOOST_PP_TUPLE_ELEM_16_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) j +# define BOOST_PP_TUPLE_ELEM_16_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) k +# define BOOST_PP_TUPLE_ELEM_16_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) l +# define BOOST_PP_TUPLE_ELEM_16_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) m +# define BOOST_PP_TUPLE_ELEM_16_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) n +# define BOOST_PP_TUPLE_ELEM_16_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) o +# define BOOST_PP_TUPLE_ELEM_16_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) p +# +# define BOOST_PP_TUPLE_ELEM_17_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) a +# define BOOST_PP_TUPLE_ELEM_17_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) b +# define BOOST_PP_TUPLE_ELEM_17_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) c +# define BOOST_PP_TUPLE_ELEM_17_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) d +# define BOOST_PP_TUPLE_ELEM_17_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) e +# define BOOST_PP_TUPLE_ELEM_17_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) f +# define BOOST_PP_TUPLE_ELEM_17_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) g +# define BOOST_PP_TUPLE_ELEM_17_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) h +# define BOOST_PP_TUPLE_ELEM_17_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) i +# define BOOST_PP_TUPLE_ELEM_17_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) j +# define BOOST_PP_TUPLE_ELEM_17_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) k +# define BOOST_PP_TUPLE_ELEM_17_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) l +# define BOOST_PP_TUPLE_ELEM_17_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) m +# define BOOST_PP_TUPLE_ELEM_17_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) n +# define BOOST_PP_TUPLE_ELEM_17_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) o +# define BOOST_PP_TUPLE_ELEM_17_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) p +# define BOOST_PP_TUPLE_ELEM_17_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) q +# +# define BOOST_PP_TUPLE_ELEM_18_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) a +# define BOOST_PP_TUPLE_ELEM_18_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) b +# define BOOST_PP_TUPLE_ELEM_18_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) c +# define BOOST_PP_TUPLE_ELEM_18_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) d +# define BOOST_PP_TUPLE_ELEM_18_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) e +# define BOOST_PP_TUPLE_ELEM_18_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) f +# define BOOST_PP_TUPLE_ELEM_18_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) g +# define BOOST_PP_TUPLE_ELEM_18_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) h +# define BOOST_PP_TUPLE_ELEM_18_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) i +# define BOOST_PP_TUPLE_ELEM_18_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) j +# define BOOST_PP_TUPLE_ELEM_18_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) k +# define BOOST_PP_TUPLE_ELEM_18_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) l +# define BOOST_PP_TUPLE_ELEM_18_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) m +# define BOOST_PP_TUPLE_ELEM_18_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) n +# define BOOST_PP_TUPLE_ELEM_18_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) o +# define BOOST_PP_TUPLE_ELEM_18_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) p +# define BOOST_PP_TUPLE_ELEM_18_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) q +# define BOOST_PP_TUPLE_ELEM_18_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) r +# +# define BOOST_PP_TUPLE_ELEM_19_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) a +# define BOOST_PP_TUPLE_ELEM_19_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) b +# define BOOST_PP_TUPLE_ELEM_19_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) c +# define BOOST_PP_TUPLE_ELEM_19_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) d +# define BOOST_PP_TUPLE_ELEM_19_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) e +# define BOOST_PP_TUPLE_ELEM_19_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) f +# define BOOST_PP_TUPLE_ELEM_19_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) g +# define BOOST_PP_TUPLE_ELEM_19_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) h +# define BOOST_PP_TUPLE_ELEM_19_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) i +# define BOOST_PP_TUPLE_ELEM_19_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) j +# define BOOST_PP_TUPLE_ELEM_19_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) k +# define BOOST_PP_TUPLE_ELEM_19_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) l +# define BOOST_PP_TUPLE_ELEM_19_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) m +# define BOOST_PP_TUPLE_ELEM_19_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) n +# define BOOST_PP_TUPLE_ELEM_19_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) o +# define BOOST_PP_TUPLE_ELEM_19_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) p +# define BOOST_PP_TUPLE_ELEM_19_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) q +# define BOOST_PP_TUPLE_ELEM_19_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) r +# define BOOST_PP_TUPLE_ELEM_19_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) s +# +# define BOOST_PP_TUPLE_ELEM_20_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) a +# define BOOST_PP_TUPLE_ELEM_20_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) b +# define BOOST_PP_TUPLE_ELEM_20_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) c +# define BOOST_PP_TUPLE_ELEM_20_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) d +# define BOOST_PP_TUPLE_ELEM_20_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) e +# define BOOST_PP_TUPLE_ELEM_20_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) f +# define BOOST_PP_TUPLE_ELEM_20_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) g +# define BOOST_PP_TUPLE_ELEM_20_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) h +# define BOOST_PP_TUPLE_ELEM_20_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) i +# define BOOST_PP_TUPLE_ELEM_20_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) j +# define BOOST_PP_TUPLE_ELEM_20_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) k +# define BOOST_PP_TUPLE_ELEM_20_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) l +# define BOOST_PP_TUPLE_ELEM_20_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) m +# define BOOST_PP_TUPLE_ELEM_20_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) n +# define BOOST_PP_TUPLE_ELEM_20_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) o +# define BOOST_PP_TUPLE_ELEM_20_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) p +# define BOOST_PP_TUPLE_ELEM_20_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) q +# define BOOST_PP_TUPLE_ELEM_20_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) r +# define BOOST_PP_TUPLE_ELEM_20_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) s +# define BOOST_PP_TUPLE_ELEM_20_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) t +# +# define BOOST_PP_TUPLE_ELEM_21_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) a +# define BOOST_PP_TUPLE_ELEM_21_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) b +# define BOOST_PP_TUPLE_ELEM_21_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) c +# define BOOST_PP_TUPLE_ELEM_21_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) d +# define BOOST_PP_TUPLE_ELEM_21_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) e +# define BOOST_PP_TUPLE_ELEM_21_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) f +# define BOOST_PP_TUPLE_ELEM_21_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) g +# define BOOST_PP_TUPLE_ELEM_21_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) h +# define BOOST_PP_TUPLE_ELEM_21_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) i +# define BOOST_PP_TUPLE_ELEM_21_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) j +# define BOOST_PP_TUPLE_ELEM_21_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) k +# define BOOST_PP_TUPLE_ELEM_21_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) l +# define BOOST_PP_TUPLE_ELEM_21_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) m +# define BOOST_PP_TUPLE_ELEM_21_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) n +# define BOOST_PP_TUPLE_ELEM_21_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) o +# define BOOST_PP_TUPLE_ELEM_21_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) p +# define BOOST_PP_TUPLE_ELEM_21_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) q +# define BOOST_PP_TUPLE_ELEM_21_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) r +# define BOOST_PP_TUPLE_ELEM_21_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) s +# define BOOST_PP_TUPLE_ELEM_21_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) t +# define BOOST_PP_TUPLE_ELEM_21_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) u +# +# define BOOST_PP_TUPLE_ELEM_22_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) a +# define BOOST_PP_TUPLE_ELEM_22_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) b +# define BOOST_PP_TUPLE_ELEM_22_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) c +# define BOOST_PP_TUPLE_ELEM_22_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) d +# define BOOST_PP_TUPLE_ELEM_22_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) e +# define BOOST_PP_TUPLE_ELEM_22_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) f +# define BOOST_PP_TUPLE_ELEM_22_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) g +# define BOOST_PP_TUPLE_ELEM_22_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) h +# define BOOST_PP_TUPLE_ELEM_22_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) i +# define BOOST_PP_TUPLE_ELEM_22_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) j +# define BOOST_PP_TUPLE_ELEM_22_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) k +# define BOOST_PP_TUPLE_ELEM_22_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) l +# define BOOST_PP_TUPLE_ELEM_22_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) m +# define BOOST_PP_TUPLE_ELEM_22_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) n +# define BOOST_PP_TUPLE_ELEM_22_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) o +# define BOOST_PP_TUPLE_ELEM_22_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) p +# define BOOST_PP_TUPLE_ELEM_22_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) q +# define BOOST_PP_TUPLE_ELEM_22_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) r +# define BOOST_PP_TUPLE_ELEM_22_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) s +# define BOOST_PP_TUPLE_ELEM_22_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) t +# define BOOST_PP_TUPLE_ELEM_22_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) u +# define BOOST_PP_TUPLE_ELEM_22_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) v +# +# define BOOST_PP_TUPLE_ELEM_23_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) a +# define BOOST_PP_TUPLE_ELEM_23_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) b +# define BOOST_PP_TUPLE_ELEM_23_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) c +# define BOOST_PP_TUPLE_ELEM_23_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) d +# define BOOST_PP_TUPLE_ELEM_23_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) e +# define BOOST_PP_TUPLE_ELEM_23_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) f +# define BOOST_PP_TUPLE_ELEM_23_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) g +# define BOOST_PP_TUPLE_ELEM_23_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) h +# define BOOST_PP_TUPLE_ELEM_23_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) i +# define BOOST_PP_TUPLE_ELEM_23_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) j +# define BOOST_PP_TUPLE_ELEM_23_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) k +# define BOOST_PP_TUPLE_ELEM_23_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) l +# define BOOST_PP_TUPLE_ELEM_23_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) m +# define BOOST_PP_TUPLE_ELEM_23_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) n +# define BOOST_PP_TUPLE_ELEM_23_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) o +# define BOOST_PP_TUPLE_ELEM_23_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) p +# define BOOST_PP_TUPLE_ELEM_23_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) q +# define BOOST_PP_TUPLE_ELEM_23_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) r +# define BOOST_PP_TUPLE_ELEM_23_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) s +# define BOOST_PP_TUPLE_ELEM_23_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) t +# define BOOST_PP_TUPLE_ELEM_23_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) u +# define BOOST_PP_TUPLE_ELEM_23_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) v +# define BOOST_PP_TUPLE_ELEM_23_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) w +# +# define BOOST_PP_TUPLE_ELEM_24_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) a +# define BOOST_PP_TUPLE_ELEM_24_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) b +# define BOOST_PP_TUPLE_ELEM_24_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) c +# define BOOST_PP_TUPLE_ELEM_24_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) d +# define BOOST_PP_TUPLE_ELEM_24_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) e +# define BOOST_PP_TUPLE_ELEM_24_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) f +# define BOOST_PP_TUPLE_ELEM_24_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) g +# define BOOST_PP_TUPLE_ELEM_24_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) h +# define BOOST_PP_TUPLE_ELEM_24_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) i +# define BOOST_PP_TUPLE_ELEM_24_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) j +# define BOOST_PP_TUPLE_ELEM_24_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) k +# define BOOST_PP_TUPLE_ELEM_24_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) l +# define BOOST_PP_TUPLE_ELEM_24_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) m +# define BOOST_PP_TUPLE_ELEM_24_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) n +# define BOOST_PP_TUPLE_ELEM_24_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) o +# define BOOST_PP_TUPLE_ELEM_24_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) p +# define BOOST_PP_TUPLE_ELEM_24_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) q +# define BOOST_PP_TUPLE_ELEM_24_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) r +# define BOOST_PP_TUPLE_ELEM_24_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) s +# define BOOST_PP_TUPLE_ELEM_24_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) t +# define BOOST_PP_TUPLE_ELEM_24_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) u +# define BOOST_PP_TUPLE_ELEM_24_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) v +# define BOOST_PP_TUPLE_ELEM_24_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) w +# define BOOST_PP_TUPLE_ELEM_24_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) x +# +# define BOOST_PP_TUPLE_ELEM_25_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) a +# define BOOST_PP_TUPLE_ELEM_25_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) b +# define BOOST_PP_TUPLE_ELEM_25_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) c +# define BOOST_PP_TUPLE_ELEM_25_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) d +# define BOOST_PP_TUPLE_ELEM_25_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) e +# define BOOST_PP_TUPLE_ELEM_25_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) f +# define BOOST_PP_TUPLE_ELEM_25_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) g +# define BOOST_PP_TUPLE_ELEM_25_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) h +# define BOOST_PP_TUPLE_ELEM_25_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) i +# define BOOST_PP_TUPLE_ELEM_25_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) j +# define BOOST_PP_TUPLE_ELEM_25_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) k +# define BOOST_PP_TUPLE_ELEM_25_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) l +# define BOOST_PP_TUPLE_ELEM_25_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) m +# define BOOST_PP_TUPLE_ELEM_25_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) n +# define BOOST_PP_TUPLE_ELEM_25_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) o +# define BOOST_PP_TUPLE_ELEM_25_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) p +# define BOOST_PP_TUPLE_ELEM_25_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) q +# define BOOST_PP_TUPLE_ELEM_25_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) r +# define BOOST_PP_TUPLE_ELEM_25_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) s +# define BOOST_PP_TUPLE_ELEM_25_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) t +# define BOOST_PP_TUPLE_ELEM_25_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) u +# define BOOST_PP_TUPLE_ELEM_25_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) v +# define BOOST_PP_TUPLE_ELEM_25_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) w +# define BOOST_PP_TUPLE_ELEM_25_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) x +# define BOOST_PP_TUPLE_ELEM_25_24(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) y +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/tuple/rem.hpp b/deal.II/contrib/boost/include/boost/preprocessor/tuple/rem.hpp new file mode 100644 index 0000000000..fd3e03470f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/tuple/rem.hpp @@ -0,0 +1,73 @@ +# /* ************************************************************************** +# * * +# * (C) Copyright Paul Mensonides 2002. Permission to copy, use, * +# * modify, sell, and distribute this software is granted provided * +# * this copyright notice appears in all copies. This software is * +# * provided "as is" without express or implied warranty, and with * +# * no claim at to its suitability for any purpose. * +# * * +# ************************************************************************** */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_REM_HPP +# define BOOST_PREPROCESSOR_TUPLE_REM_HPP +# +# include +# +# /* BOOST_PP_TUPLE_REM */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_TUPLE_REM(size) BOOST_PP_TUPLE_REM_I(size) +# else +# define BOOST_PP_TUPLE_REM(size) BOOST_PP_TUPLE_REM_OO((size)) +# define BOOST_PP_TUPLE_REM_OO(par) BOOST_PP_TUPLE_REM_I ## par +# endif +# +# define BOOST_PP_TUPLE_REM_I(size) BOOST_PP_TUPLE_REM_ ## size +# +# define BOOST_PP_TUPLE_REM_0() +# define BOOST_PP_TUPLE_REM_1(a) a +# define BOOST_PP_TUPLE_REM_2(a, b) a, b +# define BOOST_PP_TUPLE_REM_3(a, b, c) a, b, c +# define BOOST_PP_TUPLE_REM_4(a, b, c, d) a, b, c, d +# define BOOST_PP_TUPLE_REM_5(a, b, c, d, e) a, b, c, d, e +# define BOOST_PP_TUPLE_REM_6(a, b, c, d, e, f) a, b, c, d, e, f +# define BOOST_PP_TUPLE_REM_7(a, b, c, d, e, f, g) a, b, c, d, e, f, g +# define BOOST_PP_TUPLE_REM_8(a, b, c, d, e, f, g, h) a, b, c, d, e, f, g, h +# define BOOST_PP_TUPLE_REM_9(a, b, c, d, e, f, g, h, i) a, b, c, d, e, f, g, h, i +# define BOOST_PP_TUPLE_REM_10(a, b, c, d, e, f, g, h, i, j) a, b, c, d, e, f, g, h, i, j +# define BOOST_PP_TUPLE_REM_11(a, b, c, d, e, f, g, h, i, j, k) a, b, c, d, e, f, g, h, i, j, k +# define BOOST_PP_TUPLE_REM_12(a, b, c, d, e, f, g, h, i, j, k, l) a, b, c, d, e, f, g, h, i, j, k, l +# define BOOST_PP_TUPLE_REM_13(a, b, c, d, e, f, g, h, i, j, k, l, m) a, b, c, d, e, f, g, h, i, j, k, l, m +# define BOOST_PP_TUPLE_REM_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n) a, b, c, d, e, f, g, h, i, j, k, l, m, n +# define BOOST_PP_TUPLE_REM_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o +# define BOOST_PP_TUPLE_REM_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p +# define BOOST_PP_TUPLE_REM_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q +# define BOOST_PP_TUPLE_REM_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r +# define BOOST_PP_TUPLE_REM_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s +# define BOOST_PP_TUPLE_REM_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t +# define BOOST_PP_TUPLE_REM_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u +# define BOOST_PP_TUPLE_REM_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v +# define BOOST_PP_TUPLE_REM_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w +# define BOOST_PP_TUPLE_REM_24(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x +# define BOOST_PP_TUPLE_REM_25(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y +# +# /* BOOST_PP_TUPLE_REM_CTOR */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() +# define BOOST_PP_TUPLE_REM_CTOR(size, tuple) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_TUPLE_REM(size), tuple) +# else +# define BOOST_PP_TUPLE_REM_CTOR(size, tuple) BOOST_PP_TUPLE_REM_CTOR_D(size, tuple) +# define BOOST_PP_TUPLE_REM_CTOR_D(size, tuple) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_TUPLE_REM(size), tuple) +# endif +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_TUPLE_REM_CTOR_I(ext, tuple) ext tuple +# else +# define BOOST_PP_TUPLE_REM_CTOR_I(ext, tuple) BOOST_PP_TUPLE_REM_CTOR_OO((ext, tuple)) +# define BOOST_PP_TUPLE_REM_CTOR_OO(par) BOOST_PP_TUPLE_REM_CTOR_II ## par +# define BOOST_PP_TUPLE_REM_CTOR_II(ext, tuple) ext ## tuple +# endif +# +# endif diff --git a/deal.II/contrib/boost/include/boost/preprocessor/tuple/to_list.hpp b/deal.II/contrib/boost/include/boost/preprocessor/tuple/to_list.hpp new file mode 100644 index 0000000000..4794083fca --- /dev/null +++ b/deal.II/contrib/boost/include/boost/preprocessor/tuple/to_list.hpp @@ -0,0 +1,63 @@ +# /* Copyright (C) 2001 +# * Housemarque Oy +# * http://www.housemarque.com +# * +# * Permission to copy, use, modify, sell and distribute this software is +# * granted provided this copyright notice appears in all copies. This +# * software is provided "as is" without express or implied warranty, and +# * with no claim as to its suitability for any purpose. +# */ +# +# /* Revised by Paul Mensonides (2002) */ +# +# /* See http://www.boost.org for most recent version. */ +# +# ifndef BOOST_PREPROCESSOR_TUPLE_TO_LIST_HPP +# define BOOST_PREPROCESSOR_TUPLE_TO_LIST_HPP +# +# include +# +# /* BOOST_PP_TUPLE_TO_LIST */ +# +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() +# define BOOST_PP_TUPLE_TO_LIST(size, tuple) BOOST_PP_TUPLE_TO_LIST_I(size, tuple) +# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() +# define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_ ## s t +# else +# define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_II(BOOST_PP_TUPLE_TO_LIST_ ## s t) +# define BOOST_PP_TUPLE_TO_LIST_II(res) res +# endif +# else +# define BOOST_PP_TUPLE_TO_LIST(size, tuple) BOOST_PP_TUPLE_TO_LIST_OO((size, tuple)) +# define BOOST_PP_TUPLE_TO_LIST_OO(par) BOOST_PP_TUPLE_TO_LIST_I ## par +# define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_ ## s ## t +# endif +# +# define BOOST_PP_TUPLE_TO_LIST_0() BOOST_PP_NIL +# define BOOST_PP_TUPLE_TO_LIST_1(a) (a, BOOST_PP_NIL) +# define BOOST_PP_TUPLE_TO_LIST_2(a, b) (a, (b, BOOST_PP_NIL)) +# define BOOST_PP_TUPLE_TO_LIST_3(a, b, c) (a, (b, (c, BOOST_PP_NIL))) +# define BOOST_PP_TUPLE_TO_LIST_4(a, b, c, d) (a, (b, (c, (d, BOOST_PP_NIL)))) +# define BOOST_PP_TUPLE_TO_LIST_5(a, b, c, d, e) (a, (b, (c, (d, (e, BOOST_PP_NIL))))) +# define BOOST_PP_TUPLE_TO_LIST_6(a, b, c, d, e, f) (a, (b, (c, (d, (e, (f, BOOST_PP_NIL)))))) +# define BOOST_PP_TUPLE_TO_LIST_7(a, b, c, d, e, f, g) (a, (b, (c, (d, (e, (f, (g, BOOST_PP_NIL))))))) +# define BOOST_PP_TUPLE_TO_LIST_8(a, b, c, d, e, f, g, h) (a, (b, (c, (d, (e, (f, (g, (h, BOOST_PP_NIL)))))))) +# define BOOST_PP_TUPLE_TO_LIST_9(a, b, c, d, e, f, g, h, i) (a, (b, (c, (d, (e, (f, (g, (h, (i, BOOST_PP_NIL))))))))) +# define BOOST_PP_TUPLE_TO_LIST_10(a, b, c, d, e, f, g, h, i, j) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, BOOST_PP_NIL)))))))))) +# define BOOST_PP_TUPLE_TO_LIST_11(a, b, c, d, e, f, g, h, i, j, k) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, BOOST_PP_NIL))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_12(a, b, c, d, e, f, g, h, i, j, k, l) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, BOOST_PP_NIL)))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_13(a, b, c, d, e, f, g, h, i, j, k, l, m) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, BOOST_PP_NIL))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, BOOST_PP_NIL)))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, BOOST_PP_NIL))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, BOOST_PP_NIL)))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, BOOST_PP_NIL))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, BOOST_PP_NIL)))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, BOOST_PP_NIL))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, BOOST_PP_NIL)))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, BOOST_PP_NIL))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, BOOST_PP_NIL)))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, (w, BOOST_PP_NIL))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_24(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, (w, (x, BOOST_PP_NIL)))))))))))))))))))))))) +# define BOOST_PP_TUPLE_TO_LIST_25(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, (w, (x, (y, BOOST_PP_NIL))))))))))))))))))))))))) +# +# endif diff --git a/deal.II/contrib/boost/include/boost/ref.hpp b/deal.II/contrib/boost/include/boost/ref.hpp new file mode 100644 index 0000000000..52f01cd0b2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/ref.hpp @@ -0,0 +1,163 @@ +#ifndef BOOST_REF_HPP_INCLUDED +# define BOOST_REF_HPP_INCLUDED + +# if _MSC_VER+0 >= 1020 +# pragma once +# endif + +# include +# include +# include + +// +// ref.hpp - ref/cref, useful helper functions +// +// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) +// Copyright (C) 2001, 2002 Peter Dimov +// Copyright (C) 2002 David Abrahams +// +// Permission to copy, use, modify, sell and distribute this software +// is granted provided this copyright notice appears in all copies. +// This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. +// +// See http://www.boost.org/libs/bind/ref.html for documentation. +// + +namespace boost +{ + +template class reference_wrapper +{ +public: + typedef T type; + +#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300) + + explicit reference_wrapper(T& t): t_(&t) {} + +#else + + explicit reference_wrapper(T& t): t_(addressof(t)) {} + +#endif + + operator T& () const { return *t_; } + + T& get() const { return *t_; } + + T* get_pointer() const { return t_; } + +private: + + T* t_; +}; + +# if defined(__BORLANDC__) && (__BORLANDC__ <= 0x570) +# define BOOST_REF_CONST +# else +# define BOOST_REF_CONST const +# endif + +template inline reference_wrapper BOOST_REF_CONST ref(T & t) +{ + return reference_wrapper(t); +} + +template inline reference_wrapper BOOST_REF_CONST cref(T const & t) +{ + return reference_wrapper(t); +} + +# undef BOOST_REF_CONST + +# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +class is_reference_wrapper + : public mpl::false_ +{ +}; + +template +class is_reference_wrapper > + : public mpl::true_ +{ +}; + +template +class unwrap_reference +{ + public: + typedef T type; +}; + +template +class unwrap_reference > +{ + public: + typedef T type; +}; +# else // no partial specialization + +} // namespace boost + +#include + +namespace boost +{ + +namespace detail +{ + typedef char (&yes_reference_wrapper_t)[1]; + typedef char (&no_reference_wrapper_t)[2]; + + no_reference_wrapper_t is_reference_wrapper_test(...); + + template + yes_reference_wrapper_t is_reference_wrapper_test(type< reference_wrapper >); + + template + struct reference_unwrapper + { + template + struct apply + { + typedef T type; + }; + }; + + template<> + struct reference_unwrapper + { + template + struct apply + { + typedef typename T::type type; + }; + }; +} + +template +class is_reference_wrapper +{ + public: + BOOST_STATIC_CONSTANT( + bool, value = ( + sizeof(detail::is_reference_wrapper_test(type())) + == sizeof(detail::yes_reference_wrapper_t))); + + typedef ::boost::mpl::bool_ type; +}; + +template +class unwrap_reference + : public detail::reference_unwrapper< + is_reference_wrapper::value + >::template apply +{}; + +# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#endif // #ifndef BOOST_REF_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/shared_ptr.hpp b/deal.II/contrib/boost/include/boost/shared_ptr.hpp new file mode 100644 index 0000000000..d33eb77e82 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/shared_ptr.hpp @@ -0,0 +1,444 @@ +#ifndef BOOST_SHARED_PTR_HPP_INCLUDED +#define BOOST_SHARED_PTR_HPP_INCLUDED + +// +// shared_ptr.hpp +// +// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. +// Copyright (c) 2001, 2002, 2003 Peter Dimov +// +// Permission to copy, use, modify, sell and distribute this software +// is granted provided this copyright notice appears in all copies. +// This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. +// +// See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation. +// + +#include // for broken compiler workarounds + +#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) +#include +#else + +#include +#include +#include +#include +#include + +#include // for std::auto_ptr +#include // for std::swap +#include // for std::less +#include // for std::bad_cast +#include // for std::basic_ostream + +#ifdef BOOST_MSVC // moved here to work around VC++ compiler crash +# pragma warning(push) +# pragma warning(disable:4284) // odd return type for operator-> +#endif + +namespace boost +{ + +template class weak_ptr; +template class enable_shared_from_this; + +namespace detail +{ + +struct static_cast_tag {}; +struct dynamic_cast_tag {}; +struct polymorphic_cast_tag {}; + +template struct shared_ptr_traits +{ + typedef T & reference; +}; + +template<> struct shared_ptr_traits +{ + typedef void reference; +}; + +#if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS) + +template<> struct shared_ptr_traits +{ + typedef void reference; +}; + +#endif + +// enable_shared_from_this support + +template void sp_enable_shared_from_this(boost::enable_shared_from_this * pe, Y * px, shared_count const & pn) +{ + if(pe != 0) pe->_internal_weak_this._internal_assign(px, pn); +} + +inline void sp_enable_shared_from_this(void const *, void const *, shared_count const &) +{ +} + +} // namespace detail + + +// +// shared_ptr +// +// An enhanced relative of scoped_ptr with reference counted copy semantics. +// The object pointed to is deleted when the last shared_ptr pointing to it +// is destroyed or reset. +// + +template class shared_ptr +{ +private: + + // Borland 5.5.1 specific workaround + typedef shared_ptr this_type; + +public: + + typedef T element_type; + typedef T value_type; + typedef T * pointer; + typedef typename detail::shared_ptr_traits::reference reference; + + shared_ptr(): px(0), pn() // never throws in 1.30+ + { + } + + template + explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter()) // Y must be complete + { + detail::sp_enable_shared_from_this(p, p, pn); + } + + // + // Requirements: D's copy constructor must not throw + // + // shared_ptr will release p by calling d(p) + // + + template shared_ptr(Y * p, D d): px(p), pn(p, d) + { + detail::sp_enable_shared_from_this(p, p, pn); + } + +// generated copy constructor, assignment, destructor are fine... + +// except that Borland C++ has a bug, and g++ with -Wsynth warns +#if defined(__BORLANDC__) || defined(__GNUC__) + + shared_ptr & operator=(shared_ptr const & r) // never throws + { + px = r.px; + pn = r.pn; // shared_count::op= doesn't throw + return *this; + } + +#endif + + template + explicit shared_ptr(weak_ptr const & r): pn(r.pn) // may throw + { + // it is now safe to copy r.px, as pn(r.pn) did not throw + px = r.px; + } + + template + shared_ptr(shared_ptr const & r): px(r.px), pn(r.pn) // never throws + { + } + + template + shared_ptr(shared_ptr const & r, detail::static_cast_tag): px(static_cast(r.px)), pn(r.pn) + { + } + + template + shared_ptr(shared_ptr const & r, detail::dynamic_cast_tag): px(dynamic_cast(r.px)), pn(r.pn) + { + if(px == 0) // need to allocate new counter -- the cast failed + { + pn = detail::shared_count(); + } + } + + template + shared_ptr(shared_ptr const & r, detail::polymorphic_cast_tag): px(dynamic_cast(r.px)), pn(r.pn) + { + if(px == 0) + { + boost::throw_exception(std::bad_cast()); + } + } + +#ifndef BOOST_NO_AUTO_PTR + + template + explicit shared_ptr(std::auto_ptr & r): px(r.get()), pn() + { + Y * tmp = r.get(); + pn = detail::shared_count(r); + detail::sp_enable_shared_from_this(tmp, tmp, pn); + } + +#endif + +#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200) + + template + shared_ptr & operator=(shared_ptr const & r) // never throws + { + px = r.px; + pn = r.pn; // shared_count::op= doesn't throw + return *this; + } + +#endif + +#ifndef BOOST_NO_AUTO_PTR + + template + shared_ptr & operator=(std::auto_ptr & r) + { + this_type(r).swap(*this); + return *this; + } + +#endif + + void reset() // never throws in 1.30+ + { + this_type().swap(*this); + } + + template void reset(Y * p) // Y must be complete + { + BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors + this_type(p).swap(*this); + } + + template void reset(Y * p, D d) + { + this_type(p, d).swap(*this); + } + + reference operator* () const // never throws + { + BOOST_ASSERT(px != 0); + return *px; + } + + T * operator-> () const // never throws + { + BOOST_ASSERT(px != 0); + return px; + } + + T * get() const // never throws + { + return px; + } + + // implicit conversion to "bool" + +#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530) + + operator bool () const + { + return px != 0; + } + +#else + + typedef T * (this_type::*unspecified_bool_type)() const; + + operator unspecified_bool_type() const // never throws + { + return px == 0? 0: &this_type::get; + } + +#endif + + // operator! is redundant, but some compilers need it + + bool operator! () const // never throws + { + return px == 0; + } + + bool unique() const // never throws + { + return pn.unique(); + } + + long use_count() const // never throws + { + return pn.use_count(); + } + + void swap(shared_ptr & other) // never throws + { + std::swap(px, other.px); + pn.swap(other.pn); + } + + template bool _internal_less(shared_ptr const & rhs) const + { + return pn < rhs.pn; + } + + void * _internal_get_deleter(std::type_info const & ti) const + { + return pn.get_deleter(ti); + } + +// Tasteless as this may seem, making all members public allows member templates +// to work in the absence of member template friends. (Matthew Langston) + +#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS + +private: + + template friend class shared_ptr; + template friend class weak_ptr; + + +#endif + + T * px; // contained pointer + detail::shared_count pn; // reference counter + +}; // shared_ptr + +template inline bool operator==(shared_ptr const & a, shared_ptr const & b) +{ + return a.get() == b.get(); +} + +template inline bool operator!=(shared_ptr const & a, shared_ptr const & b) +{ + return a.get() != b.get(); +} + +#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96 + +// Resolve the ambiguity between our op!= and the one in rel_ops + +template inline bool operator!=(shared_ptr const & a, shared_ptr const & b) +{ + return a.get() != b.get(); +} + +#endif + +template inline bool operator<(shared_ptr const & a, shared_ptr const & b) +{ + return a._internal_less(b); +} + +template inline void swap(shared_ptr & a, shared_ptr & b) +{ + a.swap(b); +} + +template shared_ptr static_pointer_cast(shared_ptr const & r) +{ + return shared_ptr(r, detail::static_cast_tag()); +} + +template shared_ptr dynamic_pointer_cast(shared_ptr const & r) +{ + return shared_ptr(r, detail::dynamic_cast_tag()); +} + +// shared_*_cast names are deprecated. Use *_pointer_cast instead. + +template shared_ptr shared_static_cast(shared_ptr const & r) +{ + return shared_ptr(r, detail::static_cast_tag()); +} + +template shared_ptr shared_dynamic_cast(shared_ptr const & r) +{ + return shared_ptr(r, detail::dynamic_cast_tag()); +} + +template shared_ptr shared_polymorphic_cast(shared_ptr const & r) +{ + return shared_ptr(r, detail::polymorphic_cast_tag()); +} + +template shared_ptr shared_polymorphic_downcast(shared_ptr const & r) +{ + BOOST_ASSERT(dynamic_cast(r.get()) == r.get()); + return shared_static_cast(r); +} + +// get_pointer() enables boost::mem_fn to recognize shared_ptr + +template inline T * get_pointer(shared_ptr const & p) +{ + return p.get(); +} + +// operator<< + +#if defined(__GNUC__) && (__GNUC__ < 3) + +template std::ostream & operator<< (std::ostream & os, shared_ptr const & p) +{ + os << p.get(); + return os; +} + +#else + +# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT) +// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL +using std::basic_ostream; +template basic_ostream & operator<< (basic_ostream & os, shared_ptr const & p) +# else +template std::basic_ostream & operator<< (std::basic_ostream & os, shared_ptr const & p) +# endif +{ + os << p.get(); + return os; +} + +#endif + +// get_deleter (experimental) + +#if defined(__GNUC__) && (__GNUC__ < 3) + +// g++ 2.9x doesn't allow static_cast(void *) + +template D * get_deleter(shared_ptr const & p) +{ + void const * q = p._internal_get_deleter(typeid(D)); + return const_cast(static_cast(q)); +} + +#else + +template D * get_deleter(shared_ptr const & p) +{ + return static_cast(p._internal_get_deleter(typeid(D))); +} + +#endif + +} // namespace boost + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) + +#endif // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/static_assert.hpp b/deal.II/contrib/boost/include/boost/static_assert.hpp new file mode 100644 index 0000000000..7e53e51bb9 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/static_assert.hpp @@ -0,0 +1,91 @@ +// (C) Copyright John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org/libs/static_assert for documentation. + +/* + Revision history: + 02 August 2000 + Initial version. +*/ + +#ifndef BOOST_STATIC_ASSERT_HPP +#define BOOST_STATIC_ASSERT_HPP + +#include + +#ifdef __BORLANDC__ +// +// workaround for buggy integral-constant expression support: +#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS +#endif + +namespace boost{ + +// HP aCC cannot deal with missing names for template value parameters +template struct STATIC_ASSERTION_FAILURE; + +template <> struct STATIC_ASSERTION_FAILURE { enum { value = 1 }; }; + +// HP aCC cannot deal with missing names for template value parameters +template struct static_assert_test{}; + +} + +// +// Implicit instantiation requires that all member declarations be +// instantiated, but that the definitions are *not* instantiated. +// +// It's not particularly clear how this applies to enum's or typedefs; +// both are described as declarations [7.1.3] and [7.2] in the standard, +// however some compilers use "delayed evaluation" of one or more of +// these when implicitly instantiating templates. We use typedef declarations +// by default, but try defining BOOST_USE_ENUM_STATIC_ASSERT if the enum +// version gets better results from your compiler... +// +// Implementation: +// Both of these versions rely on sizeof(incomplete_type) generating an error +// message containing the name of the incomplete type. We use +// "STATIC_ASSERTION_FAILURE" as the type name here to generate +// an eye catching error message. The result of the sizeof expression is either +// used as an enum initialiser, or as a template argument depending which version +// is in use... +// Note that the argument to the assert is explicitly cast to bool using old- +// style casts: too many compilers currently have problems with static_cast +// when used inside integral constant expressions. +// +#if !defined(BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS) && !defined(__MWERKS__) + +#if defined(BOOST_MSVC) +// __LINE__ macro broken when -ZI is used see Q199057 +// fortunately MSVC ignores duplicate typedef's. +#define BOOST_STATIC_ASSERT( B ) \ + typedef ::boost::static_assert_test<\ + sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >)\ + > boost_static_assert_typedef_ +#elif defined(BOOST_INTEL_CXX_VERSION) +// agurt 15/sep/02: a special care is needed to force Intel C++ issue an error +// instead of warning in case of failure +# define BOOST_STATIC_ASSERT( B ) \ + typedef char BOOST_JOIN(boost_static_assert_typedef_, __LINE__) \ + [ ::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >::value ] +#else +// generic version +#define BOOST_STATIC_ASSERT( B ) \ + typedef ::boost::static_assert_test<\ + sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >)>\ + BOOST_JOIN(boost_static_assert_typedef_, __LINE__) +#endif + +#else +// alternative enum based implementation: +#define BOOST_STATIC_ASSERT( B ) \ + enum { BOOST_JOIN(boost_static_assert_enum_, __LINE__) \ + = sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >) } +#endif + + +#endif // BOOST_STATIC_ASSERT_HPP diff --git a/deal.II/contrib/boost/include/boost/throw_exception.hpp b/deal.II/contrib/boost/include/boost/throw_exception.hpp new file mode 100644 index 0000000000..3f06fcd196 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/throw_exception.hpp @@ -0,0 +1,45 @@ +#ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED +#define BOOST_THROW_EXCEPTION_HPP_INCLUDED + +#if _MSC_VER >= 1020 +#pragma once +#endif + +// +// boost/throw_exception.hpp +// +// Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// +// Permission to copy, use, modify, sell and distribute this software +// is granted provided this copyright notice appears in all copies. +// This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. +// +// http://www.boost.org/libs/utility/throw_exception.html +// + +#include + +#ifdef BOOST_NO_EXCEPTIONS +# include +#endif + +namespace boost +{ + +#ifdef BOOST_NO_EXCEPTIONS + +void throw_exception(std::exception const & e); // user defined + +#else + +template void throw_exception(E const & e) +{ + throw e; +} + +#endif + +} // namespace boost + +#endif // #ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/tuple/detail/tuple_basic.hpp b/deal.II/contrib/boost/include/boost/tuple/detail/tuple_basic.hpp new file mode 100644 index 0000000000..22478c6af3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/tuple/detail/tuple_basic.hpp @@ -0,0 +1,883 @@ +// tuple_basic.hpp ----------------------------------------------------- + +// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) +// +// Permission to copy, use, sell and distribute this software is granted +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +// For more information, see http://www.boost.org + +// Outside help: +// This and that, Gary Powell. +// Fixed return types for get_head/get_tail +// ( and other bugs ) per suggestion of Jens Maurer +// simplified element type accessors + bug fix (Jeremy Siek) +// Several changes/additions according to suggestions by Doug Gregor, +// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, +// David Abrahams. + +// Revision history: +// 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes +// 2002 04 18 Jaakko: tuple element types can be void or plain function +// types, as long as no object is created. +// Tuple objects can no hold even noncopyable types +// such as arrays. +// 2001 10 22 John Maddock +// Fixes for Borland C++ +// 2001 08 30 David Abrahams +// Added default constructor for cons<>. +// ----------------------------------------------------------------- + +#ifndef BOOST_TUPLE_BASIC_HPP +#define BOOST_TUPLE_BASIC_HPP + + +#include // needed for the assignment from pair to tuple + +#include "boost/type_traits/cv_traits.hpp" +#include "boost/type_traits/function_traits.hpp" + +namespace boost { +namespace tuples { + +// -- null_type -------------------------------------------------------- +struct null_type {}; + +// a helper function to provide a const null_type type temporary +namespace detail { + inline const null_type cnull() { return null_type(); } + + +// -- if construct ------------------------------------------------ +// Proposed by Krzysztof Czarnecki and Ulrich Eisenecker + +template struct IF { typedef Then RET; }; + +template struct IF { + typedef Else RET; +}; + +} // end detail + +// - cons forward declaration ----------------------------------------------- +template struct cons; + + +// - tuple forward declaration ----------------------------------------------- +template < + class T0 = null_type, class T1 = null_type, class T2 = null_type, + class T3 = null_type, class T4 = null_type, class T5 = null_type, + class T6 = null_type, class T7 = null_type, class T8 = null_type, + class T9 = null_type> +class tuple; + +// tuple_length forward declaration +template struct length; + + + +namespace detail { + +#ifdef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS + + template struct workaround_holder {}; + +# define BOOST_TUPLE_DUMMY_PARM , detail::workaround_holder* = 0 +# define BOOST_TUPLE_SINGLE_DUMMY_PARM detail::workaround_holder* = 0 +#else +# define BOOST_TUPLE_DUMMY_PARM +# define BOOST_TUPLE_SINGLE_DUMMY_PARM +#endif + +// -- generate error template, referencing to non-existing members of this +// template is used to produce compilation errors intentionally +template +class generate_error; + +// - cons getters -------------------------------------------------------- +// called: get_class::get(aTuple) + +template< int N > +struct get_class { + template + inline static RET get(const cons& t) + { + return get_class::BOOST_NESTED_TEMPLATE get(t.tail); + } + template + inline static RET get(cons& t) + { + return get_class::BOOST_NESTED_TEMPLATE get(t.tail); + } +}; + +template<> +struct get_class<0> { + template + inline static RET get(const cons& t) + { + return t.head; + } + template + inline static RET get(cons& t) + { + return t.head; + } +}; + +} // end of namespace detail + + +// -cons type accessors ---------------------------------------- +// typename tuples::element::type gets the type of the +// Nth element ot T, first element is at index 0 +// ------------------------------------------------------- + +template +struct element +{ +private: + typedef typename T::tail_type Next; +public: + typedef typename element::type type; +}; +template +struct element<0,T> +{ + typedef typename T::head_type type; +}; + +template +struct element +{ +private: + typedef typename T::tail_type Next; + typedef typename element::type unqualified_type; +public: + typedef typename boost::add_const::type type; +}; +template +struct element<0,const T> +{ + typedef typename boost::add_const::type type; +}; + +// -get function templates ----------------------------------------------- +// Usage: get(aTuple) + +// -- some traits classes for get functions + +// access traits lifted from detail namespace to be part of the interface, +// (Joel de Guzman's suggestion). Rationale: get functions are part of the +// interface, so should the way to express their return types be. + +template struct access_traits { + typedef const T& const_type; + typedef T& non_const_type; + + typedef const typename boost::remove_cv::type& parameter_type; + +// used as the tuple constructors parameter types +// Rationale: non-reference tuple element types can be cv-qualified. +// It should be possible to initialize such types with temporaries, +// and when binding temporaries to references, the reference must +// be non-volatile and const. 8.5.3. (5) +}; + +template struct access_traits { + + typedef T& const_type; + typedef T& non_const_type; + + typedef T& parameter_type; +}; + +// get function for non-const cons-lists, returns a reference to the element + +template +inline typename access_traits< + typename element >::type + >::non_const_type +get(cons& c BOOST_TUPLE_DUMMY_PARM) { + return detail::get_class::BOOST_NESTED_TEMPLATE + get< + typename access_traits< + typename element >::type + >::non_const_type>(c); +} + +// get function for const cons-lists, returns a const reference to +// the element. If the element is a reference, returns the reference +// as such (that is, can return a non-const reference) +template +inline typename access_traits< + typename element >::type + >::const_type +get(const cons& c BOOST_TUPLE_DUMMY_PARM) { + return detail::get_class::BOOST_NESTED_TEMPLATE + get< + typename access_traits< + typename element >::type + >::const_type>(c); +} + +// -- the cons template -------------------------------------------------- +namespace detail { + +// These helper templates wrap void types and plain function types. +// The reationale is to allow one to write tuple types with those types +// as elements, even though it is not possible to instantiate such object. +// E.g: typedef tuple some_type; // ok +// but: some_type x; // fails + +template class non_storeable_type { + non_storeable_type(); +}; + +template struct wrap_non_storeable_type { + typedef typename IF< + ::boost::is_function::value, non_storeable_type, T + >::RET type; +}; +template <> struct wrap_non_storeable_type { + typedef non_storeable_type type; +}; + +} // detail + +template +struct cons { + + typedef HT head_type; + typedef TT tail_type; + + typedef typename + detail::wrap_non_storeable_type::type stored_head_type; + + stored_head_type head; + tail_type tail; + + typename access_traits::non_const_type + get_head() { return head; } + + typename access_traits::non_const_type + get_tail() { return tail; } + + typename access_traits::const_type + get_head() const { return head; } + + typename access_traits::const_type + get_tail() const { return tail; } + + cons() : head(), tail() {} + // cons() : head(detail::default_arg::f()), tail() {} + + // the argument for head is not strictly needed, but it prevents + // array type elements. This is good, since array type elements + // cannot be supported properly in any case (no assignment, + // copy works only if the tails are exactly the same type, ...) + + cons(typename access_traits::parameter_type h, + const tail_type& t) + : head (h), tail(t) {} + + template + cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, + T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) + : head (t1), + tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull()) + {} + + template + cons( const null_type& t1, T2& t2, T3& t3, T4& t4, T5& t5, + T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) + : head (), + tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull()) + {} + + + template + cons( const cons& u ) : head(u.head), tail(u.tail) {} + + template + cons& operator=( const cons& u ) { + head=u.head; tail=u.tail; return *this; + } + + // must define assignment operator explicitly, implicit version is + // illformed if HT is a reference (12.8. (12)) + cons& operator=(const cons& u) { + head = u.head; tail = u.tail; return *this; + } + + template + cons& operator=( const std::pair& u ) { + BOOST_STATIC_ASSERT(length::value == 2); // check length = 2 + head = u.first; tail.head = u.second; return *this; + } + + // get member functions (non-const and const) + template + typename access_traits< + typename element >::type + >::non_const_type + get() { + return boost::tuples::get(*this); // delegate to non-member get + } + + template + typename access_traits< + typename element >::type + >::const_type + get() const { + return boost::tuples::get(*this); // delegate to non-member get + } +}; + +template +struct cons { + + typedef HT head_type; + typedef null_type tail_type; + typedef cons self_type; + + typedef typename + detail::wrap_non_storeable_type::type stored_head_type; + stored_head_type head; + + typename access_traits::non_const_type + get_head() { return head; } + + null_type get_tail() { return null_type(); } + + typename access_traits::const_type + get_head() const { return head; } + + const null_type get_tail() const { return null_type(); } + + // cons() : head(detail::default_arg::f()) {} + cons() : head() {} + + cons(typename access_traits::parameter_type h, + const null_type& = null_type()) + : head (h) {} + + template + cons(T1& t1, const null_type&, const null_type&, const null_type&, + const null_type&, const null_type&, const null_type&, + const null_type&, const null_type&, const null_type&) + : head (t1) {} + + cons(const null_type&, + const null_type&, const null_type&, const null_type&, + const null_type&, const null_type&, const null_type&, + const null_type&, const null_type&, const null_type&) + : head () {} + + template + cons( const cons& u ) : head(u.head) {} + + template + cons& operator=(const cons& u ) + { head = u.head; return *this; } + + // must define assignment operator explicitely, implicit version + // is illformed if HT is a reference + cons& operator=(const cons& u) { head = u.head; return *this; } + + template + typename access_traits< + typename element::type + >::non_const_type + get(BOOST_TUPLE_SINGLE_DUMMY_PARM) { + return boost::tuples::get(*this); + } + + template + typename access_traits< + typename element::type + >::const_type + get(BOOST_TUPLE_SINGLE_DUMMY_PARM) const { + return boost::tuples::get(*this); + } + +}; + +// templates for finding out the length of the tuple ------------------- + +template +struct length { + BOOST_STATIC_CONSTANT(int, value = 1 + length::value); +}; + +template<> +struct length > { + BOOST_STATIC_CONSTANT(int, value = 0); +}; + +template<> +struct length { + BOOST_STATIC_CONSTANT(int, value = 0); +}; + + +namespace detail { + +// Tuple to cons mapper -------------------------------------------------- +template +struct map_tuple_to_cons +{ + typedef cons::type + > type; +}; + +// The empty tuple is a null_type +template <> +struct map_tuple_to_cons +{ + typedef null_type type; +}; + +} // end detail + +// ------------------------------------------------------------------- +// -- tuple ------------------------------------------------------ +template + +class tuple : + public detail::map_tuple_to_cons::type +{ +public: + typedef typename + detail::map_tuple_to_cons::type inherited; + typedef typename inherited::head_type head_type; + typedef typename inherited::tail_type tail_type; + + +// access_traits::parameter_type takes non-reference types as const T& + tuple() {} + + tuple(typename access_traits::parameter_type t0) + : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1) + : inherited(t0, t1, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2) + : inherited(t0, t1, t2, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3) + : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull(), + detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4) + : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4, + typename access_traits::parameter_type t5) + : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4, + typename access_traits::parameter_type t5, + typename access_traits::parameter_type t6) + : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(), + detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4, + typename access_traits::parameter_type t5, + typename access_traits::parameter_type t6, + typename access_traits::parameter_type t7) + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(), + detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4, + typename access_traits::parameter_type t5, + typename access_traits::parameter_type t6, + typename access_traits::parameter_type t7, + typename access_traits::parameter_type t8) + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4, + typename access_traits::parameter_type t5, + typename access_traits::parameter_type t6, + typename access_traits::parameter_type t7, + typename access_traits::parameter_type t8, + typename access_traits::parameter_type t9) + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {} + + + template + tuple(const cons& p) : inherited(p) {} + + template + tuple& operator=(const cons& k) { + inherited::operator=(k); + return *this; + } + + template + tuple& operator=(const std::pair& k) { + BOOST_STATIC_ASSERT(length::value == 2);// check_length = 2 + this->head = k.first; + this->tail.head = k.second; + return *this; + } + +}; + +// The empty tuple +template <> +class tuple : + public null_type +{ +public: + typedef null_type inherited; +}; + + +// Swallows any assignment (by Doug Gregor) +namespace detail { + +struct swallow_assign { + + template + swallow_assign& operator=(const T&) { + return *this; + } +}; + +} // namespace detail + +// "ignore" allows tuple positions to be ignored when using "tie". +namespace { + detail::swallow_assign ignore; +} + +// --------------------------------------------------------------------------- +// The call_traits for make_tuple +// Honours the reference_wrapper class. + +// Must be instantiated with plain or const plain types (not with references) + +// from template foo(const T& t) : make_tuple_traits::type +// from template foo(T& t) : make_tuple_traits::type + +// Conversions: +// T -> T, +// references -> compile_time_error +// reference_wrapper -> T& +// const reference_wrapper -> T& +// array -> const ref array + + +template +struct make_tuple_traits { + typedef T type; + + // commented away, see below (JJ) + // typedef typename IF< + // boost::is_function::value, + // T&, + // T>::RET type; + +}; + +// The is_function test was there originally for plain function types, +// which can't be stored as such (we must either store them as references or +// pointers). Such a type could be formed if make_tuple was called with a +// reference to a function. +// But this would mean that a const qualified function type was formed in +// the make_tuple function and hence make_tuple can't take a function +// reference as a parameter, and thus T can't be a function type. +// So is_function test was removed. +// (14.8.3. says that type deduction fails if a cv-qualified function type +// is created. (It only applies for the case of explicitly specifying template +// args, though?)) (JJ) + +template +struct make_tuple_traits { + typedef typename + detail::generate_error:: + do_not_use_with_reference_type error; +}; + +// Arrays can't be stored as plain types; convert them to references. +// All arrays are converted to const. This is because make_tuple takes its +// parameters as const T& and thus the knowledge of the potential +// non-constness of actual argument is lost. +template struct make_tuple_traits { + typedef const T (&type)[n]; +}; + +template +struct make_tuple_traits { + typedef const T (&type)[n]; +}; + +template struct make_tuple_traits { + typedef const volatile T (&type)[n]; +}; + +template +struct make_tuple_traits { + typedef const volatile T (&type)[n]; +}; + +template +struct make_tuple_traits >{ + typedef T& type; +}; + +template +struct make_tuple_traits >{ + typedef T& type; +}; + + + + +namespace detail { + +// a helper traits to make the make_tuple functions shorter (Vesa Karvonen's +// suggestion) +template < + class T0 = null_type, class T1 = null_type, class T2 = null_type, + class T3 = null_type, class T4 = null_type, class T5 = null_type, + class T6 = null_type, class T7 = null_type, class T8 = null_type, + class T9 = null_type +> +struct make_tuple_mapper { + typedef + tuple::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type> type; +}; + +} // end detail + +// -make_tuple function templates ----------------------------------- +inline tuple<> make_tuple() { + return tuple<>(); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0) { + typedef typename detail::make_tuple_mapper::type t; + return t(t0); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1) { + typedef typename detail::make_tuple_mapper::type t; + return t(t0, t1); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2) { + typedef typename detail::make_tuple_mapper::type t; + return t(t0, t1, t2); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) { + typedef typename detail::make_tuple_mapper::type t; + return t(t0, t1, t2, t3); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4) { + typedef typename detail::make_tuple_mapper::type t; + return t(t0, t1, t2, t3, t4); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5) { + typedef typename detail::make_tuple_mapper::type t; + return t(t0, t1, t2, t3, t4, t5); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5, const T6& t6) { + typedef typename detail::make_tuple_mapper + ::type t; + return t(t0, t1, t2, t3, t4, t5, t6); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5, const T6& t6, const T7& t7) { + typedef typename detail::make_tuple_mapper + ::type t; + return t(t0, t1, t2, t3, t4, t5, t6, t7); +} + +template +inline typename detail::make_tuple_mapper + ::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5, const T6& t6, const T7& t7, + const T8& t8) { + typedef typename detail::make_tuple_mapper + ::type t; + return t(t0, t1, t2, t3, t4, t5, t6, t7, t8); +} + +template +inline typename detail::make_tuple_mapper + ::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5, const T6& t6, const T7& t7, + const T8& t8, const T9& t9) { + typedef typename detail::make_tuple_mapper + ::type t; + return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); +} + + + +// Tie function templates ------------------------------------------------- +template +inline tuple tie(T1& t1) { + return tuple (t1); +} + +template +inline tuple tie(T1& t1, T2& t2) { + return tuple (t1, t2); +} + +template +inline tuple tie(T1& t1, T2& t2, T3& t3) { + return tuple (t1, t2, t3); +} + +template +inline tuple tie(T1& t1, T2& t2, T3& t3, T4& t4) { + return tuple (t1, t2, t3, t4); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) { + return tuple (t1, t2, t3, t4, t5); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) { + return tuple (t1, t2, t3, t4, t5, t6); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) { + return tuple (t1, t2, t3, t4, t5, t6, t7); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) { + return tuple + (t1, t2, t3, t4, t5, t6, t7, t8); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, + T9& t9) { + return tuple + (t1, t2, t3, t4, t5, t6, t7, t8, t9); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, + T9& t9, T10& t10) { + return tuple + (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); +} + +} // end of namespace tuples +} // end of namespace boost + +#undef BOOST_TUPLE_DUMMY_PARM +#undef BOOST_TUPLE_SINGLE_DUMMY_PARM + +#endif // BOOST_TUPLE_BASIC_HPP + + diff --git a/deal.II/contrib/boost/include/boost/tuple/tuple.hpp b/deal.II/contrib/boost/include/boost/tuple/tuple.hpp new file mode 100644 index 0000000000..c1298222e4 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/tuple/tuple.hpp @@ -0,0 +1,95 @@ +// tuple.hpp - Boost Tuple Library -------------------------------------- + +// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) +// +// Permission to copy, use, sell and distribute this software is granted +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +// For more information, see http://www.boost.org + +// ----------------------------------------------------------------- + +#ifndef BOOST_TUPLE_HPP +#define BOOST_TUPLE_HPP + +#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 +// Work around a compiler bug. +// boost::python::tuple has to be seen by the compiler before the +// boost::tuple class template. +namespace boost { namespace python { class tuple; }} +#endif + +#include "boost/config.hpp" +#include "boost/static_assert.hpp" + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +// The MSVC version +#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp" + +#else +// other compilers +#include "boost/ref.hpp" +#include "boost/tuple/detail/tuple_basic.hpp" + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +namespace boost { + +using tuples::tuple; +using tuples::make_tuple; +using tuples::tie; +#if !defined(BOOST_NO_USING_TEMPLATE) +using tuples::get; +#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +// +// The "using tuples::get" statement causes the +// Borland compiler to ICE, use forwarding +// functions instead: +// +template +inline typename tuples::access_traits< + typename tuples::element >::type + >::non_const_type +get(tuples::cons& c) { + return tuples::get(c); +} +// get function for const cons-lists, returns a const reference to +// the element. If the element is a reference, returns the reference +// as such (that is, can return a non-const reference) +template +inline typename tuples::access_traits< + typename tuples::element >::type + >::const_type +get(const tuples::cons& c) { + return tuples::get(c); +} +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +// +// MSVC, using declarations don't mix with templates well, +// so use forwarding functions instead: +// +template +typename tuples::detail::element_ref >::RET +get(tuples::cons& t, tuples::detail::workaround_holder* = 0) +{ + return tuples::detail::get_class::get(t); +} + +template +typename tuples::detail::element_const_ref >::RET +get(const tuples::cons& t, tuples::detail::workaround_holder* = 0) +{ + return tuples::detail::get_class::get(t); +} +#endif // BOOST_NO_USING_TEMPLATE + +} // end namespace boost + + +#endif // BOOST_TUPLE_HPP diff --git a/deal.II/contrib/boost/include/boost/type_traits.hpp b/deal.II/contrib/boost/include/boost/type_traits.hpp new file mode 100644 index 0000000000..09ee9382e0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits.hpp @@ -0,0 +1,66 @@ +// (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org/libs/type_traits for documentation. +// See boost/type_traits/*.hpp for full copyright notices. + +#ifndef BOOST_TYPE_TRAITS_HPP +#define BOOST_TYPE_TRAITS_HPP + +#include "boost/type_traits/add_const.hpp" +#include "boost/type_traits/add_cv.hpp" +#include "boost/type_traits/add_pointer.hpp" +#include "boost/type_traits/add_reference.hpp" +#include "boost/type_traits/add_volatile.hpp" +#include "boost/type_traits/alignment_of.hpp" +#include "boost/type_traits/has_nothrow_assign.hpp" +#include "boost/type_traits/has_nothrow_constructor.hpp" +#include "boost/type_traits/has_nothrow_copy.hpp" +#include "boost/type_traits/has_nothrow_destructor.hpp" +#include "boost/type_traits/has_trivial_assign.hpp" +#include "boost/type_traits/has_trivial_constructor.hpp" +#include "boost/type_traits/has_trivial_copy.hpp" +#include "boost/type_traits/has_trivial_destructor.hpp" +#include "boost/type_traits/is_arithmetic.hpp" +#include "boost/type_traits/is_array.hpp" +#include "boost/type_traits/is_base_and_derived.hpp" +#include "boost/type_traits/is_class.hpp" +#include "boost/type_traits/is_compound.hpp" +#include "boost/type_traits/is_const.hpp" +#include "boost/type_traits/is_convertible.hpp" +#include "boost/type_traits/is_empty.hpp" +#include "boost/type_traits/is_enum.hpp" +#include "boost/type_traits/is_float.hpp" +#include "boost/type_traits/is_function.hpp" +#include "boost/type_traits/is_fundamental.hpp" +#include "boost/type_traits/is_integral.hpp" +#include "boost/type_traits/is_member_function_pointer.hpp" +#include "boost/type_traits/is_member_pointer.hpp" +#include "boost/type_traits/is_object.hpp" +#include "boost/type_traits/is_pod.hpp" +#include "boost/type_traits/is_polymorphic.hpp" +#include "boost/type_traits/is_pointer.hpp" +#include "boost/type_traits/is_reference.hpp" +#include "boost/type_traits/is_same.hpp" +#include "boost/type_traits/is_scalar.hpp" +#include "boost/type_traits/is_stateless.hpp" +#include "boost/type_traits/is_union.hpp" +#include "boost/type_traits/is_void.hpp" +#include "boost/type_traits/is_volatile.hpp" +#include "boost/type_traits/remove_bounds.hpp" +#include "boost/type_traits/remove_const.hpp" +#include "boost/type_traits/remove_cv.hpp" +#include "boost/type_traits/remove_pointer.hpp" +#include "boost/type_traits/remove_reference.hpp" +#include "boost/type_traits/remove_volatile.hpp" +#include "boost/type_traits/type_with_alignment.hpp" + +#include "boost/type_traits/ice.hpp" + +#endif // BOOST_TYPE_TRAITS_HPP + + + + diff --git a/deal.II/contrib/boost/include/boost/type_traits/add_const.hpp b/deal.II/contrib/boost/include/boost/type_traits/add_const.hpp new file mode 100644 index 0000000000..5c0a83fca0 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/add_const.hpp @@ -0,0 +1,48 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_ADD_CONST_HPP_INCLUDED +#define BOOST_TT_ADD_CONST_HPP_INCLUDED + +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + +// * convert a type T to const type - add_const +// this is not required since the result is always +// the same as "T const", but it does suppress warnings +// from some compilers: + +#if defined(BOOST_MSVC) +// This bogus warning will appear when add_const is applied to a +// const volatile reference because we can't detect const volatile +// references with MSVC6. +# pragma warning(push) +# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored +#endif + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_const,T,T const) + +#if defined(BOOST_MSVC) +# pragma warning(pop) +#endif + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_const,T&,T&) +#endif + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_ADD_CONST_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/add_cv.hpp b/deal.II/contrib/boost/include/boost/type_traits/add_cv.hpp new file mode 100644 index 0000000000..3f694dbafd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/add_cv.hpp @@ -0,0 +1,48 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_ADD_CV_HPP_INCLUDED +#define BOOST_TT_ADD_CV_HPP_INCLUDED + +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + +// * convert a type T to a const volatile type - add_cv +// this is not required since the result is always +// the same as "T const volatile", but it does suppress warnings +// from some compilers: + +#if defined(BOOST_MSVC) +// This bogus warning will appear when add_volatile is applied to a +// const volatile reference because we can't detect const volatile +// references with MSVC6. +# pragma warning(push) +# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored +#endif + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_cv,T,T const volatile) + +#if defined(BOOST_MSVC) +# pragma warning(pop) +#endif + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_cv,T&,T&) +#endif + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_ADD_CV_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/add_pointer.hpp b/deal.II/contrib/boost/include/boost/type_traits/add_pointer.hpp new file mode 100644 index 0000000000..66f5c5b5e2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/add_pointer.hpp @@ -0,0 +1,73 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_ADD_POINTER_HPP_INCLUDED +#define BOOST_TT_ADD_POINTER_HPP_INCLUDED + +#include "boost/type_traits/remove_reference.hpp" + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + +namespace detail { + +#ifdef __BORLANDC__ +// +// For some reason this implementation stops Borlands compiler +// from dropping cv-qualifiers, it still fails with references +// to arrays for some reason though (shrug...) (JM 20021104) +// +template +struct add_pointer_impl +{ + typedef T* type; +}; +template +struct add_pointer_impl +{ + typedef T* type; +}; +template +struct add_pointer_impl +{ + typedef T* type; +}; +template +struct add_pointer_impl +{ + typedef T* type; +}; +template +struct add_pointer_impl +{ + typedef T* type; +}; + +#else + +template +struct add_pointer_impl +{ + typedef typename remove_reference::type no_ref_type; + typedef no_ref_type* type; +}; + +#endif + +} // namespace detail + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_pointer,T,typename detail::add_pointer_impl::type) + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_ADD_POINTER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/add_reference.hpp b/deal.II/contrib/boost/include/boost/type_traits/add_reference.hpp new file mode 100644 index 0000000000..ae9feaf32f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/add_reference.hpp @@ -0,0 +1,90 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_ADD_REFERENCE_HPP_INCLUDED +#define BOOST_TT_ADD_REFERENCE_HPP_INCLUDED + +#include "boost/type_traits/is_reference.hpp" +#include "boost/detail/workaround.hpp" +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + +namespace detail { + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && defined(BOOST_MSVC6_MEMBER_TEMPLATES) + +template +struct reference_adder +{ + template struct result_ + { + typedef T& type; + }; +}; + +template <> +struct reference_adder +{ + template struct result_ + { + typedef T type; + }; +}; + +template +struct add_reference_impl +{ + typedef typename reference_adder< + ::boost::is_reference::value + >::template result_ result; + + typedef typename result::type type; +}; + +#else + +template +struct add_reference_impl +{ + typedef T& type; +}; + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&) +#endif + +#endif + +// these full specialisations are always required: +BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void,void) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const,void const) +BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void volatile,void volatile) +BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const volatile,void const volatile) +#endif + +} // namespace detail + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_reference,T,typename detail::add_reference_impl::type) + +// agurt, 07/mar/03: workaround Borland's ill-formed sensitivity to an additional +// level of indirection, here +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&) +#endif + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/add_volatile.hpp b/deal.II/contrib/boost/include/boost/type_traits/add_volatile.hpp new file mode 100644 index 0000000000..1f99fde277 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/add_volatile.hpp @@ -0,0 +1,48 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_ADD_VOLATILE_HPP_INCLUDED +#define BOOST_TT_ADD_VOLATILE_HPP_INCLUDED + +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + +// * convert a type T to volatile type - add_volatile +// this is not required since the result is always +// the same as "T volatile", but it does suppress warnings +// from some compilers: + +#if defined(BOOST_MSVC) +// This bogus warning will appear when add_volatile is applied to a +// const volatile reference because we can't detect const volatile +// references with MSVC6. +# pragma warning(push) +# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored +#endif + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_volatile,T,T volatile) + +#if defined(BOOST_MSVC) +# pragma warning(pop) +#endif + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_volatile,T&,T&) +#endif + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_ADD_VOLATILE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/alignment_of.hpp b/deal.II/contrib/boost/include/boost/type_traits/alignment_of.hpp new file mode 100644 index 0000000000..a4a5b95a6b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/alignment_of.hpp @@ -0,0 +1,99 @@ + +// (C) Copyright John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. + +#ifndef BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED +#define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED + +#include "boost/config.hpp" +#include + +// should be the last #include +#include "boost/type_traits/detail/size_t_trait_def.hpp" + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable: 4121) // alignment is sensitive to packing +#endif +#ifdef __BORLANDC__ +#pragma option push -Vx- -Ve- +#endif + +namespace boost { + +template struct alignment_of; + +// get the alignment of some arbitrary type: +namespace detail { + +template +struct alignment_of_hack +{ + char c; + T t; + alignment_of_hack(); +}; + + +template +struct alignment_logic +{ + BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S); +}; + + +template< typename T > +struct alignment_of_impl +{ + BOOST_STATIC_CONSTANT(std::size_t, value = + (::boost::detail::alignment_logic< + sizeof(detail::alignment_of_hack) - sizeof(T), + sizeof(T) + >::value)); +}; + +} // namespace detail + +BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(alignment_of,T,::boost::detail::alignment_of_impl::value) + +// references have to be treated specially, assume +// that a reference is just a special pointer: +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct alignment_of + : alignment_of +{ +}; +#endif +#ifdef __BORLANDC__ +// long double gives an incorrect value of 10 (!) +// unless we do this... +struct long_double_wrapper{ long double ld; }; +template<> struct alignment_of + : public alignment_of{}; +#endif + +// void has to be treated specially: +BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void,0) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const,0) +BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void volatile,0) +BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const volatile,0) +#endif + +} // namespace boost + +#ifdef __BORLANDC__ +#pragma option pop +#endif +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#include "boost/type_traits/detail/size_t_trait_undef.hpp" + +#endif // BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED + diff --git a/deal.II/contrib/boost/include/boost/type_traits/broken_compiler_spec.hpp b/deal.II/contrib/boost/include/boost/type_traits/broken_compiler_spec.hpp new file mode 100644 index 0000000000..87f75482f2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/broken_compiler_spec.hpp @@ -0,0 +1,104 @@ + +// Copyright (c) 2001 Aleksey Gurtovoy. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +#ifndef BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED +#define BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED + +#include "boost/mpl/aux_/lambda_support.hpp" +#include "boost/config.hpp" + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + +# define BOOST_TT_BROKEN_COMPILER_SPEC(T) /**/ + +#else + +namespace boost { namespace detail { +template< typename T > struct remove_const_impl { typedef T type; }; +template< typename T > struct remove_volatile_impl { typedef T type; }; +template< typename T > struct remove_pointer_impl { typedef T type; }; +template< typename T > struct remove_reference_impl { typedef T type; }; +}} + +// same as BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1 macro, except that it +// never gets #undef-ined +# define BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(trait,spec,result) \ +template<> struct trait##_impl \ +{ \ + typedef result type; \ +}; \ +/**/ + +# define BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T) \ + BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const,T) \ + BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const volatile,T volatile) \ + BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T volatile,T) \ + BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T const volatile,T const) \ + /**/ + +# define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T) \ + BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*,T) \ + BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_reference,T&,T) \ + /**/ + +# define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T) \ + BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T) \ + BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const) \ + BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T volatile) \ + BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const volatile) \ + /**/ + +# define BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T) \ + BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T) \ + BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T) \ + /**/ + +# define BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T) \ + BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T*) \ + BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const*) \ + BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T volatile*) \ + BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const volatile*) \ + /**/ + +# define BOOST_TT_BROKEN_COMPILER_SPEC(T) \ + namespace boost { namespace detail { \ + BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T) \ + BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T) \ + BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T*) \ + BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const*) \ + BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T volatile*) \ + BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const volatile*) \ + }} \ + /**/ + +# include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +BOOST_TT_BROKEN_COMPILER_SPEC(bool) +BOOST_TT_BROKEN_COMPILER_SPEC(char) +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +BOOST_TT_BROKEN_COMPILER_SPEC(wchar_t) +#endif +BOOST_TT_BROKEN_COMPILER_SPEC(signed char) +BOOST_TT_BROKEN_COMPILER_SPEC(unsigned char) +BOOST_TT_BROKEN_COMPILER_SPEC(signed short) +BOOST_TT_BROKEN_COMPILER_SPEC(unsigned short) +BOOST_TT_BROKEN_COMPILER_SPEC(signed int) +BOOST_TT_BROKEN_COMPILER_SPEC(unsigned int) +BOOST_TT_BROKEN_COMPILER_SPEC(signed long) +BOOST_TT_BROKEN_COMPILER_SPEC(unsigned long) +BOOST_TT_BROKEN_COMPILER_SPEC(float) +BOOST_TT_BROKEN_COMPILER_SPEC(double) +//BOOST_TT_BROKEN_COMPILER_SPEC(long double) + +// for backward compatibility +#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) \ + BOOST_TT_BROKEN_COMPILER_SPEC(T) \ +/**/ + +#endif // BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/config.hpp b/deal.II/contrib/boost/include/boost/type_traits/config.hpp new file mode 100644 index 0000000000..f19aaa728b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/config.hpp @@ -0,0 +1,34 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_CONFIG_HPP_INCLUDED +#define BOOST_TT_CONFIG_HPP_INCLUDED + +#ifndef BOOST_CONFIG_HPP +#include "boost/config.hpp" +#endif + +// +// whenever we have a conversion function with elipses +// it needs to be declared __cdecl to suppress compiler +// warnings from MS and Borland compilers (this *must* +// appear before we include is_same.hpp below): +#if defined(BOOST_MSVC) || defined(__BORLANDC__) +# define BOOST_TT_DECL __cdecl +#else +# define BOOST_TT_DECL /**/ +#endif + +# if (defined(__MWERKS__) && __MWERKS__ >= 0x3000) || (defined(BOOST_MSVC) && (BOOST_MSVC > 1301)) || defined(BOOST_NO_COMPILER_CONFIG) +# define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION +#endif + +#endif // BOOST_TT_CONFIG_HPP_INCLUDED + + diff --git a/deal.II/contrib/boost/include/boost/type_traits/cv_traits.hpp b/deal.II/contrib/boost/include/boost/type_traits/cv_traits.hpp new file mode 100644 index 0000000000..6d57c62da8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/cv_traits.hpp @@ -0,0 +1,25 @@ +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. +// +// defines traits classes for cv-qualified types: +// is_const, is_volatile, remove_const, remove_volatile, remove_cv. + +#ifndef BOOST_TT_CV_TRAITS_HPP_INCLUDED +#define BOOST_TT_CV_TRAITS_HPP_INCLUDED + +#include "boost/type_traits/add_const.hpp" +#include "boost/type_traits/add_volatile.hpp" +#include "boost/type_traits/add_cv.hpp" +#include "boost/type_traits/is_const.hpp" +#include "boost/type_traits/is_volatile.hpp" +#include "boost/type_traits/remove_const.hpp" +#include "boost/type_traits/remove_volatile.hpp" +#include "boost/type_traits/remove_cv.hpp" + +#endif // BOOST_TT_CV_TRAITS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/bool_trait_def.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/bool_trait_def.hpp new file mode 100644 index 0000000000..417e33b53c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/bool_trait_def.hpp @@ -0,0 +1,155 @@ +//----------------------------------------------------------------------------- +// boost/type_traits/detail/bool_trait_def.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +// no include guards, the header is intended for multiple inclusion! + +#include "boost/type_traits/detail/template_arity_spec.hpp" +#include "boost/mpl/bool.hpp" +#include "boost/mpl/aux_/lambda_support.hpp" +#include "boost/config.hpp" + +#if defined(__SUNPRO_CC) +# define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + typedef mpl::bool_< C > type; \ + enum { value = type::value }; \ + /**/ +# define BOOST_TT_AUX_BOOL_C_BASE(C) + +#elif defined(BOOST_MSVC) && BOOST_MSVC <= 1200 + +# define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + typedef mpl::bool_< C > base_; \ + using base_::value; \ + /**/ + +#endif + +#ifndef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL +# define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) /**/ +#endif + +#ifndef BOOST_TT_AUX_BOOL_C_BASE +# define BOOST_TT_AUX_BOOL_C_BASE(C) : mpl::bool_< C > +#endif + + +#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) \ +template< typename T > struct trait \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \ +}; \ +\ +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \ +/**/ + + +#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) \ +template< typename T1, typename T2 > struct trait \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) \ +}; \ +\ +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait) \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) \ +template<> struct trait< sp > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) \ +template<> struct trait< sp1,sp2 > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) \ +template<> struct trait##_impl< sp > \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = (C)); \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) \ +template<> struct trait##_impl< sp1,sp2 > \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = (C)); \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) \ +template< param > struct trait< sp > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) \ +template< param1, param2 > struct trait< sp > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \ +template< param > struct trait< sp1,sp2 > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) \ +template< param1, param2 > struct trait< sp1,sp2 > \ + BOOST_TT_AUX_BOOL_C_BASE(C) \ +{ \ + BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ +}; \ +/**/ + +#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \ +template< param > struct trait##_impl< sp1,sp2 > \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = (C)); \ +}; \ +/**/ + +#ifndef BOOST_NO_CV_SPECIALIZATIONS +# define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) \ + BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) \ + BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) \ + BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) \ + BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value) \ + /**/ +#else +# define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) \ + BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) \ + /**/ +#endif diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/bool_trait_undef.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/bool_trait_undef.hpp new file mode 100644 index 0000000000..d3d957c044 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/bool_trait_undef.hpp @@ -0,0 +1,32 @@ +//----------------------------------------------------------------------------- +// boost/type_traits/detail/bool_trait_undef.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +// no include guards, the header is intended for multiple inclusion! + +#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL +#undef BOOST_TT_AUX_BOOL_C_BASE +#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1 +#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2 +#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1 +#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2 +#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1 +#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1 +#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2 +#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1 +#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1 diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/cv_traits_impl.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/cv_traits_impl.hpp new file mode 100644 index 0000000000..f0e26f2dcf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/cv_traits_impl.hpp @@ -0,0 +1,62 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED +#define BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED + +#include "boost/config.hpp" + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +namespace boost { +namespace detail { + +// implementation helper: + +template struct cv_traits_imp {}; + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type; +}; + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = false); + typedef T unqualified_type; +}; + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = false); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type; +}; + +template +struct cv_traits_imp +{ + BOOST_STATIC_CONSTANT(bool, is_const = true); + BOOST_STATIC_CONSTANT(bool, is_volatile = true); + typedef T unqualified_type; +}; + +} // namespace detail +} // namespace boost + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#endif // BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/false_result.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/false_result.hpp new file mode 100644 index 0000000000..e0287cf759 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/false_result.hpp @@ -0,0 +1,26 @@ +// Copyright David Abrahams 2002. Permission to copy, use, +// modify, sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. + +#ifndef BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED +#define BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED + +#include "boost/config.hpp" + +namespace boost { +namespace type_traits { + +// Utility class which always "returns" false +struct false_result +{ + template struct result_ + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +}} // namespace boost::type_traits + +#endif // BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/ice_and.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/ice_and.hpp new file mode 100644 index 0000000000..890cb618c1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/ice_and.hpp @@ -0,0 +1,36 @@ +// (C) Copyright John Maddock and Steve Cleary 2000. +// +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED +#define BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED + +#include "boost/config.hpp" + +namespace boost { +namespace type_traits { + +template +struct ice_and; + +template +struct ice_and +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template <> +struct ice_and +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/ice_eq.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/ice_eq.hpp new file mode 100644 index 0000000000..ba91e37de6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/ice_eq.hpp @@ -0,0 +1,38 @@ +// (C) Copyright John Maddock and Steve Cleary 2000. +// +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED +#define BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED + +#include "boost/config.hpp" + +namespace boost { +namespace type_traits { + +template +struct ice_eq +{ + BOOST_STATIC_CONSTANT(bool, value = (b1 == b2)); +}; + +template +struct ice_ne +{ + BOOST_STATIC_CONSTANT(bool, value = (b1 != b2)); +}; + +#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION +template bool const ice_eq::value; +template bool const ice_ne::value; +#endif + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/ice_not.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/ice_not.hpp new file mode 100644 index 0000000000..1c04873baa --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/ice_not.hpp @@ -0,0 +1,33 @@ +// (C) Copyright John Maddock and Steve Cleary 2000. +// +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED +#define BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED + +#include "boost/config.hpp" + +namespace boost { +namespace type_traits { + +template +struct ice_not +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template <> +struct ice_not +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/ice_or.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/ice_or.hpp new file mode 100644 index 0000000000..0eca6499b3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/ice_or.hpp @@ -0,0 +1,36 @@ +// (C) Copyright John Maddock and Steve Cleary 2000. +// +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED +#define BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED + +#include "boost/config.hpp" + +namespace boost { +namespace type_traits { + +template +struct ice_or; + +template +struct ice_or +{ + BOOST_STATIC_CONSTANT(bool, value = true); +}; + +template <> +struct ice_or +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/is_function_ptr_helper.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/is_function_ptr_helper.hpp new file mode 100644 index 0000000000..0bdce95b3a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/is_function_ptr_helper.hpp @@ -0,0 +1,142 @@ + +// Copyright (C) 2000 John Maddock (john_maddock@compuserve.com) +// Copyright (C) 2002 Aleksey Gurtovoy (agurtovoy@meta-comm.com) +// +// Permission to copy and use this software is granted, +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted, +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED +#define BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" + +#if defined(BOOST_TT_PREPROCESSING_MODE) +# include "boost/preprocessor/iterate.hpp" +# include "boost/preprocessor/enum_params.hpp" +# include "boost/preprocessor/comma_if.hpp" +#endif + +namespace boost { +namespace type_traits { + +template +struct is_function_ptr_helper +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +#if !defined(BOOST_TT_PREPROCESSING_MODE) +// preprocessor-generated part, don't edit by hand! + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; + +#else + +#undef BOOST_STATIC_CONSTANT +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (0, 25, "boost/type_traits/detail/is_function_ptr_helper.hpp")) +#include BOOST_PP_ITERATE() + +#endif // BOOST_TT_PREPROCESSING_MODE + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED + +///// iteration + +#else +#define i BOOST_PP_FRAME_ITERATION(1) + +template +struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; + +#undef i +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp new file mode 100644 index 0000000000..0e2da0999d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp @@ -0,0 +1,358 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, +// Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software +// is granted provided this copyright notice appears in all copies. +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +#if !defined(BOOST_PP_IS_ITERATING) + +///// header body + +#ifndef BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED +#define BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED + +#include "boost/config.hpp" + +#if defined(BOOST_TT_PREPROCESSING_MODE) +# include "boost/preprocessor/iterate.hpp" +# include "boost/preprocessor/enum_params.hpp" +# include "boost/preprocessor/comma_if.hpp" +#endif + +namespace boost { +namespace type_traits { + +template +struct is_mem_fun_pointer_impl +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +#if !defined(BOOST_TT_PREPROCESSING_MODE) +// preprocessor-generated part, don't edit by hand! + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +#else + +#undef BOOST_STATIC_CONSTANT +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (0, 25, "boost/type_traits/detail/is_mem_fun_pointer_impl.hpp")) +#include BOOST_PP_ITERATE() + +#endif // BOOST_TT_PREPROCESSING_MODE + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED + +///// iteration + +#else +#define i BOOST_PP_FRAME_ITERATION(1) + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; + +// Metrowerks and Visual Age think this creates ambiguities +//: #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; + +template +struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; +//: #endif + + +#undef i +#endif // BOOST_PP_IS_ITERATING diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/size_t_trait_def.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/size_t_trait_def.hpp new file mode 100644 index 0000000000..d3890e897d --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/size_t_trait_def.hpp @@ -0,0 +1,60 @@ +//----------------------------------------------------------------------------- +// boost/type_traits/detail/size_t_trait_def.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +// no include guards, the header is intended for multiple inclusion! + +#include "boost/type_traits/detail/template_arity_spec.hpp" +#include "boost/mpl/size_t.hpp" +#include "boost/mpl/aux_/lambda_support.hpp" + +#include + +#if !defined(BOOST_MSVC) || BOOST_MSVC > 1200 +# define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/ +#else +# define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \ + typedef mpl::size_t< C > base_; \ + using base_::value; \ + /**/ +#endif + + +#define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) \ +template< typename T > struct trait \ + : mpl::size_t< C > \ +{ \ + BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \ +}; \ +\ +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \ +/**/ + +#define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) \ +template<> struct trait \ + : mpl::size_t< C > \ +{ \ + BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \ +}; \ +/**/ + +#define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) \ +template< param > struct trait \ + : mpl::size_t< C > \ +{ \ +}; \ +/**/ diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/size_t_trait_undef.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/size_t_trait_undef.hpp new file mode 100644 index 0000000000..cc1c608718 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/size_t_trait_undef.hpp @@ -0,0 +1,21 @@ +//----------------------------------------------------------------------------- +// boost/type_traits/detail/size_t_trait_undef.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +// no include guards, the header is intended for multiple inclusion! + +#undef BOOST_TT_AUX_SIZE_T_TRAIT_DEF1 +#undef BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1 +#undef BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1 diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/template_arity_spec.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/template_arity_spec.hpp new file mode 100644 index 0000000000..81e79217de --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/template_arity_spec.hpp @@ -0,0 +1,40 @@ +//----------------------------------------------------------------------------- +// boost/type_traits/detail/template_arity_spec.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +// no include guards, the header is intended for multiple inclusion! + +#include "boost/mpl/aux_/template_arity_fwd.hpp" +#include "boost/mpl/aux_/preprocessor/params.hpp" +#include "boost/mpl/aux_/lambda_support.hpp" +#include "boost/mpl/aux_/config/overload_resolution.hpp" +#include "boost/config.hpp" + +#if defined(BOOST_MPL_NO_FULL_LAMBDA_SUPPORT) && \ + defined(BOOST_MPL_BROKEN_OVERLOAD_RESOLUTION) +# define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) \ +namespace mpl { namespace aux { \ +template< BOOST_MPL_PP_PARAMS(i, typename T) > \ +struct template_arity< \ + name< BOOST_MPL_PP_PARAMS(i, T) > \ + > \ +{ \ + BOOST_STATIC_CONSTANT(int, value = i ); \ +}; \ +}} \ +/**/ +#else +# define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) /**/ +#endif diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/type_trait_def.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/type_trait_def.hpp new file mode 100644 index 0000000000..0b5d492ad1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/type_trait_def.hpp @@ -0,0 +1,66 @@ +//----------------------------------------------------------------------------- +// boost/type_traits/detail/type_trait_def.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +// no include guards, the header is intended for multiple inclusion! + +#include "boost/type_traits/detail/template_arity_spec.hpp" +#include "boost/mpl/aux_/lambda_support.hpp" + +#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) \ +template< typename T > struct trait \ +{ \ + typedef result type; \ + BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \ +}; \ +\ +BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \ +/**/ + +#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) \ +template<> struct trait \ +{ \ + typedef result type; \ + BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \ +}; \ +/**/ + +#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) \ +template<> struct trait##_impl \ +{ \ + typedef result type; \ +}; \ +/**/ + +#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) \ +template< param > struct trait \ +{ \ + typedef result type; \ +}; \ +/**/ + +#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) \ +template< param1, param2 > struct trait \ +{ \ + typedef result; \ +}; \ +/**/ + +#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) \ +template< param > struct trait##_impl \ +{ \ + typedef result type; \ +}; \ +/**/ diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/type_trait_undef.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/type_trait_undef.hpp new file mode 100644 index 0000000000..9259e6a1f6 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/type_trait_undef.hpp @@ -0,0 +1,24 @@ +//----------------------------------------------------------------------------- +// boost/type_traits/detail/type_trait_undef.hpp header file +// See http://www.boost.org for updates, documentation, and revision history. +//----------------------------------------------------------------------------- +// +// Copyright (c) 2002 +// Aleksey Gurtovoy +// +// Permission to use, copy, modify, distribute and sell this software +// and its documentation for any purpose is hereby granted without fee, +// provided that the above copyright notice appears in all copies and +// that both the copyright notice and this permission notice appear in +// supporting documentation. No representations are made about the +// suitability of this software for any purpose. It is provided "as is" +// without express or implied warranty. + +// no include guards, the header is intended for multiple inclusion! + +#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1 +#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1 +#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1 +#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1 +#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2 +#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1 diff --git a/deal.II/contrib/boost/include/boost/type_traits/detail/yes_no_type.hpp b/deal.II/contrib/boost/include/boost/type_traits/detail/yes_no_type.hpp new file mode 100644 index 0000000000..2bc4f191a1 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/detail/yes_no_type.hpp @@ -0,0 +1,27 @@ + +// (C) Copyright John Maddock and Steve Cleary 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. + +// See http://www.boost.org for most recent version including documentation. +// +// macros and helpers for working with integral-constant-expressions. + +#ifndef BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED +#define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED + +namespace boost { +namespace type_traits { + +typedef char yes_type; +struct no_type +{ + char padding[8]; +}; + +} // namespace type_traits +} // namespace boost + +#endif // BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/function_traits.hpp b/deal.II/contrib/boost/include/boost/type_traits/function_traits.hpp new file mode 100644 index 0000000000..c38d76e213 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/function_traits.hpp @@ -0,0 +1,237 @@ + +// Copyright (C) 2000 John Maddock (john_maddock@compuserve.com) +// +// Permission to copy and use this software is granted, +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted, +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +#ifndef BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED +#define BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED + +#include +#include +#include + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +namespace detail { + +template struct function_traits_helper; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(int, arity = 0); + typedef R result_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(int, arity = 1); + typedef R result_type; + typedef T1 arg1_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(int, arity = 2); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(int, arity = 3); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(int, arity = 4); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(int, arity = 5); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(int, arity = 6); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; + typedef T6 arg6_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(int, arity = 7); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; + typedef T6 arg6_type; + typedef T7 arg7_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(int, arity = 8); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; + typedef T6 arg6_type; + typedef T7 arg7_type; + typedef T8 arg8_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(int, arity = 9); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; + typedef T6 arg6_type; + typedef T7 arg7_type; + typedef T8 arg8_type; + typedef T9 arg9_type; +}; + +template +struct function_traits_helper +{ + BOOST_STATIC_CONSTANT(int, arity = 10); + typedef R result_type; + typedef T1 arg1_type; + typedef T2 arg2_type; + typedef T3 arg3_type; + typedef T4 arg4_type; + typedef T5 arg5_type; + typedef T6 arg6_type; + typedef T7 arg7_type; + typedef T8 arg8_type; + typedef T9 arg9_type; + typedef T10 arg10_type; +}; + +} // end namespace detail + +template +struct function_traits : + public detail::function_traits_helper::type> +{ +}; + +#else + +namespace detail { + +template +struct type_of_size +{ + char elements[N]; +}; + +template +type_of_size<1> function_arity_helper(R (*f)()); + +template +type_of_size<2> function_arity_helper(R (*f)(T1)); + +template +type_of_size<3> function_arity_helper(R (*f)(T1, T2)); + +template +type_of_size<4> function_arity_helper(R (*f)(T1, T2, T3)); + +template +type_of_size<5> function_arity_helper(R (*f)(T1, T2, T3, T4)); + +template +type_of_size<6> function_arity_helper(R (*f)(T1, T2, T3, T4, T5)); + +template +type_of_size<7> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6)); + +template +type_of_size<8> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7)); + +template +type_of_size<9> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8)); + +template +type_of_size<10> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, + T9)); + +template +type_of_size<11> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, + T9, T10)); +} // end namespace detail + +// Won't work with references +template +struct function_traits +{ + BOOST_STATIC_CONSTANT(int, arity = (sizeof(detail::function_arity_helper((Function*)0))-1)); +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +} + +#endif // BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_assign.hpp b/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_assign.hpp new file mode 100644 index 0000000000..a4a853176f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_assign.hpp @@ -0,0 +1,26 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED + +#include "boost/type_traits/has_trivial_assign.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_assign,T,::boost::has_trivial_assign::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_constructor.hpp b/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_constructor.hpp new file mode 100644 index 0000000000..c60c0cbb6a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_constructor.hpp @@ -0,0 +1,26 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED + +#include "boost/type_traits/has_trivial_constructor.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_constructor,T,::boost::has_trivial_constructor::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_copy.hpp b/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_copy.hpp new file mode 100644 index 0000000000..224b154863 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_copy.hpp @@ -0,0 +1,26 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED +#define BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED + +#include "boost/type_traits/has_trivial_copy.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_copy,T,::boost::has_trivial_copy::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_destructor.hpp b/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_destructor.hpp new file mode 100644 index 0000000000..9eea57e0d8 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/has_nothrow_destructor.hpp @@ -0,0 +1,26 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED + +#include "boost/type_traits/has_trivial_destructor.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_destructor,T,::boost::has_trivial_destructor::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/has_trivial_assign.hpp b/deal.II/contrib/boost/include/boost/type_traits/has_trivial_assign.hpp new file mode 100644 index 0000000000..c4f6b45521 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/has_trivial_assign.hpp @@ -0,0 +1,51 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" +#include "boost/type_traits/intrinsics.hpp" +#include "boost/type_traits/is_pod.hpp" +#include "boost/type_traits/is_const.hpp" +#include "boost/type_traits/is_volatile.hpp" +#include "boost/type_traits/detail/ice_and.hpp" +#include "boost/type_traits/detail/ice_or.hpp" +#include "boost/type_traits/detail/ice_not.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +template +struct has_trivial_assign_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_or< + ::boost::is_pod::value, + BOOST_HAS_TRIVIAL_ASSIGN(T) + >::value, + ::boost::type_traits::ice_not< ::boost::is_const::value >::value, + ::boost::type_traits::ice_not< ::boost::is_volatile::value >::value + >::value)); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_assign,T,::boost::detail::has_trivial_assign_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/has_trivial_constructor.hpp b/deal.II/contrib/boost/include/boost/type_traits/has_trivial_constructor.hpp new file mode 100644 index 0000000000..d867251baf --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/has_trivial_constructor.hpp @@ -0,0 +1,43 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" +#include "boost/type_traits/intrinsics.hpp" +#include "boost/type_traits/is_pod.hpp" +#include "boost/type_traits/detail/ice_or.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +template +struct has_trivial_ctor_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_pod::value, + BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) + >::value)); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_constructor,T,::boost::detail::has_trivial_ctor_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/has_trivial_copy.hpp b/deal.II/contrib/boost/include/boost/type_traits/has_trivial_copy.hpp new file mode 100644 index 0000000000..8decc67f63 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/has_trivial_copy.hpp @@ -0,0 +1,49 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" +#include "boost/type_traits/intrinsics.hpp" +#include "boost/type_traits/is_volatile.hpp" +#include "boost/type_traits/is_pod.hpp" +#include "boost/type_traits/detail/ice_and.hpp" +#include "boost/type_traits/detail/ice_or.hpp" +#include "boost/type_traits/detail/ice_not.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +template +struct has_trivial_copy_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_or< + ::boost::is_pod::value, + BOOST_HAS_TRIVIAL_COPY(T) + >::value, + ::boost::type_traits::ice_not< ::boost::is_volatile::value >::value + >::value)); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_copy,T,::boost::detail::has_trivial_copy_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/has_trivial_destructor.hpp b/deal.II/contrib/boost/include/boost/type_traits/has_trivial_destructor.hpp new file mode 100644 index 0000000000..7e3bbf1d28 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/has_trivial_destructor.hpp @@ -0,0 +1,43 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED +#define BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" +#include "boost/type_traits/intrinsics.hpp" +#include "boost/type_traits/is_pod.hpp" +#include "boost/type_traits/detail/ice_or.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +template +struct has_trivial_dtor_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_pod::value, + BOOST_HAS_TRIVIAL_DESTRUCTOR(T) + >::value)); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_destructor,T,::boost::detail::has_trivial_dtor_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/ice.hpp b/deal.II/contrib/boost/include/boost/type_traits/ice.hpp new file mode 100644 index 0000000000..0195136090 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/ice.hpp @@ -0,0 +1,21 @@ + +// (C) Copyright John Maddock and Steve Cleary 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// See http://www.boost.org for most recent version including documentation. +// +// macros and helpers for working with integral-constant-expressions. + +#ifndef BOOST_TT_ICE_HPP_INCLUDED +#define BOOST_TT_ICE_HPP_INCLUDED + +#include "boost/type_traits/detail/yes_no_type.hpp" +#include "boost/type_traits/detail/ice_or.hpp" +#include "boost/type_traits/detail/ice_and.hpp" +#include "boost/type_traits/detail/ice_not.hpp" +#include "boost/type_traits/detail/ice_eq.hpp" + +#endif // BOOST_TT_ICE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/intrinsics.hpp b/deal.II/contrib/boost/include/boost/type_traits/intrinsics.hpp new file mode 100644 index 0000000000..f5da3ef256 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/intrinsics.hpp @@ -0,0 +1,90 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_INTRINSICS_HPP_INCLUDED +#define BOOST_TT_INTRINSICS_HPP_INCLUDED + +#ifndef BOOST_TT_CONFIG_HPP_INCLUDED +#include "boost/type_traits/config.hpp" +#endif + +// +// Helper macros for builtin compiler support. +// If your compiler has builtin support for any of the following +// traits concepts, then redefine the appropriate macros to pick +// up on the compiler support: +// +// (these should largely ignore cv-qualifiers) +// BOOST_IS_UNION(T) should evaluate to true if T is a union type +// BOOST_IS_POD(T) should evaluate to true if T is a POD type +// BOOST_IS_EMPTY(T) should evaluate to true if T is an empty struct or union +// BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect +// BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy +// BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy +// BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect + +#ifdef BOOST_HAS_SGI_TYPE_TRAITS + // Hook into SGI's __type_traits class, this will pick up user supplied + // specializations as well as SGI - compiler supplied specializations. +# include "boost/type_traits/is_same.hpp" +# include +# define BOOST_IS_POD(T) ::boost::is_same< typename ::__type_traits::is_POD_type, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ::boost::is_same< typename ::__type_traits::has_trivial_default_constructor, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_COPY(T) ::boost::is_same< typename ::__type_traits::has_trivial_copy_constructor, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_ASSIGN(T) ::boost::is_same< typename ::__type_traits::has_trivial_assignment_operator, ::__true_type>::value +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) ::boost::is_same< typename ::__type_traits::has_trivial_destructor, ::__true_type>::value +#endif + +#if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000) + // Metrowerks compiler is acquiring intrinsic type traits support + // post version 8. We hook into the published interface to pick up + // user defined specializations as well as compiler intrinsics as + // and when they become available: +# include +# define BOOST_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union::value +# define BOOST_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD::value +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor::value +# define BOOST_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor::value +# define BOOST_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment::value +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor::value +#endif + +#ifndef BOOST_IS_UNION +# define BOOST_IS_UNION(T) false +#endif + +#ifndef BOOST_IS_POD +# define BOOST_IS_POD(T) false +#endif + +#ifndef BOOST_IS_EMPTY +# define BOOST_IS_EMPTY(T) false +#endif + +#ifndef BOOST_HAS_TRIVIAL_CONSTRUCTOR +# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false +#endif + +#ifndef BOOST_HAS_TRIVIAL_COPY +# define BOOST_HAS_TRIVIAL_COPY(T) false +#endif + +#ifndef BOOST_HAS_TRIVIAL_ASSIGN +# define BOOST_HAS_TRIVIAL_ASSIGN(T) false +#endif + +#ifndef BOOST_HAS_TRIVIAL_DESTRUCTOR +# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false +#endif + +#endif // BOOST_TT_INTRINSICS_HPP_INCLUDED + + + + diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_arithmetic.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_arithmetic.hpp new file mode 100644 index 0000000000..21c87ae587 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_arithmetic.hpp @@ -0,0 +1,44 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED +#define BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED + +#include "boost/type_traits/is_integral.hpp" +#include "boost/type_traits/is_float.hpp" +#include "boost/type_traits/detail/ice_or.hpp" +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +template< typename T > +struct is_arithmetic_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_integral::value, + ::boost::is_float::value + >::value)); +}; + +} // namespace detail + +//* is a type T an arithmetic type described in the standard (3.9.1p8) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_arithmetic,T,::boost::detail::is_arithmetic_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_array.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_array.hpp new file mode 100644 index 0000000000..b2fb26111b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_array.hpp @@ -0,0 +1,79 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_ARRAY_HPP_INCLUDED +#define BOOST_TT_IS_ARRAY_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" + +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# include "boost/type_traits/detail/yes_no_type.hpp" +# include "boost/type_traits/detail/wrap.hpp" +#endif + +#include + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T[N],true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T const[N],true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T volatile[N],true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T const volatile[N],true) + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +namespace detail { + +using ::boost::type_traits::yes_type; +using ::boost::type_traits::no_type; +using ::boost::type_traits::wrap; + +template< typename T > T(* is_array_tester1(wrap) )(wrap); +char BOOST_TT_DECL is_array_tester1(...); + +template< typename T> no_type is_array_tester2(T(*)(wrap)); +yes_type BOOST_TT_DECL is_array_tester2(...); + +template< typename T > +struct is_array_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + sizeof(::boost::detail::is_array_tester2( + ::boost::detail::is_array_tester1( + ::boost::type_traits::wrap() + ) + )) == 1 + ); +}; + +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void const volatile,false) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,::boost::detail::is_array_impl::value) + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_ARRAY_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_base_and_derived.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_base_and_derived.hpp new file mode 100644 index 0000000000..05e4f34b27 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_base_and_derived.hpp @@ -0,0 +1,207 @@ + +// (C) Copyright Rani Sharoni 2003. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED +#define BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED + +#include "boost/type_traits/is_class.hpp" +#include "boost/type_traits/is_same.hpp" +#include "boost/type_traits/is_convertible.hpp" +#include "boost/type_traits/detail/ice_and.hpp" +#include "boost/type_traits/remove_cv.hpp" +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)) \ + && !BOOST_WORKAROUND(__SUNPRO_CC , BOOST_TESTED_AT(0x540)) \ + && !BOOST_WORKAROUND(__EDG_VERSION__, <= 243) + // The EDG version number is a lower estimate. + // It is not currently known which EDG version + // exactly fixes the problem. + +/************************************************************************* + +This version detects ambiguous base classes and private base classes +correctly, and was devised by Rani Sharoni. + +Explanation by Terje Slettebø and Rani Sharoni. + +Let's take the multiple base class below as an example, and the following +will also show why there's not a problem with private or ambiguous base +class: + +struct B {}; +struct B1 : B {}; +struct B2 : B {}; +struct D : private B1, private B2 {}; + +is_base_and_derived::value; + +First, some terminology: + +SC - Standard conversion +UDC - User-defined conversion + +A user-defined conversion sequence consists of an SC, followed by an UDC, +followed by another SC. Either SC may be the identity conversion. + +When passing the default-constructed Host object to the overloaded check() +functions (initialization 8.5/14/4/3), we have several viable implicit +conversion sequences: + +For "static no_type check(B const volatile *, int)" we have the conversion +sequences: + +C -> C const (SC - Qualification Adjustment) -> B const volatile* (UDC) +C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* -> + B const volatile* (SC - Conversion) + +For "static yes_type check(D const volatile *, T)" we have the conversion +sequence: + +C -> D const volatile* (UDC) + +According to 13.3.3.1/4, in context of user-defined conversion only the +standard conversion sequence is considered when selecting the best viable +function, so it only considers up to the user-defined conversion. For the +first function this means choosing between C -> C const and C -> C, and it +chooses the latter, because it's a proper subset (13.3.3.2/3/2) of the +former. Therefore, we have: + +C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* -> + B const volatile* (SC - Conversion) +C -> D const volatile* (UDC) + +Here, the principle of the "shortest subsequence" applies again, and it +chooses C -> D const volatile*. This shows that it doesn't even need to +consider the multiple paths to B, or accessibility, as that possibility is +eliminated before it could possibly cause ambiguity or access violation. + +If D is not derived from B, it has to choose between C -> C const -> B const +volatile* for the first function, and C -> D const volatile* for the second +function, which are just as good (both requires a UDC, 13.3.3.2), had it not +been for the fact that "static no_type check(B const volatile *, int)" is +not templated, which makes C -> C const -> B const volatile* the best choice +(13.3.3/1/4), resulting in "no". + +Also, if Host::operator B const volatile* hadn't been const, the two +conversion sequences for "static no_type check(B const volatile *, int)", in +the case where D is derived from B, would have been ambiguous. + +See also +http://groups.google.com/groups?selm=df893da6.0301280859.522081f7%40posting. +google.com and links therein. + +*************************************************************************/ + +template +struct bd_helper +{ + template + static type_traits::yes_type check(D const volatile *, T); + static type_traits::no_type check(B const volatile *, int); +}; + +template +struct is_base_and_derived_impl2 +{ + struct Host + { + operator B const volatile *() const; + operator D const volatile *(); + }; + + BOOST_STATIC_CONSTANT(bool, value = + sizeof(bd_helper::check(Host(), 0)) == sizeof(type_traits::yes_type)); +}; + +#else + +// +// broken version: +// +template +struct is_base_and_derived_impl2 +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::is_convertible::value)); +}; + +#define BOOST_BROKEN_IS_BASE_AND_DERIVED + +#endif + +template +struct is_base_and_derived_impl3 +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct is_base_and_derived_select +{ + template + struct rebind + { + typedef is_base_and_derived_impl3 type; + }; +}; + +template <> +struct is_base_and_derived_select +{ + template + struct rebind + { + typedef is_base_and_derived_impl2 type; + }; +}; + +template +struct is_base_and_derived_impl +{ + typedef typename remove_cv::type ncvB; + typedef typename remove_cv::type ncvD; + + typedef is_base_and_derived_select< + ::boost::is_class::value, + ::boost::is_class::value, + ::boost::is_same::value> selector; + typedef typename selector::template rebind binder; + typedef typename binder::type bound_type; + + BOOST_STATIC_CONSTANT(bool, value = bound_type::value); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF2( + is_base_and_derived + , Base + , Derived + , (::boost::detail::is_base_and_derived_impl::value) + ) + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base,Derived&,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived&,false) +#endif + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_class.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_class.hpp new file mode 100644 index 0000000000..15d8df9ef2 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_class.hpp @@ -0,0 +1,99 @@ +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000-2002. Permission to copy, use, +// modify, sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_CLASS_HPP_INCLUDED +#define BOOST_TT_IS_CLASS_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" +# include "boost/type_traits/is_union.hpp" +# include "boost/type_traits/detail/ice_and.hpp" +# include "boost/type_traits/detail/ice_not.hpp" + +#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION +# include "boost/type_traits/detail/yes_no_type.hpp" +#else +# include "boost/type_traits/is_scalar.hpp" +# include "boost/type_traits/is_array.hpp" +# include "boost/type_traits/is_reference.hpp" +# include "boost/type_traits/is_void.hpp" +# include "boost/type_traits/is_function.hpp" +#endif + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION + +// This is actually the conforming implementation which works with +// abstract classes. However, enough compilers have trouble with +// it that most will use the one in +// boost/type_traits/object_traits.hpp. This implementation +// actually works with VC7.0, but other interactions seem to fail +// when we use it. + +// is_class<> metafunction due to Paul Mensonides +// (leavings@attbi.com). For more details: +// http://groups.google.com/groups?hl=en&selm=000001c1cc83%24e154d5e0%247772e50c%40c161550a&rnum=1 + +template +struct is_class_impl +{ + template static ::boost::type_traits::yes_type is_class_tester(void(U::*)(void)); + template static ::boost::type_traits::no_type is_class_tester(...); + + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + sizeof(is_class_tester(0)) == sizeof(::boost::type_traits::yes_type), + ::boost::type_traits::ice_not< ::boost::is_union::value >::value + >::value) + ); +}; + +#else + +template +struct is_class_impl +{ +# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< ::boost::is_union::value >::value, + ::boost::type_traits::ice_not< ::boost::is_scalar::value >::value, + ::boost::type_traits::ice_not< ::boost::is_array::value >::value, + ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, + ::boost::type_traits::ice_not< ::boost::is_void::value >::value, + ::boost::type_traits::ice_not< ::boost::is_function::value >::value + >::value)); +# else + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< ::boost::is_union::value >::value, + ::boost::type_traits::ice_not< ::boost::is_scalar::value >::value, + ::boost::type_traits::ice_not< ::boost::is_array::value >::value, + ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, + ::boost::type_traits::ice_not< ::boost::is_void::value >::value + >::value)); +# endif +}; + +# endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_class,T,::boost::detail::is_class_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_CLASS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_compound.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_compound.hpp new file mode 100644 index 0000000000..88c1419fb5 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_compound.hpp @@ -0,0 +1,41 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_COMPOUND_HPP_INCLUDED +#define BOOST_TT_IS_COMPOUND_HPP_INCLUDED + +#include "boost/config.hpp" +#include "boost/type_traits/is_fundamental.hpp" +#include "boost/type_traits/detail/ice_not.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +template +struct is_compound_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_not< + ::boost::is_fundamental::value + >::value)); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_compound,T,::boost::detail::is_compound_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_COMPOUND_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_const.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_const.hpp new file mode 100644 index 0000000000..662715d061 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_const.hpp @@ -0,0 +1,124 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_CONST_HPP_INCLUDED +#define BOOST_TT_IS_CONST_HPP_INCLUDED + +#include "boost/config.hpp" + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# include "boost/type_traits/detail/cv_traits_impl.hpp" +# ifdef __GNUC__ +# include +# endif +#else +# include "boost/type_traits/is_reference.hpp" +# include "boost/type_traits/is_array.hpp" +# include "boost/type_traits/detail/yes_no_type.hpp" +# include "boost/type_traits/detail/false_result.hpp" +#endif + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +//* is a type T declared const - is_const +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::cv_traits_imp::is_const) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T&,false) + +#if defined(__BORLANDC__) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const volatile,false) +#endif + +#if defined(__GNUC__) && (__GNUC__ < 3) +// special case for gcc where illegally cv-qualified reference types can be +// generated in some corner cases: +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T const,!(::boost::is_reference::value)) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T volatile const,!(::boost::is_reference::value)) +#endif + +#else + +namespace detail { + +using ::boost::type_traits::yes_type; +using ::boost::type_traits::no_type; + +yes_type is_const_tester(const volatile void*); +no_type is_const_tester(volatile void *); + +template +struct is_const_helper + : ::boost::type_traits::false_result +{ +}; + +template <> +struct is_const_helper +{ + template struct result_ + { + static T* t; + BOOST_STATIC_CONSTANT(bool, value = ( + sizeof(detail::yes_type) == sizeof(detail::is_const_tester(t)) + )); + }; +}; + +template <> +struct is_const_helper +{ + template struct result_ + { + static T t; + BOOST_STATIC_CONSTANT(bool, value = ( + sizeof(detail::yes_type) == sizeof(detail::is_const_tester(&t)) + )); + }; +}; + +template +struct is_const_impl + : is_const_helper< + is_reference::value + , is_array::value + >::template result_ +{ +}; + +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void const,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void const volatile,true) +#endif + +} // namespace detail + +//* is a type T declared const - is_const +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::is_const_impl::value) + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_CONST_HPP_INCLUDED + diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_convertible.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_convertible.hpp new file mode 100644 index 0000000000..6eb098b0af --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_convertible.hpp @@ -0,0 +1,287 @@ + +// Copyright (C) 2000 John Maddock (john_maddock@compuserve.com) +// Copyright (C) 2000 Jeremy Siek (jsiek@lsc.nd.edu) +// Copyright (C) 1999, 2000 Jaakko J„rvi (jaakko.jarvi@cs.utu.fi) +// +// Permission to copy and use this software is granted, +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted, +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. +// + +#ifndef BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED +#define BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED + +#include "boost/type_traits/detail/yes_no_type.hpp" +#include "boost/type_traits/config.hpp" +#include "boost/type_traits/is_array.hpp" +#include "boost/type_traits/add_reference.hpp" +#include "boost/type_traits/ice.hpp" + +#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) +# include "boost/type_traits/is_void.hpp" +#endif + +// should be always the last #include directive +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +// is one type convertable to another? +// +// there are multiple versions of the is_convertible +// template, almost every compiler seems to require its +// own version. +// +// Thanks to Andrei Alexandrescu for the original version of the +// conversion detection technique! +// + +namespace detail { + +// MS specific version: + +#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) + +// This workaround is necessary to handle when From is void +// which is normally taken care of by the partial specialization +// of the is_convertible typename. +using ::boost::type_traits::yes_type; +using ::boost::type_traits::no_type; + +template< typename From > +struct does_conversion_exist +{ + template< typename To > struct result_ + { + static no_type BOOST_TT_DECL _m_check(...); + static yes_type BOOST_TT_DECL _m_check(To); + static From _m_from; + enum { value = sizeof( _m_check(_m_from) ) == sizeof(yes_type) }; + }; +}; + +template<> +struct does_conversion_exist +{ + template< typename To > struct result_ + { + enum { value = ::boost::is_void::value }; + }; +}; + +template +struct is_convertible_basic_impl + : does_conversion_exist::template result_ +{ +}; + +#elif defined(__BORLANDC__) && (__BORLANDC__ < 0x560) +// +// special version for Borland compilers +// this version breaks when used for some +// UDT conversions: +// +template +struct is_convertible_impl +{ +#pragma option push -w-8074 + // This workaround for Borland breaks the EDG C++ frontend, + // so we only use it for Borland. + template struct checker + { + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(T); + }; + + static From _m_from; + static bool const value = sizeof( checker::_m_check(_m_from) ) + == sizeof(::boost::type_traits::yes_type); +#pragma option pop +}; + +#elif defined(__GNUC__) || defined(__BORLANDC__) +// special version for gcc compiler + recent Borland versions +// note that this does not pass UDT's through (...) + +struct any_conversion +{ + template any_conversion(const volatile T&); + //template any_conversion(T&); +}; + +template struct checker +{ + static boost::type_traits::no_type _m_check(any_conversion ...); + static boost::type_traits::yes_type _m_check(T, int); +}; + +template +struct is_convertible_basic_impl +{ + static From _m_from; + static bool const value = sizeof( detail::checker::_m_check(_m_from, 0) ) + == sizeof(::boost::type_traits::yes_type); +}; + +#elif (defined(BOOST_MSVC) && (BOOST_MSVC > 1310)) \ + || (defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 245) && !defined(__ICL)) +// +// This is *almost* an ideal world implementation as it doesn't rely +// on undefined behaviour by passing UDT's through (...). +// Unfortunately it doesn't quite pass all the tests for most compilers (sigh...) +// Enable this for your compiler if is_convertible_test.cpp will compile it... +// +struct any_conversion +{ + template any_conversion(const volatile T&); + // we need this constructor to catch references to functions + // (which can not be cv-qualified): + template any_conversion(T&); +}; + +template +struct is_convertible_basic_impl +{ + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion ...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int); + static From _m_from; + + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type) + ); +}; + +#else + +// +// This version seems to work pretty well for a wide spectrum of compilers, +// however it does rely on undefined behaviour by passing UDT's through (...). +// +template +struct is_convertible_basic_impl +{ + static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...); + static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To); + static From _m_from; + + BOOST_STATIC_CONSTANT(bool, value = + sizeof( _m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type) + ); +}; + +#endif // is_convertible_impl + +#if !defined(__BORLANDC__) || __BORLANDC__ > 0x551 +template +struct is_convertible_impl +{ + typedef typename add_reference::type ref_type; + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::detail::is_convertible_basic_impl::value, + ::boost::type_traits::ice_not< + ::boost::is_array::value + >::value + >::value) + ); +}; +#endif + +// +// Now add the full and partial specialisations +// for void types, these are common to all the +// implementation above: +// +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +# define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) \ + BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2,value) \ + BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const,value) \ + BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 volatile,value) \ + BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const volatile,value) \ + /**/ + +# define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2(trait,spec1,spec2,value) \ + TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) \ + TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const,spec2,value) \ + TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 volatile,spec2,value) \ + TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const volatile,spec2,value) \ + /**/ + + TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2(is_convertible,void,void,true) + +# undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2 +# undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1 + +#else + BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(is_convertible,void,void,true) +#endif // BOOST_NO_CV_VOID_SPECIALIZATIONS + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void,To,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void const,To,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void volatile,To,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void const volatile,To,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const volatile,false) +#endif +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_convertible,From,To,(::boost::detail::is_convertible_impl::value)) + + +#if defined(__GNUC__) + +// Declare specializations of is_convertible for all of the floating +// types to all of the integral types. This suppresses some nasty +// warnings + +# define TT_AUX_IS_CONVERTIBLE_SPEC(T1,T2) \ + BOOST_TT_AUX_BOOL_TRAIT_SPEC2(is_convertible,T1,T2,true) \ + /**/ + +# define TT_AUX_IS_CONVERTIBLE_SPEC_2(T1,T2) \ + TT_AUX_IS_CONVERTIBLE_SPEC(T1,signed T2) \ + TT_AUX_IS_CONVERTIBLE_SPEC(T1,unsigned T2) \ + /**/ + +# define TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_SPEC(F) \ + TT_AUX_IS_CONVERTIBLE_SPEC(F,char) \ + TT_AUX_IS_CONVERTIBLE_SPEC_2(F,char) \ + TT_AUX_IS_CONVERTIBLE_SPEC_2(F,short) \ + TT_AUX_IS_CONVERTIBLE_SPEC_2(F,int) \ + TT_AUX_IS_CONVERTIBLE_SPEC_2(F,long) \ + TT_AUX_IS_CONVERTIBLE_SPEC_2(F,long long) \ + /**/ + +# define TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_CV_SPEC(F) \ + TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_SPEC(F const) \ + TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_SPEC(F volatile) \ + TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_SPEC(F const volatile) \ + /**/ + +TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_CV_SPEC(float) +TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_CV_SPEC(double) +TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_CV_SPEC(long double) + +# undef TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_CV_SPEC +# undef TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_SPEC +# undef TT_AUX_IS_CONVERTIBLE_SPEC_2 +# undef TT_AUX_IS_CONVERTIBLE_SPEC + +#endif // __GNUC__ + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_empty.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_empty.hpp new file mode 100644 index 0000000000..1a96022f72 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_empty.hpp @@ -0,0 +1,208 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_EMPTY_HPP_INCLUDED +#define BOOST_TT_IS_EMPTY_HPP_INCLUDED + +#include "boost/type_traits/is_convertible.hpp" +#include "boost/type_traits/detail/ice_or.hpp" +#include "boost/type_traits/config.hpp" +#include "boost/type_traits/intrinsics.hpp" + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# include "boost/type_traits/remove_cv.hpp" +# include "boost/type_traits/is_class.hpp" +# include "boost/type_traits/add_reference.hpp" +#else +# include "boost/type_traits/is_reference.hpp" +# include "boost/type_traits/is_pointer.hpp" +# include "boost/type_traits/is_member_pointer.hpp" +# include "boost/type_traits/is_array.hpp" +# include "boost/type_traits/is_void.hpp" +# include "boost/type_traits/detail/ice_and.hpp" +# include "boost/type_traits/detail/ice_not.hpp" +#endif + +// should be always the last #include directive +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct empty_helper_t1 : public T +{ + empty_helper_t1(); // hh compiler bug workaround + int i[256]; +}; + +struct empty_helper_t2 { int i[256]; }; + +#ifndef __BORLANDC__ + +template +struct empty_helper +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct empty_helper +{ + BOOST_STATIC_CONSTANT( + bool, value = (sizeof(empty_helper_t1) == sizeof(empty_helper_t2)) + ); +}; + +template +struct is_empty_impl +{ + typedef typename remove_cv::type cvt; + BOOST_STATIC_CONSTANT( + bool, value = ( + ::boost::type_traits::ice_or< + ::boost::detail::empty_helper::value>::value + , BOOST_IS_EMPTY(cvt) + >::value + )); +}; + +#else // __BORLANDC__ + +template +struct empty_helper +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct empty_helper +{ + BOOST_STATIC_CONSTANT(bool, value = ( + sizeof(empty_helper_t1) == sizeof(empty_helper_t2) + )); +}; + +template +struct is_empty_impl +{ + typedef typename remove_cv::type cvt; + typedef typename add_reference::type r_type; + + BOOST_STATIC_CONSTANT( + bool, value = ( + ::boost::type_traits::ice_or< + ::boost::detail::empty_helper< + cvt + , ::boost::is_class::value + , ::boost::is_convertible< r_type,int>::value + >::value + , BOOST_IS_EMPTY(cvt) + >::value)); +}; + +#endif // __BORLANDC__ + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +#ifdef BOOST_MSVC6_MEMBER_TEMPLATES + +template +struct empty_helper_t1 : public T +{ + empty_helper_t1(); + int i[256]; +}; + +struct empty_helper_t2 { int i[256]; }; + +template +struct empty_helper_base +{ + enum { value = (sizeof(empty_helper_t1) == sizeof(empty_helper_t2)) }; +}; + +template +struct empty_helper_nonbase +{ + enum { value = false }; +}; + +template +struct empty_helper_chooser +{ + template struct result_ + { + typedef empty_helper_nonbase type; + }; +}; + +template <> +struct empty_helper_chooser +{ + template struct result_ + { + typedef empty_helper_base type; + }; +}; + +template +struct is_empty_impl +{ + typedef ::boost::detail::empty_helper_chooser< + ::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< ::boost::is_reference::value >::value, + ::boost::type_traits::ice_not< ::boost::is_convertible::value >::value, + ::boost::type_traits::ice_not< ::boost::is_pointer::value >::value, + ::boost::type_traits::ice_not< ::boost::is_member_pointer::value >::value, + ::boost::type_traits::ice_not< ::boost::is_array::value >::value, + ::boost::type_traits::ice_not< ::boost::is_void::value >::value, + ::boost::type_traits::ice_not< + ::boost::is_convertible::value + >::value + >::value > chooser; + + typedef typename chooser::template result_ result; + typedef typename result::type eh_type; + + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or::value)); +}; + +#else + +template struct is_empty_impl +{ + BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_EMPTY(T)); +}; + +#endif // BOOST_MSVC6_MEMBER_TEMPLATES + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +// these help when the compiler has no partial specialization support: +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_empty,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_empty,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_empty,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_empty,void const volatile,false) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_empty,T,::boost::detail::is_empty_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_EMPTY_HPP_INCLUDED + diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_enum.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_enum.hpp new file mode 100644 index 0000000000..939262534b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_enum.hpp @@ -0,0 +1,122 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_ENUM_HPP_INCLUDED +#define BOOST_TT_IS_ENUM_HPP_INCLUDED + +#include "boost/type_traits/add_reference.hpp" +#include "boost/type_traits/is_arithmetic.hpp" +#include "boost/type_traits/is_reference.hpp" +#include "boost/type_traits/is_convertible.hpp" +#include "boost/type_traits/config.hpp" + +#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION +# include "boost/type_traits/is_class.hpp" +#endif + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +#if !(defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)) + +namespace detail { + +struct int_convertible +{ + int_convertible(int); +}; + +// Don't evaluate convertibility to int_convertible unless the type +// is non-arithmetic. This suppresses warnings with GCC. +template +struct is_enum_helper +{ + template struct type + { + BOOST_STATIC_CONSTANT(bool, value = false); + }; +}; + +template <> +struct is_enum_helper +{ + template struct type + : ::boost::is_convertible + { + }; +}; + +template struct is_enum_impl +{ + typedef ::boost::add_reference ar_t; + typedef typename ar_t::type r_type; + +#if defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) + BOOST_STATIC_CONSTANT(bool, selector = + (::boost::type_traits::ice_or< + ::boost::is_arithmetic::value + , ::boost::is_reference::value + // We MUST do this on conforming compilers in order to + // correctly deduce that noncopyable types are not enums (dwa + // 2002/04/15)... + , ::boost::is_class::value + >::value)); +#else + BOOST_STATIC_CONSTANT(bool, selector = + (::boost::type_traits::ice_or< + ::boost::is_arithmetic::value + , ::boost::is_reference::value + // However, not doing this on non-conforming compilers prevents + // a dependency recursion. + >::value)); +#endif + +#ifdef __BORLANDC__ + typedef ::boost::detail::is_enum_helper< + ::boost::detail::is_enum_impl::selector + > se_t; +#else + typedef ::boost::detail::is_enum_helper se_t; +#endif + typedef typename se_t::template type helper; + BOOST_STATIC_CONSTANT(bool, value = helper::value); +}; + +// Specializations suppress some nasty warnings with GCC +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,float,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,double,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,long double,false) +// these help on compilers with no partial specialization support: +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void const volatile,false) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_enum,T,::boost::detail::is_enum_impl::value) + +#else // __BORLANDC__ +// +// buggy is_convertible prevents working +// implementation of is_enum: +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_enum,T,false) + +#endif + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_ENUM_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_float.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_float.hpp new file mode 100644 index 0000000000..5450fca532 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_float.hpp @@ -0,0 +1,28 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED +#define BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +//* is a type T a floating-point type described in the standard (3.9.1p8) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_float,T,false) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_float,float,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_float,double,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_float,long double,true) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_function.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_function.hpp new file mode 100644 index 0000000000..02c661d477 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_function.hpp @@ -0,0 +1,85 @@ + +// Copyright (C) 2000 John Maddock (john_maddock@compuserve.com) +// Copyright (C) 2002 Aleksey Gurtovoy (agurtovoy@meta-comm.com) +// +// Permission to copy and use this software is granted, +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted, +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +#ifndef BOOST_TT_IS_FUNCTION_HPP_INCLUDED +#define BOOST_TT_IS_FUNCTION_HPP_INCLUDED + +#include "boost/type_traits/is_reference.hpp" +#include "boost/type_traits/detail/false_result.hpp" +#include "boost/config.hpp" + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# include "boost/type_traits/detail/is_function_ptr_helper.hpp" +#else +# include "boost/type_traits/detail/is_function_ptr_tester.hpp" +# include "boost/type_traits/detail/yes_no_type.hpp" +#endif + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +// is a type a function? +// Please note that this implementation is unnecessarily complex: +// we could just use !is_convertible::value, +// except that some compilers erroneously allow conversions from +// function pointers to void*. + +namespace boost { +namespace detail { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct is_function_chooser + : ::boost::type_traits::false_result +{ +}; + +template <> +struct is_function_chooser +{ + template< typename T > struct result_ + : ::boost::type_traits::is_function_ptr_helper + { + }; +}; + +template +struct is_function_impl + : is_function_chooser< ::boost::is_reference::value > + ::template result_ +{ +}; + +#else + +template +struct is_function_impl +{ + static T* t; + BOOST_STATIC_CONSTANT( + bool, value = sizeof(::boost::type_traits::is_function_ptr_tester(t)) + == sizeof(::boost::type_traits::yes_type) + ); +}; + +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_function,T,::boost::detail::is_function_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_FUNCTION_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_fundamental.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_fundamental.hpp new file mode 100644 index 0000000000..09e4da9c0c --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_fundamental.hpp @@ -0,0 +1,42 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED +#define BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED + +#include "boost/type_traits/is_arithmetic.hpp" +#include "boost/type_traits/is_void.hpp" +#include "boost/type_traits/detail/ice_or.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +template +struct is_fundamental_impl + : ::boost::type_traits::ice_or< + ::boost::is_arithmetic::value + , ::boost::is_void::value + > +{ +}; + +} // namespace detail + +//* is a type T a fundamental type described in the standard (3.9.1) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_fundamental,T,::boost::detail::is_fundamental_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_integral.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_integral.hpp new file mode 100644 index 0000000000..c3d138159a --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_integral.hpp @@ -0,0 +1,63 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_INTEGRAL_HPP_INCLUDED +#define BOOST_TT_IS_INTEGRAL_HPP_INCLUDED + +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +//* is a type T an [cv-qualified-] integral type described in the standard (3.9.1p3) +// as an extention we include long long, as this is likely to be added to the +// standard at a later date +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_integral,T,false) + +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned char,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned short,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned int,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned long,true) + +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed char,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed short,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed int,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed long,true) + +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,bool,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,char,true) + +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,wchar_t,true) +#endif + +#if (defined(BOOST_MSVC) && (BOOST_MSVC == 1200)) || (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int8,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int8,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int16,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int16,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int32,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int32,true) +#endif + +# if defined(BOOST_HAS_LONG_LONG) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned long long,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,long long,true) +#elif defined(BOOST_HAS_MS_INT64) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int64,true) +BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int64,true) +#endif + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_INTEGRAL_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_member_function_pointer.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_member_function_pointer.hpp new file mode 100644 index 0000000000..b2e4218849 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_member_function_pointer.hpp @@ -0,0 +1,114 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED +#define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__) +# include "boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" +#else +# include "boost/type_traits/is_reference.hpp" +# include "boost/type_traits/is_array.hpp" +# include "boost/type_traits/detail/is_mem_fun_pointer_tester.hpp" +# include "boost/type_traits/detail/yes_no_type.hpp" +# include "boost/type_traits/detail/false_result.hpp" +# include "boost/type_traits/detail/ice_or.hpp" +#endif + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__) + +BOOST_TT_AUX_BOOL_TRAIT_DEF1( + is_member_function_pointer + , T + , ::boost::type_traits::is_mem_fun_pointer_impl::value + ) + +#else + +namespace detail { + +#ifndef __BORLANDC__ + +template +struct is_mem_fun_pointer_select + : ::boost::type_traits::false_result +{ +}; + +template <> +struct is_mem_fun_pointer_select +{ + template struct result_ + { + static T& make_t; + typedef result_ self_type; + + BOOST_STATIC_CONSTANT( + bool, value = ( + 1 == sizeof(::boost::type_traits::is_mem_fun_pointer_tester(self_type::make_t)) + )); + }; +}; + +template +struct is_member_function_pointer_impl + : is_mem_fun_pointer_select< + ::boost::type_traits::ice_or< + ::boost::is_reference::value + , ::boost::is_array::value + >::value + >::template result_ +{ +}; + +#else // Borland C++ + +template +struct is_member_function_pointer_impl +{ + static T& m_t; + BOOST_STATIC_CONSTANT( + bool, value = + (1 == sizeof(type_traits::is_mem_fun_pointer_tester(m_t))) ); +}; + +template +struct is_member_function_pointer_impl +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +#endif + +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void const volatile,false) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_function_pointer,T,::boost::detail::is_member_function_pointer_impl::value) + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_member_pointer.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_member_pointer.hpp new file mode 100644 index 0000000000..0f8851b6bd --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_member_pointer.hpp @@ -0,0 +1,97 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED +#define BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" + +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__) +# include "boost/type_traits/is_member_function_pointer.hpp" +#else +# include "boost/type_traits/is_reference.hpp" +# include "boost/type_traits/is_array.hpp" +# include "boost/type_traits/detail/is_mem_fun_pointer_tester.hpp" +# include "boost/type_traits/detail/yes_no_type.hpp" +# include "boost/type_traits/detail/false_result.hpp" +# include "boost/type_traits/detail/ice_or.hpp" +#endif + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +#if defined(__BORLANDC__) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*,true) + +#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,::boost::is_member_function_pointer::value) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*,true) + +#else // no partial template specialization + +namespace detail { + +template +::boost::type_traits::yes_type BOOST_TT_DECL is_member_pointer_tester(R T::*); +::boost::type_traits::no_type BOOST_TT_DECL is_member_pointer_tester(...); + +template +struct is_member_pointer_select + : ::boost::type_traits::false_result +{ +}; + +template <> +struct is_member_pointer_select +{ + template struct result_ + { + static T& make_t(); + BOOST_STATIC_CONSTANT( + bool, value = + (::boost::type_traits::ice_or< + (1 == sizeof(::boost::type_traits::is_mem_fun_pointer_tester(make_t()))), + (1 == sizeof(is_member_pointer_tester(make_t()))) + >::value) ); + }; +}; + +template +struct is_member_pointer_impl + : is_member_pointer_select< + ::boost::type_traits::ice_or< + ::boost::is_reference::value + , ::boost::is_array::value + >::value + >::template result_ +{ +}; + +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void const volatile,false) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,::boost::detail::is_member_pointer_impl::value) + +#endif // __BORLANDC__ + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_object.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_object.hpp new file mode 100644 index 0000000000..efe737b240 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_object.hpp @@ -0,0 +1,54 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_OBJECT_HPP_INCLUDED +#define BOOST_TT_IS_OBJECT_HPP_INCLUDED + +#include "boost/type_traits/is_reference.hpp" +#include "boost/type_traits/is_void.hpp" +#include "boost/type_traits/is_function.hpp" +#include "boost/type_traits/detail/ice_and.hpp" +#include "boost/type_traits/detail/ice_not.hpp" +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +template +struct is_object_impl +{ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, + ::boost::type_traits::ice_not< ::boost::is_void::value>::value, + ::boost::type_traits::ice_not< ::boost::is_function::value>::value + >::value)); +#else + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, + ::boost::type_traits::ice_not< ::boost::is_void::value>::value + >::value)); +#endif +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_object,T,::boost::detail::is_object_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_OBJECT_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_pod.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_pod.hpp new file mode 100644 index 0000000000..d478e34cac --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_pod.hpp @@ -0,0 +1,134 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_POD_HPP_INCLUDED +#define BOOST_TT_IS_POD_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" +#include "boost/type_traits/is_void.hpp" +#include "boost/type_traits/is_scalar.hpp" +#include "boost/type_traits/detail/ice_or.hpp" +#include "boost/type_traits/intrinsics.hpp" + +#include + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +// forward declaration, needed by 'is_pod_array_helper' template below +template< typename T > struct is_POD; + +namespace detail { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +template struct is_pod_impl +{ + BOOST_STATIC_CONSTANT( + bool, value = + (::boost::type_traits::ice_or< + ::boost::is_scalar::value, + ::boost::is_void::value, + BOOST_IS_POD(T) + >::value)); +}; + +template +struct is_pod_impl + : is_pod_impl +{ +}; + +#else + +template +struct is_pod_helper +{ + template struct result_ + { + BOOST_STATIC_CONSTANT( + bool, value = + (::boost::type_traits::ice_or< + ::boost::is_scalar::value, + ::boost::is_void::value, + BOOST_IS_POD(T) + >::value)); + }; +}; + +template +struct bool_to_yes_no_type +{ + typedef ::boost::type_traits::no_type type; +}; + +template <> +struct bool_to_yes_no_type +{ + typedef ::boost::type_traits::yes_type type; +}; + +template +struct is_pod_array_helper +{ + enum { is_pod = ::boost::is_POD::value }; // MSVC workaround + typedef typename bool_to_yes_no_type::type type; + type instance() const; +}; + +template +is_pod_array_helper is_POD_array(T*); + +template <> +struct is_pod_helper +{ + template struct result_ + { + static T& help(); + BOOST_STATIC_CONSTANT(bool, value = + sizeof(is_POD_array(help()).instance()) == sizeof(::boost::type_traits::yes_type) + ); + }; +}; + + +template struct is_pod_impl +{ + BOOST_STATIC_CONSTANT( + bool, value = ( + ::boost::detail::is_pod_helper< + ::boost::is_array::value + >::template result_::value + ) + ); +}; + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +// the following help compilers without partial specialization support: +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void,true) + +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void const,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void volatile,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void const volatile,true) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_POD,T,::boost::detail::is_pod_impl::value) +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pod,T,::boost::is_POD::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_POD_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_pointer.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_pointer.hpp new file mode 100644 index 0000000000..95f32368ff --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_pointer.hpp @@ -0,0 +1,139 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_POINTER_HPP_INCLUDED +#define BOOST_TT_IS_POINTER_HPP_INCLUDED + +#include "boost/type_traits/is_member_pointer.hpp" +#include "boost/type_traits/detail/ice_and.hpp" +#include "boost/type_traits/detail/ice_not.hpp" +#include "boost/type_traits/config.hpp" + +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# include "boost/type_traits/is_reference.hpp" +# include "boost/type_traits/is_array.hpp" +# include "boost/type_traits/detail/is_function_ptr_tester.hpp" +# include "boost/type_traits/detail/false_result.hpp" +# include "boost/type_traits/detail/ice_or.hpp" +#endif + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +namespace detail { + +template< typename T > struct is_pointer_helper +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +# define TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(helper,sp,result) \ +template< typename T > struct helper \ +{ \ + BOOST_STATIC_CONSTANT(bool, value = result); \ +}; \ +/**/ + +TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(is_pointer_helper,T*,true) +TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(is_pointer_helper,T* const,true) +TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(is_pointer_helper,T* volatile,true) +TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(is_pointer_helper,T* const volatile,true) + +# undef TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC + +template< typename T > +struct is_pointer_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::detail::is_pointer_helper::value + , ::boost::type_traits::ice_not< + ::boost::is_member_pointer::value + >::value + >::value) + ); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pointer,T,::boost::detail::is_pointer_impl::value) + +#if defined(__BORLANDC__) && !defined(__COMO__) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T&,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& const,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& const volatile,false) +#endif + +#else // no partial template specialization + +namespace detail { + +struct pointer_helper +{ + pointer_helper(const volatile void*); +}; + +yes_type BOOST_TT_DECL is_pointer_tester(pointer_helper); +no_type BOOST_TT_DECL is_pointer_tester(...); + +template +struct is_pointer_select + : ::boost::type_traits::false_result +{ +}; + +template <> +struct is_pointer_select +{ + template struct result_ + { + static T& make_t(); + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + (1 == sizeof(is_pointer_tester(make_t()))), + (1 == sizeof(type_traits::is_function_ptr_tester(make_t()))) + >::value)); + }; +}; + +template +struct is_pointer_impl + : is_pointer_select< + ::boost::type_traits::ice_or< + ::boost::is_reference::value + , ::boost::is_array::value + >::value + >::template result_ +{ +}; + +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void const volatile,false) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pointer,T,::boost::detail::is_pointer_impl::value) + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_POINTER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_polymorphic.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_polymorphic.hpp new file mode 100644 index 0000000000..c9bb14db21 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_polymorphic.hpp @@ -0,0 +1,90 @@ +// (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +#ifndef BOOST_TT_IS_POLYMORPHIC_HPP +#define BOOST_TT_IS_POLYMORPHIC_HPP + +#include +#include +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" +#include + +namespace boost{ +namespace detail{ + +template +struct is_polymorphic_imp1 +{ +# if BOOST_WORKAROUND(__MWERKS__, <= 0x2407) // CWPro7 should return false always. + typedef char d1, (&d2)[2]; +# else + typedef typename remove_cv::type ncvT; + struct d1 : public ncvT + { + d1(); +# if !defined(__GNUC__) // this raises warnings with some classes, and buys nothing with GCC + ~d1()throw(); +# endif + char padding[256]; + }; + struct d2 : public ncvT + { + d2(); + virtual ~d2()throw(); +# ifndef BOOST_MSVC + // for some reason this messes up VC++ when T has virtual bases: + virtual void foo(); +# endif + char padding[256]; + }; +# endif + BOOST_STATIC_CONSTANT(bool, value = (sizeof(d2) == sizeof(d1))); +}; + +template +struct is_polymorphic_imp2 +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +template +struct is_polymorphic_selector +{ + template + struct rebind + { + typedef is_polymorphic_imp2 type; + }; +}; + +template <> +struct is_polymorphic_selector +{ + template + struct rebind + { + typedef is_polymorphic_imp1 type; + }; +}; + +template +struct is_polymorphic_imp +{ + typedef is_polymorphic_selector< ::boost::is_class::value> selector; + typedef typename selector::template rebind binder; + typedef typename binder::type imp_type; + BOOST_STATIC_CONSTANT(bool, value = imp_type::value); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_polymorphic,T,::boost::detail::is_polymorphic_imp::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_reference.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_reference.hpp new file mode 100644 index 0000000000..325d430d34 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_reference.hpp @@ -0,0 +1,111 @@ + +// (C) Copyright David Abrahams Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000-2002. Permission to copy, use, +// modify, sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_REFERENCE_HPP_INCLUDED +#define BOOST_TT_IS_REFERENCE_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" + +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# include "boost/type_traits/detail/yes_no_type.hpp" +# include "boost/type_traits/detail/wrap.hpp" +#endif + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && defined(BOOST_MSVC) +# include "boost/type_traits/detail/is_function_type_tester.hpp" +# include "boost/type_traits/detail/false_result.hpp" +#endif + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_reference,T,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T&,true) + +#if defined(__BORLANDC__) && !defined(__COMO__) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T& const,true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T& volatile,true) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T& const volatile,true) +#endif + +#if defined(__GNUC__) && (__GNUC__ < 3) +// these allow us to work around illegally cv-qualified reference +// types. +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T const ,::boost::is_reference::value) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T volatile ,::boost::is_reference::value) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T const volatile ,::boost::is_reference::value) +// However, the above specializations confuse gcc 2.96 unless we also +// supply these specializations for array types +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,T[N],false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,const T[N],false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,volatile T[N],false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,const volatile T[N],false) +#endif + +#else + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable: 4181) +#endif + +namespace detail { + +using ::boost::type_traits::yes_type; +using ::boost::type_traits::no_type; +using ::boost::type_traits::wrap; + +template T&(* is_reference_helper1(wrap) )(wrap); +char is_reference_helper1(...); + +template no_type is_reference_helper2(T&(*)(wrap)); +yes_type is_reference_helper2(...); + +template +struct is_reference_impl +{ + BOOST_STATIC_CONSTANT( + bool, value = sizeof( + ::boost::detail::is_reference_helper2( + ::boost::detail::is_reference_helper1(::boost::type_traits::wrap()))) == 1 + ); +}; + +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void const volatile,false) +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_reference,T,::boost::detail::is_reference_impl::value) + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED + diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_same.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_same.hpp new file mode 100644 index 0000000000..313312be27 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_same.hpp @@ -0,0 +1,93 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Aleksey Gurtovoy, +// Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This +// software is provided "as is" without express or implied warranty, and +// with no claim as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_SAME_HPP_INCLUDED +#define BOOST_TT_IS_SAME_HPP_INCLUDED + +#include "boost/type_traits/config.hpp" +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +#include "boost/type_traits/detail/yes_no_type.hpp" +#include "boost/type_traits/detail/ice_and.hpp" +#include "boost/type_traits/is_reference.hpp" +#endif +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_same,T,U,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename T,is_same,T,T,true) +#ifdef __BORLANDC__ +// without this, Borland's compiler gives the wrong answer for +// references to arrays: +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename T,is_same,T&,T&,true) +#endif + +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +namespace detail { + +#ifdef BOOST_MSVC +// the following VC6 specific implementation is *NOT* legal +// C++, but has the advantage that it works for incomplete +// types. + +template< typename T1 > +struct is_same_part_1 +{ + template struct part_2 { enum { value = false }; }; + template<> struct part_2 { enum { value = true }; }; +}; + +template< typename T1, typename T2 > +struct is_same_impl +{ + enum { value = detail::is_same_part_1::template part_2::value }; +}; + +#else // generic "no-partial-specialization" version + +template +::boost::type_traits::yes_type +BOOST_TT_DECL is_same_tester(T*, T*); + +::boost::type_traits::no_type +BOOST_TT_DECL is_same_tester(...); + +template +struct is_same_impl +{ + static T t; + static U u; + + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + (sizeof(type_traits::yes_type) == sizeof(detail::is_same_tester(&t,&u))), + (::boost::is_reference::value == ::boost::is_reference::value), + (sizeof(T) == sizeof(U)) + >::value)); +}; + +#endif // BOOST_MSVC + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_same,T,U,(::boost::detail::is_same_impl::value)) + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_SAME_HPP_INCLUDED + diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_scalar.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_scalar.hpp new file mode 100644 index 0000000000..5abd7ee821 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_scalar.hpp @@ -0,0 +1,56 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_SCALAR_HPP_INCLUDED +#define BOOST_TT_IS_SCALAR_HPP_INCLUDED + +#include "boost/type_traits/is_arithmetic.hpp" +#include "boost/type_traits/is_enum.hpp" +#include "boost/type_traits/is_pointer.hpp" +#include "boost/type_traits/is_member_pointer.hpp" +#include "boost/type_traits/detail/ice_or.hpp" +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +template +struct is_scalar_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_arithmetic::value, + ::boost::is_enum::value, + ::boost::is_pointer::value, + ::boost::is_member_pointer::value + >::value)); +}; + +// these specializations are only really needed for compilers +// without partial specialization support: +template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; +template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; +template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; +#endif + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_scalar,T,::boost::detail::is_scalar_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_SCALAR_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_stateless.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_stateless.hpp new file mode 100644 index 0000000000..d2c764ba45 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_stateless.hpp @@ -0,0 +1,49 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_STATELESS_HPP_INCLUDED +#define BOOST_TT_IS_STATELESS_HPP_INCLUDED + +#include "boost/type_traits/has_trivial_constructor.hpp" +#include "boost/type_traits/has_trivial_copy.hpp" +#include "boost/type_traits/has_trivial_destructor.hpp" +#include "boost/type_traits/is_class.hpp" +#include "boost/type_traits/is_empty.hpp" +#include "boost/type_traits/detail/ice_and.hpp" +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { + +template +struct is_stateless_impl +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_and< + ::boost::has_trivial_constructor::value, + ::boost::has_trivial_copy::value, + ::boost::has_trivial_destructor::value, + ::boost::is_class::value, + ::boost::is_empty::value + >::value)); +}; + +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_stateless,T,::boost::detail::is_stateless_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_STATELESS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_union.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_union.hpp new file mode 100644 index 0000000000..5a2c3f9711 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_union.hpp @@ -0,0 +1,37 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_UNION_HPP_INCLUDED +#define BOOST_TT_IS_UNION_HPP_INCLUDED + +#include "boost/type_traits/remove_cv.hpp" +#include "boost/type_traits/config.hpp" +#include "boost/type_traits/intrinsics.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +namespace detail { +template struct is_union_impl +{ + typedef typename remove_cv::type cvt; + BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_UNION(cvt)); +}; +} // namespace detail + +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_union,T,::boost::detail::is_union_impl::value) + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_UNION_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_void.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_void.hpp new file mode 100644 index 0000000000..1ef7eb7c0f --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_void.hpp @@ -0,0 +1,34 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_VOID_HPP_INCLUDED +#define BOOST_TT_IS_VOID_HPP_INCLUDED + +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +//* is a type T void - is_void +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_void,T,false) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void,true) + +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void const,true) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void volatile,true) +BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void const volatile,true) +#endif + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_VOID_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/is_volatile.hpp b/deal.II/contrib/boost/include/boost/type_traits/is_volatile.hpp new file mode 100644 index 0000000000..b907a50e60 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/is_volatile.hpp @@ -0,0 +1,113 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_IS_VOLATILE_HPP_INCLUDED +#define BOOST_TT_IS_VOLATILE_HPP_INCLUDED + +#include "boost/config.hpp" + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +# include "boost/type_traits/detail/cv_traits_impl.hpp" +#else +# include "boost/type_traits/is_reference.hpp" +# include "boost/type_traits/is_array.hpp" +# include "boost/type_traits/detail/yes_no_type.hpp" +# include "boost/type_traits/detail/false_result.hpp" +#endif + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +//* is a type T declared volatile - is_volatile +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::cv_traits_imp::is_volatile) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T&,false) + +#if defined(__BORLANDC__) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& const,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& volatile,false) +BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& const volatile,false) +#endif + +#else + +namespace detail { + +using ::boost::type_traits::yes_type; +using ::boost::type_traits::no_type; + +yes_type is_volatile_tester(void const volatile*); +no_type is_volatile_tester(void const*); + +template +struct is_volatile_helper + : ::boost::type_traits::false_result +{ +}; + +template <> +struct is_volatile_helper +{ + template struct result_ + { + static T* t; + BOOST_STATIC_CONSTANT(bool, value = ( + sizeof(detail::yes_type) == sizeof(detail::is_volatile_tester(t)) + )); + }; +}; + +template <> +struct is_volatile_helper +{ + template struct result_ + { + static T t; + BOOST_STATIC_CONSTANT(bool, value = ( + sizeof(detail::yes_type) == sizeof(detail::is_volatile_tester(&t)) + )); + }; +}; + +template +struct is_volatile_impl + : is_volatile_helper< + is_reference::value + , is_array::value + >::template result_ +{ +}; + +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void,false) +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void const,false) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void volatile,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void const volatile,true) +#endif + +} // namespace detail + +//* is a type T declared volatile - is_volatile +BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::is_volatile_impl::value) + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_IS_VOLATILE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/remove_bounds.hpp b/deal.II/contrib/boost/include/boost/type_traits/remove_bounds.hpp new file mode 100644 index 0000000000..20199d3af3 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/remove_bounds.hpp @@ -0,0 +1,34 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED +#define BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED + +#include "boost/config.hpp" +#include + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_bounds,T,T) + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T[N],T type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T const[N],T const type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T volatile[N],T volatile type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T const volatile[N],T const volatile type) +#endif + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/remove_const.hpp b/deal.II/contrib/boost/include/boost/type_traits/remove_const.hpp new file mode 100644 index 0000000000..999220e450 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/remove_const.hpp @@ -0,0 +1,71 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_REMOVE_CONST_HPP_INCLUDED +#define BOOST_TT_REMOVE_CONST_HPP_INCLUDED + +#include "boost/type_traits/is_volatile.hpp" +#include "boost/type_traits/broken_compiler_spec.hpp" +#include "boost/type_traits/detail/cv_traits_impl.hpp" +#include "boost/config.hpp" + +#include + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +namespace detail { + +template +struct remove_const_helper +{ + typedef T type; +}; + +template +struct remove_const_helper +{ + typedef T volatile type; +}; + + +template +struct remove_const_impl +{ + typedef typename remove_const_helper< + typename cv_traits_imp::unqualified_type + , ::boost::is_volatile::value + >::type type; +}; + +} // namespace detail + +// * convert a type T to non-const type - remove_const + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_const,T,typename detail::remove_const_impl::type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_const,T&,T&) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_const,T const[N],T type[N]) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_const,T const volatile[N],T volatile type[N]) + +#else + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_const,T,typename detail::remove_const_impl::type) + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_REMOVE_CONST_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/remove_cv.hpp b/deal.II/contrib/boost/include/boost/type_traits/remove_cv.hpp new file mode 100644 index 0000000000..dcb828b308 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/remove_cv.hpp @@ -0,0 +1,54 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_REMOVE_CV_HPP_INCLUDED +#define BOOST_TT_REMOVE_CV_HPP_INCLUDED + +#include "boost/type_traits/broken_compiler_spec.hpp" +#include "boost/type_traits/detail/cv_traits_impl.hpp" +#include "boost/config.hpp" + +#include + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +// convert a type T to a non-cv-qualified type - remove_cv +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_cv,T,typename detail::cv_traits_imp::unqualified_type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_cv,T&,T&) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T const[N],T type[N]) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T volatile[N],T type[N]) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T const volatile[N],T type[N]) + +#else + +namespace detail { +template +struct remove_cv_impl +{ + typedef typename remove_volatile_impl< + typename remove_const_impl::type + >::type type; +}; +} + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_cv,T,typename detail::remove_cv_impl::type) + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_REMOVE_CV_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/remove_pointer.hpp b/deal.II/contrib/boost/include/boost/type_traits/remove_pointer.hpp new file mode 100644 index 0000000000..37dc820f25 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/remove_pointer.hpp @@ -0,0 +1,39 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_REMOVE_POINTER_HPP_INCLUDED +#define BOOST_TT_REMOVE_POINTER_HPP_INCLUDED + +#include "boost/type_traits/broken_compiler_spec.hpp" +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T*,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* const,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* volatile,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* const volatile,T) + +#else + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,typename detail::remove_pointer_impl::type) + +#endif + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_REMOVE_POINTER_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/remove_reference.hpp b/deal.II/contrib/boost/include/boost/type_traits/remove_reference.hpp new file mode 100644 index 0000000000..78ef6cb56b --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/remove_reference.hpp @@ -0,0 +1,46 @@ + +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This software +// is provided "as is" without express or implied warranty, and with no claim +// as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED +#define BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED + +#include "boost/type_traits/broken_compiler_spec.hpp" +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T&,T) + +#if defined(__BORLANDC__) +// these are illegal specialisations; cv-qualifies applied to +// references have no effect according to [8.3.2p1], +// C++ Builder requires them though as it treats cv-qualified +// references as distinct types... +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& const,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& volatile,T) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& const volatile,T) +#endif + +#else + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,typename detail::remove_reference_impl::type) + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/remove_volatile.hpp b/deal.II/contrib/boost/include/boost/type_traits/remove_volatile.hpp new file mode 100644 index 0000000000..ef887735ee --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/remove_volatile.hpp @@ -0,0 +1,70 @@ + +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. + +#ifndef BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED +#define BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED + +#include "boost/type_traits/is_const.hpp" +#include "boost/type_traits/broken_compiler_spec.hpp" +#include "boost/type_traits/detail/cv_traits_impl.hpp" +#include "boost/config.hpp" + +#include + +// should be the last #include +#include "boost/type_traits/detail/type_trait_def.hpp" + +namespace boost { + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +namespace detail { + +template +struct remove_volatile_helper +{ + typedef T type; +}; + +template +struct remove_volatile_helper +{ + typedef T const type; +}; + +template +struct remove_volatile_impl +{ + typedef typename remove_volatile_helper< + typename cv_traits_imp::unqualified_type + , ::boost::is_const::value + >::type type; +}; + +} // namespace detail + +// * convert a type T to a non-volatile type - remove_volatile + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_volatile,T,typename detail::remove_volatile_impl::type) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_volatile,T&,T&) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_volatile,T volatile[N],T type[N]) +BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_volatile,T const volatile[N],T const type[N]) + +#else + +BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_volatile,T,typename detail::remove_volatile_impl::type) + +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#include "boost/type_traits/detail/type_trait_undef.hpp" + +#endif // BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED diff --git a/deal.II/contrib/boost/include/boost/type_traits/type_with_alignment.hpp b/deal.II/contrib/boost/include/boost/type_traits/type_with_alignment.hpp new file mode 100644 index 0000000000..91d3aca782 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/type_traits/type_with_alignment.hpp @@ -0,0 +1,169 @@ + +// (C) Copyright John Maddock 2000. +// Permission to copy, use, modify, sell and distribute this software is +// granted provided this copyright notice appears in all copies. This +// software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +#ifndef BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED +#define BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED + +#include "boost/mpl/if.hpp" +#include "boost/preprocessor/list/for_each_i.hpp" +#include "boost/preprocessor/tuple/to_list.hpp" +#include "boost/preprocessor/cat.hpp" +#include "boost/type_traits/alignment_of.hpp" +#include "boost/type_traits/is_pod.hpp" +#include "boost/static_assert.hpp" +#include "boost/config.hpp" + +// should be the last #include +#include "boost/type_traits/detail/bool_trait_def.hpp" + +#include + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable: 4121) // alignment is sensitive to packing +#endif + +namespace boost { + +#ifndef __BORLANDC__ + +namespace detail { + +class alignment_dummy; +typedef void (*function_ptr)(); +typedef int (alignment_dummy::*member_ptr); +typedef int (alignment_dummy::*member_function_ptr)(); + +#define BOOST_TT_ALIGNMENT_TYPES BOOST_PP_TUPLE_TO_LIST( \ + 11, ( \ + char, short, int, long, float, double, long double \ + , void*, function_ptr, member_ptr, member_function_ptr)) + +#define BOOST_TT_CHOOSE_MIN_ALIGNMENT(R,P,I,T) \ + typename mpl::if_c< \ + alignment_of::value <= target, T, char>::type BOOST_PP_CAT(t,I); + +#define BOOST_TT_CHOOSE_T(R,P,I,T) T BOOST_PP_CAT(t,I); + +template +union lower_alignment +{ + BOOST_PP_LIST_FOR_EACH_I( + BOOST_TT_CHOOSE_MIN_ALIGNMENT + , ignored + , BOOST_TT_ALIGNMENT_TYPES + ) +}; + +union max_align +{ + BOOST_PP_LIST_FOR_EACH_I( + BOOST_TT_CHOOSE_T + , ignored + , BOOST_TT_ALIGNMENT_TYPES + ) +}; + +#undef BOOST_TT_ALIGNMENT_TYPES +#undef BOOST_TT_CHOOSE_MIN_ALIGNMENT +#undef BOOST_TT_CHOOSE_T + +template +struct is_aligned +{ + BOOST_STATIC_CONSTANT(bool, + value = (TAlign >= Align) & (TAlign % Align == 0) + ); +}; + +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::max_align,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<1> ,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<2> ,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<4> ,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<8> ,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<10> ,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<16> ,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<32> ,true) + +} // namespace detail + +// This alignment method originally due to Brian Parker, implemented by David +// Abrahams, and then ported here by Doug Gregor. +template +class type_with_alignment +{ + typedef detail::lower_alignment t1; + typedef typename mpl::if_c< + ::boost::detail::is_aligned< ::boost::alignment_of::value,Align >::value + , t1 + , detail::max_align + >::type align_t; + + BOOST_STATIC_CONSTANT(std::size_t, found = alignment_of::value); + +#ifndef __BORLANDC__ + BOOST_STATIC_ASSERT(found >= Align); + BOOST_STATIC_ASSERT(found % Align == 0); +#else + BOOST_STATIC_ASSERT(::boost::type_with_alignment::found >= Align); + BOOST_STATIC_ASSERT(::boost::type_with_alignment::found % Align == 0); +#endif + + public: + typedef align_t type; +}; + +#else + +// +// Borland specific version, we have this for two reasons: +// 1) The version above doesn't always compile (with the new test cases for example) +// 2) Because of Borlands #pragma option we can create types with alignments that are +// greater that the largest aligned builtin type. + +namespace align{ +#pragma option push -a16 +struct a2{ short s; }; +struct a4{ int s; }; +struct a8{ double s; }; +struct a16{ long double s; }; +#pragma option pop +} + +namespace detail { +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a2,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a4,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a8,true) +BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a16,true) +} + +template struct type_with_alignment +{ + // We should never get to here, but if we do use the maximally + // aligned type: + // BOOST_STATIC_ASSERT(0); + typedef align::a16 type; +}; +template <> struct type_with_alignment<1>{ typedef char type; }; +template <> struct type_with_alignment<2>{ typedef align::a2 type; }; +template <> struct type_with_alignment<4>{ typedef align::a4 type; }; +template <> struct type_with_alignment<8>{ typedef align::a8 type; }; +template <> struct type_with_alignment<16>{ typedef align::a16 type; }; + +#endif + +} // namespace boost + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#include "boost/type_traits/detail/bool_trait_undef.hpp" + +#endif // BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED + + diff --git a/deal.II/contrib/boost/include/boost/utility/addressof.hpp b/deal.II/contrib/boost/include/boost/utility/addressof.hpp new file mode 100644 index 0000000000..de8dfe5d59 --- /dev/null +++ b/deal.II/contrib/boost/include/boost/utility/addressof.hpp @@ -0,0 +1,43 @@ +// Copyright (C) 2002 Brad King (brad.king@kitware.com) +// Doug Gregor (gregod@cs.rpi.edu) +// Peter Dimov +// +// Permission to copy, use, sell and distribute this software is granted +// provided this copyright notice appears in all copies. +// Permission to modify the code and to distribute modified code is granted +// provided this copyright notice appears in all copies, and a notice +// that the code was modified is included with the copyright notice. +// +// This software is provided "as is" without express or implied warranty, +// and with no claim as to its suitability for any purpose. + +// For more information, see http://www.boost.org + +#ifndef BOOST_UTILITY_ADDRESSOF_HPP +# define BOOST_UTILITY_ADDRESSOF_HPP + +# include +# include +# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) +# include +# endif + +namespace boost { + +// Do not make addressof() inline. Breaks MSVC 7. (Peter Dimov) + +// VC7 strips const from nested classes unless we add indirection here +# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) +template typename add_pointer::type +# else +template T* +# endif +addressof(T& v) +{ + return reinterpret_cast( + &const_cast(reinterpret_cast(v))); +} + +} + +#endif // BOOST_UTILITY_ADDRESSOF_HPP