This avoids some warnings with gcc6.
template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+ {
+ rrlist1<A1&> a( a1_ );
+ return b.eval( a );
+ }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+ {
+ rrlist1<A1&> a( a1_ );
+ return b.eval( a );
+ }
};
template< class A1, class A2 > class rrlist2
template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+ {
+ rrlist2<A1&, A2&> a( a1_, a2_ );
+ return b.eval( a );
+ }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+ {
+ rrlist2<A1&, A2&> a( a1_, a2_ );
+ return b.eval( a );
+ }
};
template< class A1, class A2, class A3 > class rrlist3
template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+ {
+ rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ );
+ return b.eval( a );
+ }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+ {
+ rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ );
+ return b.eval( a );
+ }
};
template< class A1, class A2, class A3, class A4 > class rrlist4
template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+ {
+ rrlist4<A1&, A2&, A3&, A4&> a( a1_, a2_, a3_, a4_ );
+ return b.eval( a );
+ }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+ {
+ rrlist4<A1&, A2&, A3&, A4&> a( a1_, a2_, a3_, a4_ );
+ return b.eval( a );
+ }
};
template< class A1, class A2, class A3, class A4, class A5 > class rrlist5
template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+ {
+ rrlist5<A1&, A2&, A3&, A4&, A5&> a( a1_, a2_, a3_, a4_, a5_ );
+ return b.eval( a );
+ }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+ {
+ rrlist5<A1&, A2&, A3&, A4&, A5&> a( a1_, a2_, a3_, a4_, a5_ );
+ return b.eval( a );
+ }
};
template< class A1, class A2, class A3, class A4, class A5, class A6 > class rrlist6
template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+ {
+ rrlist6<A1&, A2&, A3&, A4&, A5&, A6&> a( a1_, a2_, a3_, a4_, a5_, a6_ );
+ return b.eval( a );
+ }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+ {
+ rrlist6<A1&, A2&, A3&, A4&, A5&, A6&> a( a1_, a2_, a3_, a4_, a5_, a6_ );
+ return b.eval( a );
+ }
};
template< class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class rrlist7
template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+ {
+ rrlist7<A1&, A2&, A3&, A4&, A5&, A6&, A7&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ );
+ return b.eval( a );
+ }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+ {
+ rrlist7<A1&, A2&, A3&, A4&, A5&, A6&, A7&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ );
+ return b.eval( a );
+ }
};
template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class rrlist8
template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+ {
+ rrlist8<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ );
+ return b.eval( a );
+ }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+ {
+ rrlist8<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ );
+ return b.eval( a );
+ }
};
template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 > class rrlist9
template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+ {
+ rrlist9<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&, A9&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ );
+ return b.eval( a );
+ }
- template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+ template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+ {
+ rrlist9<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&, A9&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ );
+ return b.eval( a );
+ }
};
template<class R, class F, class L> class bind_t
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_THREAD_LOCAL
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
# define BOOST_NO_TYPEID
#endif
-#if defined(__int64) && !defined(__GNUC__)
+#if !__has_feature(cxx_thread_local)
+# define BOOST_NO_CXX11_THREAD_LOCAL
+#endif
+
+#ifdef __is_identifier
+#if !__is_identifier(__int64) && !defined(__GNUC__)
# define BOOST_HAS_MS_INT64
#endif
+#endif
+
+#if __has_include(<stdint.h>)
+# define BOOST_HAS_STDINT_H
+#endif
+
#define BOOST_HAS_NRVO
//
// Currently clang on Windows using VC++ RTL does not support C++11's char16_t or char32_t
//
-#if defined(_MSC_VER) || !(defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
+#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || !(defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
# define BOOST_NO_CXX11_CHAR16_T
# define BOOST_NO_CXX11_CHAR32_T
#endif
+#if defined(_MSC_VER) && (_MSC_VER >= 1800) && !defined(__GNUC__)
+#define BOOST_HAS_EXPM1
+#define BOOST_HAS_LOG1P
+#endif
+
#if !__has_feature(cxx_constexpr)
# define BOOST_NO_CXX11_CONSTEXPR
#endif
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_THREAD_LOCAL
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
// Comeau C++ compiler setup:
-#include "boost/config/compiler/common_edg.hpp"
+#include <boost/config/compiler/common_edg.hpp>
#if (__COMO_VERSION__ <= 4245)
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_THREAD_LOCAL
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#define BOOST_COMPILER "HP Tru64 C++ " BOOST_STRINGIZE(__DECCXX_VER)
-#include "boost/config/compiler/common_edg.hpp"
+#include <boost/config/compiler/common_edg.hpp>
//
// versions check:
# error "Unsupported Cray compiler, please try running the configure script."
#endif
-#include "boost/config/compiler/common_edg.hpp"
+#include <boost/config/compiler/common_edg.hpp>
//
#define BOOST_NO_CXX11_CHAR16_T
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_THREAD_LOCAL
//#define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_THREAD_LOCAL
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
//
#if (BOOST_GCC_VERSION < 40800) || !defined(BOOST_GCC_CXX11)
# define BOOST_NO_CXX11_ALIGNAS
+# define BOOST_NO_CXX11_THREAD_LOCAL
#endif
// C++0x features in 4.8.1 and later
# define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
# define BOOST_NO_CXX11_INLINE_NAMESPACES
# define BOOST_NO_CXX11_REF_QUALIFIERS
-#define BOOST_NO_CXX11_FINAL
+# define BOOST_NO_CXX11_FINAL
+# define BOOST_NO_CXX11_THREAD_LOCAL
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#define BOOST_COMPILER "Greenhills C++ version " BOOST_STRINGIZE(__ghs)
-#include "boost/config/compiler/common_edg.hpp"
+#include <boost/config/compiler/common_edg.hpp>
//
// versions check:
// HP aCC C++ compiler setup:
#if defined(__EDG__)
-#include "boost/config/compiler/common_edg.hpp"
+#include <boost/config/compiler/common_edg.hpp>
#endif
#if (__HP_aCC <= 33100)
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_THREAD_LOCAL
/*
See https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443331 and
#else
-#include "boost/config/compiler/common_edg.hpp"
+#include <boost/config/compiler/common_edg.hpp>
#if defined(__INTEL_COMPILER)
#if __INTEL_COMPILER == 9999
// Kai C++ compiler setup:
-#include "boost/config/compiler/common_edg.hpp"
+#include <boost/config/compiler/common_edg.hpp>
# if (__KCC_VERSION <= 4001) || !defined(BOOST_STRICT_CONFIG)
// at least on Sun, the contents of <cwchar> is not in namespace std
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_THREAD_LOCAL
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_THREAD_LOCAL
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
# define BOOST_NO_CXX11_INLINE_NAMESPACES
# define BOOST_NO_CXX11_REF_QUALIFIERS
# define BOOST_NO_CXX11_FINAL
+# define BOOST_NO_CXX11_THREAD_LOCAL
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_THREAD_LOCAL
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
#define BOOST_COMPILER "SGI Irix compiler version " BOOST_STRINGIZE(_COMPILER_VERSION)
-#include "boost/config/compiler/common_edg.hpp"
+#include <boost/config/compiler/common_edg.hpp>
//
// Threading support:
#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_THREAD_LOCAL
#endif
#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif
+
+// Turn on threading support for Solaris 12.
+// Ticket #11972
+#if (__SUNPRO_CC >= 0x5140) && defined(__SunOS_5_12) && !defined(BOOST_HAS_THREADS)
+# define BOOST_HAS_THREADS
+#endif
+
//
// Version
//
#define BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_NO_CXX11_REF_QUALIFIERS
#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_THREAD_LOCAL
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
# define BOOST_NO_CXX11_DECLTYPE_N3276
#endif
+#if _MSC_FULL_VER >= 180020827
+#define BOOST_HAS_EXPM1
+#define BOOST_HAS_LOG1P
+#endif
+
// C++11 features supported by VC++ 14 (aka 2015)
//
#if (_MSC_FULL_VER < 190023026)
# define BOOST_NO_CXX14_BINARY_LITERALS
# define BOOST_NO_CXX14_GENERIC_LAMBDAS
# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+# define BOOST_NO_CXX11_THREAD_LOCAL
+#endif
+// C++11 features supported by VC++ 14 update 3 (aka 2015)
+//
+#if (_MSC_FULL_VER < 190024210)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+# define BOOST_NO_SFINAE_EXPR
+# define BOOST_NO_CXX11_CONSTEXPR
#endif
// MSVC including version 14 has not yet completely
// See also: http://www.boost.org/libs/utility/value_init.htm#compiler_issues
// (Niels Dekker, LKEB, May 2010)
#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
-// C++11 features not supported by any versions
-#define BOOST_NO_SFINAE_EXPR
-#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
//
-// This is somewhat supported in VC14, but we may need to wait for
-// a service release before enabling:
+// C++ 11:
+//
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
//
-#define BOOST_NO_CXX11_CONSTEXPR
-
// C++ 14:
#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
# define BOOST_NO_CXX14_AGGREGATE_NSDMI
#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
# define BOOST_NO_CXX14_CONSTEXPR
#endif
-#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
-# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
-#endif
//
// prefix and suffix headers:
# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
#endif
+#if !__has_feature(cxx_thread_local)
+# define BOOST_NO_CXX11_THREAD_LOCAL
+#endif
+
#if __cplusplus < 201400
// All versions with __cplusplus above this value seem to support this:
# define BOOST_NO_CXX14_DIGIT_SEPARATORS
// boilerplate code:
#define BOOST_HAS_UNISTD_H
#include <boost/config/posix_features.hpp>
-#ifdef __USE_GNU
+#if defined(__USE_GNU) && !defined(__ANDROID__) && !defined(ANDROID)
#define BOOST_HAS_PTHREAD_YIELD
#endif
//
// This section allows dependency scanners to find all the headers we *might* include:
//
-#include "boost/config/compiler/gcc_xml.hpp"
-#include "boost/config/compiler/cray.hpp"
-#include "boost/config/compiler/comeau.hpp"
-#include "boost/config/compiler/pathscale.hpp"
-#include "boost/config/compiler/intel.hpp"
-#include "boost/config/compiler/clang.hpp"
-#include "boost/config/compiler/digitalmars.hpp"
-#include "boost/config/compiler/gcc.hpp"
-#include "boost/config/compiler/kai.hpp"
-#include "boost/config/compiler/sgi_mipspro.hpp"
-#include "boost/config/compiler/compaq_cxx.hpp"
-#include "boost/config/compiler/greenhills.hpp"
-#include "boost/config/compiler/codegear.hpp"
-#include "boost/config/compiler/borland.hpp"
-#include "boost/config/compiler/metrowerks.hpp"
-#include "boost/config/compiler/sunpro_cc.hpp"
-#include "boost/config/compiler/hp_acc.hpp"
-#include "boost/config/compiler/mpw.hpp"
-#include "boost/config/compiler/vacpp.hpp"
-#include "boost/config/compiler/pgi.hpp"
-#include "boost/config/compiler/visualc.hpp"
+#include <boost/config/compiler/gcc_xml.hpp>
+#include <boost/config/compiler/cray.hpp>
+#include <boost/config/compiler/comeau.hpp>
+#include <boost/config/compiler/pathscale.hpp>
+#include <boost/config/compiler/intel.hpp>
+#include <boost/config/compiler/clang.hpp>
+#include <boost/config/compiler/digitalmars.hpp>
+#include <boost/config/compiler/gcc.hpp>
+#include <boost/config/compiler/kai.hpp>
+#include <boost/config/compiler/sgi_mipspro.hpp>
+#include <boost/config/compiler/compaq_cxx.hpp>
+#include <boost/config/compiler/greenhills.hpp>
+#include <boost/config/compiler/codegear.hpp>
+#include <boost/config/compiler/borland.hpp>
+#include <boost/config/compiler/metrowerks.hpp>
+#include <boost/config/compiler/sunpro_cc.hpp>
+#include <boost/config/compiler/hp_acc.hpp>
+#include <boost/config/compiler/mpw.hpp>
+#include <boost/config/compiler/vacpp.hpp>
+#include <boost/config/compiler/pgi.hpp>
+#include <boost/config/compiler/visualc.hpp>
#endif
#define BOOST_NO_STD_MESSAGES
#endif
+#if (_LIBCPP_VERSION <= 1101) && !defined(BOOST_NO_CXX11_THREAD_LOCAL)
+// This is a bit of a sledgehammer, because really it's just libc++abi that has no
+// support for thread_local, leading to linker errors such as
+// "undefined reference to `__cxa_thread_atexit'". It is fixed in the
+// most recent releases of libc++abi though...
+# define BOOST_NO_CXX11_THREAD_LOCAL
+#endif
+
#if defined(__has_include)
#if !__has_include(<shared_mutex>)
# define BOOST_NO_CXX14_HDR_SHARED_MUTEX
// Oracle Solaris compiler uses it's own verison of libstdc++ but doesn't
// set __GNUC__
//
+#if __SUNPRO_CC >= 0x5140
+#define BOOST_LIBSTDCXX_VERSION 50100
+#else
#define BOOST_LIBSTDCXX_VERSION 40800
#endif
+#endif
#if !defined(BOOST_LIBSTDCXX_VERSION)
# define BOOST_LIBSTDCXX_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#endif
+// std::auto_ptr isn't provided with _GLIBCXX_DEPRECATED=0 (GCC 4.5 and earlier)
+// or _GLIBCXX_USE_DEPRECATED=0 (GCC 4.6 and later).
+#if defined(BOOST_LIBSTDCXX11)
+# if BOOST_LIBSTDCXX_VERSION < 40600
+# if !_GLIBCXX_DEPRECATED
+# define BOOST_NO_AUTO_PTR
+# endif
+# elif !_GLIBCXX_USE_DEPRECATED
+# define BOOST_NO_AUTO_PTR
+# endif
+#endif
+
// C++0x headers in GCC 4.3.0 and later
//
#if (BOOST_LIBSTDCXX_VERSION < 40300) || !defined(BOOST_LIBSTDCXX11)
//
// Headers not present on Solaris with the Oracle compiler:
-#if defined(__SUNPRO_CC)
+#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5140)
#define BOOST_NO_CXX11_HDR_FUTURE
#define BOOST_NO_CXX11_HDR_FORWARD_LIST
#define BOOST_NO_CXX11_HDR_ATOMIC
# define BOOST_NORETURN __declspec(noreturn)
# elif defined(__GNUC__)
# define BOOST_NORETURN __attribute__ ((__noreturn__))
-# else
-# define BOOST_NO_NORETURN
-# define BOOST_NORETURN
+# elif defined(__has_attribute) && defined(__SUNPRO_CC)
+# if __has_attribute(noreturn)
+# define BOOST_NORETURN [[noreturn]]
+# endif
+# elif defined(__has_cpp_attribute)
+# if __has_cpp_attribute(noreturn)
+# define BOOST_NORETURN [[noreturn]]
+# endif
# endif
#endif
+#if !defined(BOOST_NORETURN)
+# define BOOST_NO_NORETURN
+# define BOOST_NORETURN
+#endif
+
// Branch prediction hints
// These macros are intended to wrap conditional expressions that yield true or false
//
// This header is obsolete and will be deprecated.
#include <iterator>
+#if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
+#include <cstddef>
+#endif
namespace boost
{
using std::iterator_traits;
using std::distance;
+#if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
+// std::distance from stlport with Oracle compiler 12.4 and 12.5 fails to deduce template parameters
+// when one of the arguments is an array and the other one is a pointer.
+template< typename T, std::size_t N >
+inline typename std::iterator_traits< T* >::difference_type distance(T (&left)[N], T* right)
+{
+ return std::distance(static_cast< T* >(left), right);
+}
+#endif
+
} // namespace detail
} // namespace boost
template <>
struct get_info<throw_line>;
+ template <class>
+ struct set_info_rv;
+
+ template <>
+ struct set_info_rv<throw_function>;
+
+ template <>
+ struct set_info_rv<throw_file>;
+
+ template <>
+ struct set_info_rv<throw_line>;
+
char const * get_diagnostic_information( exception const &, char const * );
void copy_boost_exception( exception *, exception const * );
friend struct exception_detail::get_info<throw_function>;
friend struct exception_detail::get_info<throw_file>;
friend struct exception_detail::get_info<throw_line>;
+ template <class>
+ friend struct exception_detail::set_info_rv;
+ friend struct exception_detail::set_info_rv<throw_function>;
+ friend struct exception_detail::set_info_rv<throw_file>;
+ friend struct exception_detail::set_info_rv<throw_line>;
friend void exception_detail::copy_boost_exception( exception *, exception const * );
#endif
mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
#include <memory>
#include <new>
#include <boost/config.hpp>
-#include <boost/detail/sp_typeinfo.hpp>
#include <boost/assert.hpp>
#include <boost/integer.hpp>
+#include <boost/type_index.hpp>
#include <boost/type_traits/has_trivial_copy.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
#include <boost/type_traits/is_const.hpp>
# pragma warning( push )
# pragma warning( disable : 4793 ) // complaint about native code generation
# pragma warning( disable : 4127 ) // "conditional expression is constant"
-#endif
-
-// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
-#ifdef BOOST_NO_STD_TYPEINFO
-// Embedded VC++ does not have type_info in namespace std
-# define BOOST_FUNCTION_STD_NS
-#else
-# define BOOST_FUNCTION_STD_NS std
-#endif
-
-// Borrowed from Boost.Python library: determines the cases where we
-// need to use std::type_info::name to compare instead of operator==.
-#if defined( BOOST_NO_TYPEID )
-# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
-#elif defined(__GNUC__) \
- || defined(_AIX) \
- || ( defined(__sgi) && defined(__host_mips))
-# include <cstring>
-# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
- (std::strcmp((X).name(),(Y).name()) == 0)
-# else
-# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
#endif
#if defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
* object pointers, and a structure that resembles a bound
* member function pointer.
*/
- union function_buffer
+ union function_buffer_members
{
// For pointers to function objects
- mutable void* obj_ptr;
+ typedef void* obj_ptr_t;
+ mutable obj_ptr_t obj_ptr;
// For pointers to std::type_info objects
struct type_t {
// (get_functor_type_tag, check_functor_type_tag).
- const detail::sp_typeinfo* type;
+ const boost::typeindex::type_info* type;
// Whether the type is const-qualified.
bool const_qualified;
} type;
// For function pointers of all kinds
- mutable void (*func_ptr)();
+ typedef void (*func_ptr_t)();
+ mutable func_ptr_t func_ptr;
// For bound member pointers
struct bound_memfunc_ptr_t {
bool is_const_qualified;
bool is_volatile_qualified;
} obj_ref;
+ };
+
+ union function_buffer
+ {
+ // Type-specific union members
+ mutable function_buffer_members members;
// To relax aliasing constraints
- mutable char data;
+ mutable char data[sizeof(function_buffer_members)];
};
/**
struct reference_manager
{
static inline void
- manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manage(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op)
{
switch (op) {
- case clone_functor_tag:
- out_buffer.obj_ref = in_buffer.obj_ref;
+ case clone_functor_tag:
+ out_buffer.members.obj_ref = in_buffer.members.obj_ref;
return;
case move_functor_tag:
- out_buffer.obj_ref = in_buffer.obj_ref;
- in_buffer.obj_ref.obj_ptr = 0;
+ out_buffer.members.obj_ref = in_buffer.members.obj_ref;
+ in_buffer.members.obj_ref.obj_ptr = 0;
return;
case destroy_functor_tag:
- out_buffer.obj_ref.obj_ptr = 0;
+ out_buffer.members.obj_ref.obj_ptr = 0;
return;
case check_functor_type_tag:
{
- const detail::sp_typeinfo& check_type
- = *out_buffer.type.type;
-
// Check whether we have the same type. We can add
// cv-qualifiers, but we can't take them away.
- if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F))
- && (!in_buffer.obj_ref.is_const_qualified
- || out_buffer.type.const_qualified)
- && (!in_buffer.obj_ref.is_volatile_qualified
- || out_buffer.type.volatile_qualified))
- out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
+ if (*out_buffer.members.type.type == boost::typeindex::type_id<F>()
+ && (!in_buffer.members.obj_ref.is_const_qualified
+ || out_buffer.members.type.const_qualified)
+ && (!in_buffer.members.obj_ref.is_volatile_qualified
+ || out_buffer.members.type.volatile_qualified))
+ out_buffer.members.obj_ptr = in_buffer.members.obj_ref.obj_ptr;
else
- out_buffer.obj_ptr = 0;
+ out_buffer.members.obj_ptr = 0;
}
return;
case get_functor_type_tag:
- out_buffer.type.type = &BOOST_SP_TYPEID(F);
- out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
- out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
+ out_buffer.members.type.type = &boost::typeindex::type_id<F>().type_info();
+ out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified;
+ out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified;
return;
}
}
struct function_allows_small_object_optimization
{
BOOST_STATIC_CONSTANT
- (bool,
+ (bool,
value = ((sizeof(F) <= sizeof(function_buffer) &&
- (alignment_of<function_buffer>::value
+ (alignment_of<function_buffer>::value
% alignment_of<F>::value == 0))));
};
A(a)
{
}
-
+
functor_wrapper(const functor_wrapper& f) :
F(static_cast<const F&>(f)),
A(static_cast<const A&>(f))
// Function pointers
static inline void
- manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op)
{
if (op == clone_functor_tag)
- out_buffer.func_ptr = in_buffer.func_ptr;
+ out_buffer.members.func_ptr = in_buffer.members.func_ptr;
else if (op == move_functor_tag) {
- out_buffer.func_ptr = in_buffer.func_ptr;
- in_buffer.func_ptr = 0;
+ out_buffer.members.func_ptr = in_buffer.members.func_ptr;
+ in_buffer.members.func_ptr = 0;
} else if (op == destroy_functor_tag)
- out_buffer.func_ptr = 0;
+ out_buffer.members.func_ptr = 0;
else if (op == check_functor_type_tag) {
- const boost::detail::sp_typeinfo& check_type
- = *out_buffer.type.type;
- if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
- out_buffer.obj_ptr = &in_buffer.func_ptr;
+ if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+ out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
else
- out_buffer.obj_ptr = 0;
+ out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ {
- out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
- out_buffer.type.const_qualified = false;
- out_buffer.type.volatile_qualified = false;
+ out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+ out_buffer.members.type.const_qualified = false;
+ out_buffer.members.type.volatile_qualified = false;
}
}
// Function objects that fit in the small-object buffer.
static inline void
- manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op)
{
if (op == clone_functor_tag || op == move_functor_tag) {
- const functor_type* in_functor =
- reinterpret_cast<const functor_type*>(&in_buffer.data);
- new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
+ const functor_type* in_functor =
+ reinterpret_cast<const functor_type*>(in_buffer.data);
+ new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);
if (op == move_functor_tag) {
- functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
+ functor_type* f = reinterpret_cast<functor_type*>(in_buffer.data);
(void)f; // suppress warning about the value of f not being used (MSVC)
f->~Functor();
}
} else if (op == destroy_functor_tag) {
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
- functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
+ functor_type* f = reinterpret_cast<functor_type*>(out_buffer.data);
(void)f; // suppress warning about the value of f not being used (MSVC)
f->~Functor();
} else if (op == check_functor_type_tag) {
- const detail::sp_typeinfo& check_type
- = *out_buffer.type.type;
- if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
- out_buffer.obj_ptr = &in_buffer.data;
+ if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+ out_buffer.members.obj_ptr = in_buffer.data;
else
- out_buffer.obj_ptr = 0;
+ out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ {
- out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
- out_buffer.type.const_qualified = false;
- out_buffer.type.volatile_qualified = false;
+ out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+ out_buffer.members.type.const_qualified = false;
+ out_buffer.members.type.volatile_qualified = false;
}
}
};
// Function pointers
static inline void
- manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, function_ptr_tag)
{
functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
// Function objects that fit in the small-object buffer.
static inline void
- manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, mpl::true_)
{
functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
}
-
+
// Function objects that require heap allocation
static inline void
- manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, mpl::false_)
{
if (op == clone_functor_tag) {
// jewillco: Changing this to static_cast because GCC 2.95.3 is
// obsolete.
const functor_type* f =
- static_cast<const functor_type*>(in_buffer.obj_ptr);
+ static_cast<const functor_type*>(in_buffer.members.obj_ptr);
functor_type* new_f = new functor_type(*f);
- out_buffer.obj_ptr = new_f;
+ out_buffer.members.obj_ptr = new_f;
} else if (op == move_functor_tag) {
- out_buffer.obj_ptr = in_buffer.obj_ptr;
- in_buffer.obj_ptr = 0;
+ out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+ in_buffer.members.obj_ptr = 0;
} else if (op == destroy_functor_tag) {
/* Cast from the void pointer to the functor pointer type */
functor_type* f =
- static_cast<functor_type*>(out_buffer.obj_ptr);
+ static_cast<functor_type*>(out_buffer.members.obj_ptr);
delete f;
- out_buffer.obj_ptr = 0;
+ out_buffer.members.obj_ptr = 0;
} else if (op == check_functor_type_tag) {
- const detail::sp_typeinfo& check_type
- = *out_buffer.type.type;
- if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
- out_buffer.obj_ptr = in_buffer.obj_ptr;
+ if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+ out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
else
- out_buffer.obj_ptr = 0;
+ out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ {
- out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
- out_buffer.type.const_qualified = false;
- out_buffer.type.volatile_qualified = false;
+ out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+ out_buffer.members.type.const_qualified = false;
+ out_buffer.members.type.volatile_qualified = false;
}
}
// object can use the small-object optimization buffer or
// whether we need to allocate it on the heap.
static inline void
- manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, function_obj_tag)
{
manager(in_buffer, out_buffer, op,
// For member pointers, we use the small-object optimization buffer.
static inline void
- manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, member_ptr_tag)
{
manager(in_buffer, out_buffer, op, mpl::true_());
/* Dispatch to an appropriate manager based on whether we have a
function pointer or a function object pointer. */
static inline void
- manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manage(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op)
{
typedef typename get_function_tag<functor_type>::type tag_type;
switch (op) {
case get_functor_type_tag:
- out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
- out_buffer.type.const_qualified = false;
- out_buffer.type.volatile_qualified = false;
+ out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
+ out_buffer.members.type.const_qualified = false;
+ out_buffer.members.type.volatile_qualified = false;
return;
default:
// Function pointers
static inline void
- manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, function_ptr_tag)
{
functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
// Function objects that fit in the small-object buffer.
static inline void
- manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, mpl::true_)
{
functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
}
-
+
// Function objects that require heap allocation
static inline void
- manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, mpl::false_)
{
typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
// can't do the static_cast that we should do.
const functor_wrapper_type* f =
- static_cast<const functor_wrapper_type*>(in_buffer.obj_ptr);
+ static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr);
wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
wrapper_allocator.construct(copy, *f);
// Get back to the original pointer type
functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
- out_buffer.obj_ptr = new_f;
+ out_buffer.members.obj_ptr = new_f;
} else if (op == move_functor_tag) {
- out_buffer.obj_ptr = in_buffer.obj_ptr;
- in_buffer.obj_ptr = 0;
+ out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+ in_buffer.members.obj_ptr = 0;
} else if (op == destroy_functor_tag) {
/* Cast from the void pointer to the functor_wrapper_type */
functor_wrapper_type* victim =
- static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
+ static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr);
wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
wrapper_allocator.destroy(victim);
wrapper_allocator.deallocate(victim,1);
- out_buffer.obj_ptr = 0;
+ out_buffer.members.obj_ptr = 0;
} else if (op == check_functor_type_tag) {
- const detail::sp_typeinfo& check_type
- = *out_buffer.type.type;
- if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
- out_buffer.obj_ptr = in_buffer.obj_ptr;
+ if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+ out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
else
- out_buffer.obj_ptr = 0;
+ out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ {
- out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
- out_buffer.type.const_qualified = false;
- out_buffer.type.volatile_qualified = false;
+ out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+ out_buffer.members.type.const_qualified = false;
+ out_buffer.members.type.volatile_qualified = false;
}
}
// object can use the small-object optimization buffer or
// whether we need to allocate it on the heap.
static inline void
- manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, function_obj_tag)
{
manager(in_buffer, out_buffer, op,
/* Dispatch to an appropriate manager based on whether we have a
function pointer or a function object pointer. */
static inline void
- manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+ manage(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op)
{
typedef typename get_function_tag<functor_type>::type tag_type;
switch (op) {
case get_functor_type_tag:
- out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
- out_buffer.type.const_qualified = false;
- out_buffer.type.volatile_qualified = false;
+ out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
+ out_buffer.members.type.const_qualified = false;
+ out_buffer.members.type.volatile_qualified = false;
return;
default:
*/
struct vtable_base
{
- void (*manager)(const function_buffer& in_buffer,
- function_buffer& out_buffer,
+ void (*manager)(const function_buffer& in_buffer,
+ function_buffer& out_buffer,
functor_manager_operation_type op);
};
} // end namespace function
/** Determine if the function is empty (i.e., has no target). */
bool empty() const { return !vtable; }
- /** Retrieve the type of the stored function object, or BOOST_SP_TYPEID(void)
+ /** Retrieve the type of the stored function object, or type_id<void>()
if this is empty. */
- const detail::sp_typeinfo& target_type() const
+ const boost::typeindex::type_info& target_type() const
{
- if (!vtable) return BOOST_SP_TYPEID(void);
+ if (!vtable) return boost::typeindex::type_id<void>().type_info();
detail::function::function_buffer type;
get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
- return *type.type.type;
+ return *type.members.type.type;
}
template<typename Functor>
if (!vtable) return 0;
detail::function::function_buffer type_result;
- type_result.type.type = &BOOST_SP_TYPEID(Functor);
- type_result.type.const_qualified = is_const<Functor>::value;
- type_result.type.volatile_qualified = is_volatile<Functor>::value;
- get_vtable()->manager(functor, type_result,
+ type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+ type_result.members.type.const_qualified = is_const<Functor>::value;
+ type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
+ get_vtable()->manager(functor, type_result,
detail::function::check_functor_type_tag);
- return static_cast<Functor*>(type_result.obj_ptr);
+ return static_cast<Functor*>(type_result.members.obj_ptr);
}
template<typename Functor>
if (!vtable) return 0;
detail::function::function_buffer type_result;
- type_result.type.type = &BOOST_SP_TYPEID(Functor);
- type_result.type.const_qualified = true;
- type_result.type.volatile_qualified = is_volatile<Functor>::value;
- get_vtable()->manager(functor, type_result,
+ type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+ type_result.members.type.const_qualified = true;
+ type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
+ get_vtable()->manager(functor, type_result,
detail::function::check_functor_type_tag);
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
// can't do the static_cast that we should do.
- return static_cast<const Functor*>(type_result.obj_ptr);
+ return static_cast<const Functor*>(type_result.members.obj_ptr);
}
template<typename F>
} // end namespace boost
#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
-#undef BOOST_FUNCTION_COMPARE_TYPE_ID
#if defined(BOOST_MSVC)
# pragma warning( pop )
-#endif
+#endif
#endif // BOOST_FUNCTION_BASE_HEADER
#if defined(BOOST_MSVC)
# pragma warning( push )
# pragma warning( disable : 4127 ) // "conditional expression is constant"
-#endif
+#endif
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
BOOST_FUNCTION_PARMS)
{
- FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+ FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
return f(BOOST_FUNCTION_ARGS);
}
};
BOOST_FUNCTION_PARMS)
{
- FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+ FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
}
};
{
FunctionObj* f;
if (function_allows_small_object_optimization<FunctionObj>::value)
- f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+ f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
else
- f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+ f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
return (*f)(BOOST_FUNCTION_ARGS);
}
};
{
FunctionObj* f;
if (function_allows_small_object_optimization<FunctionObj>::value)
- f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+ f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
else
- f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+ f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
}
};
BOOST_FUNCTION_PARMS)
{
- FunctionObj* f =
- reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+ FunctionObj* f =
+ reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
return (*f)(BOOST_FUNCTION_ARGS);
}
};
BOOST_FUNCTION_PARMS)
{
- FunctionObj* f =
- reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+ FunctionObj* f =
+ reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
}
};
BOOST_FUNCTION_PARMS)
{
- MemberPtr* f =
- reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+ MemberPtr* f =
+ reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
}
};
BOOST_FUNCTION_PARMS)
{
- MemberPtr* f =
- reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+ MemberPtr* f =
+ reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
}
};
/* Given the tag returned by get_function_tag, retrieve the
actual invoker that will be used for the given function
- object.
+ object.
Each specialization contains an "apply" nested class template
that accepts the function object, return type, function
private:
// Function pointers
template<typename FunctionPtr>
- bool
+ bool
assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
{
this->clear(functor);
if (f) {
// should be a reinterpret cast, but some compilers insist
// on giving cv-qualifiers to free functions
- functor.func_ptr = reinterpret_cast<void (*)()>(f);
+ functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
return true;
} else {
return false;
}
}
template<typename FunctionPtr,typename Allocator>
- bool
+ bool
assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
{
return assign_to(f,functor,function_ptr_tag());
// Function objects
// Assign to a function object using the small object optimization
template<typename FunctionObj>
- void
+ void
assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
{
- new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+ new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
}
template<typename FunctionObj,typename Allocator>
- void
+ void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
{
assign_functor(f,functor,mpl::true_());
// Assign to a function object allocated on the heap.
template<typename FunctionObj>
- void
+ void
assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
{
- functor.obj_ptr = new FunctionObj(f);
+ functor.members.obj_ptr = new FunctionObj(f);
}
template<typename FunctionObj,typename Allocator>
- void
+ void
assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
{
typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
- functor.obj_ptr = new_f;
+ functor.members.obj_ptr = new_f;
}
template<typename FunctionObj>
- bool
+ bool
assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
{
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
- assign_functor(f, functor,
+ assign_functor(f, functor,
mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
return true;
} else {
}
}
template<typename FunctionObj,typename Allocator>
- bool
+ bool
assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
{
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
// Reference to a function object
template<typename FunctionObj>
- bool
- assign_to(const reference_wrapper<FunctionObj>& f,
+ bool
+ assign_to(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, function_obj_ref_tag) const
{
- functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
- functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
- functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+ functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+ functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+ functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
return true;
}
template<typename FunctionObj,typename Allocator>
- bool
- assign_to_a(const reference_wrapper<FunctionObj>& f,
+ bool
+ assign_to_a(const reference_wrapper<FunctionObj>& f,
function_buffer& functor, Allocator, function_obj_ref_tag) const
{
return assign_to(f,functor,function_obj_ref_tag());
{
this->assign_to_own(f);
}
-
+
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_FUNCTION_FUNCTION(BOOST_FUNCTION_FUNCTION&& f) : function_base()
{
this->move_assign(f);
}
#endif
-
+
~BOOST_FUNCTION_FUNCTION() { clear(); }
result_type operator()(BOOST_FUNCTION_PARMS) const
BOOST_CATCH_END
return *this;
}
-
+
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
// Move assignment from another BOOST_FUNCTION_FUNCTION
BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f)
{
-
if (&f == this)
return *this;
typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
typedef typename get_invoker::
- template apply<Functor, R BOOST_FUNCTION_COMMA
+ template apply<Functor, R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS>
handler_type;
-
+
typedef typename handler_type::invoker_type invoker_type;
typedef typename handler_type::manager_type manager_type;
// static initialization. Otherwise, we will have a race
// condition here in multi-threaded code. See
// http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
- static const vtable_type stored_vtable =
+ static const vtable_type stored_vtable =
{ { &manager_type::manage }, &invoker_type::invoke };
if (stored_vtable.assign_to(f, functor)) {
boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
- } else
+ } else
vtable = 0;
}
typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
typedef typename get_invoker::
- template apply_a<Functor, R BOOST_FUNCTION_COMMA
+ template apply_a<Functor, R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS,
Allocator>
handler_type;
-
+
typedef typename handler_type::invoker_type invoker_type;
typedef typename handler_type::manager_type manager_type;
static const vtable_type stored_vtable =
{ { &manager_type::manage }, &invoker_type::invoke };
- if (stored_vtable.assign_to_a(f, functor, a)) {
+ if (stored_vtable.assign_to_a(f, functor, a)) {
std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
// coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
if (boost::has_trivial_copy_constructor<Functor>::value &&
boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
- } else
+ } else
vtable = 0;
}
- // Moves the value from the specified argument to *this. If the argument
- // has its function object allocated on the heap, move_assign will pass
- // its buffer to *this, and set the argument's buffer pointer to NULL.
- void move_assign(BOOST_FUNCTION_FUNCTION& f)
- {
+ // Moves the value from the specified argument to *this. If the argument
+ // has its function object allocated on the heap, move_assign will pass
+ // its buffer to *this, and set the argument's buffer pointer to NULL.
+ void move_assign(BOOST_FUNCTION_FUNCTION& f)
+ {
if (&f == this)
return;
function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
#endif
-
+
self_type& operator=(const self_type& f)
{
self_type(f).swap(*this);
self_type(static_cast<self_type&&>(f)).swap(*this);
return *this;
}
-#endif
+#endif
template<typename Functor>
#ifndef BOOST_NO_SFINAE
self_type(f).swap(*this);
return *this;
}
-
+
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
self_type& operator=(base_type&& f)
{
self_type(static_cast<base_type&&>(f)).swap(*this);
return *this;
}
-#endif
+#endif
};
#undef BOOST_FUNCTION_PARTIAL_SPEC
#if defined(BOOST_MSVC)
# pragma warning( pop )
-#endif
+#endif
seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
}
- template <typename SizeT>
inline void hash_combine_impl(boost::uint32_t& h1,
boost::uint32_t k1)
{
}
-// Don't define 64-bit hash combine on platforms with 64 bit integers,
+// Don't define 64-bit hash combine on platforms without 64 bit integers,
// and also not for 32-bit gcc as it warns about the 64-bit constant.
#if !defined(BOOST_NO_INT64_T) && \
!(defined(__GNUC__) && ULONG_MAX == 0xffffffff)
- template <typename SizeT>
inline void hash_combine_impl(boost::uint64_t& h,
boost::uint64_t k)
{
h ^= k;
h *= m;
+
+ // Completely arbitrary number, to prevent 0's
+ // from hashing to 0.
+ h += 0xe6546b64;
}
#endif // BOOST_NO_INT64_T
template <std::size_t N>
bool operator<<(boost::array<const CharT, N> const& input) BOOST_NOEXCEPT {
- return shl_char_array_limited(input.begin(), N);
+ return shl_char_array_limited(input.data(), N);
}
template <std::size_t N>
template <class C, std::size_t N>
bool operator>>(std::array<C, N>& output) BOOST_NOEXCEPT {
BOOST_STATIC_ASSERT_MSG(
- (sizeof(boost::array<C, N>) == sizeof(boost::array<C, N>)),
+ (sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)),
"std::array<C, N> and boost::array<C, N> must have exactly the same layout."
);
return ((*this) >> reinterpret_cast<boost::array<C, N>& >(output));
template <class T, class Digits>
struct series_factor_calc<T, Digits, mpl::true_, mpl::false_>
{
- BOOST_STATIC_CONSTANT(boost::uintmax_t, v = static_cast<boost::uintmax_t>(1u) << (Digits::value - 1));
-
static BOOST_MATH_CONSTEXPR T get() BOOST_MATH_NOEXCEPT(T)
{
- return 1 / static_cast<T>(v);
+ return 1 / static_cast<T>(static_cast<boost::uintmax_t>(1u) << (Digits::value - 1));
}
};
template <class T, class Digits>
#endif
-#endif // BOOST_MATH_TOOLS_CONFIG_HPP
+//
+// Thread local storage:
+//
+#if !defined(BOOST_NO_CXX11_THREAD_LOCAL) && !defined(BOOST_INTEL)
+# define BOOST_MATH_THREAD_LOCAL thread_local
+#else
+# define BOOST_MATH_THREAD_LOCAL
+#endif
+#endif // BOOST_MATH_TOOLS_CONFIG_HPP
template < static_gcd_type Value1, static_gcd_type Value2 >
struct static_lcm;
-
-// From <boost/math/common_factor_rt.hpp> ----------------------------------//
-
-template < typename IntegerType >
- class gcd_evaluator;
-template < typename IntegerType >
- class lcm_evaluator;
-
-// Also has a couple of function templates
-
-
} // namespace math
} // namespace boost
//! using boost::adl_move_swap.
//!
//! Parameters:
-//! first1, last1 - the first range of elements to swap
-//! first2 - beginning of the second range of elements to swap
+//! first1, last1 - the first range of elements to swap
+//! first2 - beginning of the second range of elements to swap
//!
//! Type requirements:
//! - ForwardIt1, ForwardIt2 must meet the requirements of ForwardIterator.
}
}
BOOST_CATCH(...){
- for (; back != r; ++back){
+ for (; back != r; ++back){
back->~input_value_type();
}
- BOOST_RETHROW;
+ BOOST_RETHROW;
}
BOOST_CATCH_END
return r;
#define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
public:\
- TYPE& operator=(TYPE &t)\
- { this->operator=(const_cast<const TYPE &>(t)); return *this;}\
+ BOOST_MOVE_FORCEINLINE TYPE& operator=(TYPE &t)\
+ { this->operator=(const_cast<const TYPE&>(t)); return *this;}\
public:\
BOOST_MOVE_FORCEINLINE operator ::boost::rv<TYPE>&() \
{ return *BOOST_MOVE_TO_RV_CAST(::boost::rv<TYPE>*, this); }\
static const bool value = true;
};
+//////////////////////////////////////
+// enable_if_same
+//////////////////////////////////////
+template <class T, class U, class R = void>
+struct enable_if_same : enable_if<is_same<T, U>, R> {};
+
+//////////////////////////////////////
+// disable_if_same
+//////////////////////////////////////
+template <class T, class U, class R = void>
+struct disable_if_same : disable_if<is_same<T, U>, R> {};
+
} //namespace move_detail {
} //namespace boost {
// BOOST_MOVE_IS_POD(T) should evaluate to true if T is a POD type
// BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect
// BOOST_MOVE_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy
+// (Note: this trait does not guarantee T is copy constructible, the copy constructor could be deleted but still be trivial)
// BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) should evaluate to true if T(boost::move(t)) <==> memcpy
// BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy
+// (Note: this trait does not guarantee T is assignable , the copy assignmen could be deleted but still be trivial)
// BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) should evaluate to true if t = boost::move(u) <==> memcpy
// BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect
// BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) should evaluate to true if "T x;" can not throw
# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
# endif
# if __has_feature(has_trivial_copy)
-# //There are problems with deleted copy constructors detected as trivially copyable.
-# //http://stackoverflow.com/questions/12754886/has-trivial-copy-behaves-differently-in-clang-and-gcc-whos-right
-# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && ::boost::move_detail::is_copy_constructible<T>::value)
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) __has_trivial_copy(T)
# endif
# if __has_feature(has_trivial_assign)
# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) )
#endif
#ifdef BOOST_MOVE_HAS_TRIVIAL_COPY
- #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_COPY(T)
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value ||\
+ (::boost::move_detail::is_copy_constructible<T>::value &&\
+ BOOST_MOVE_HAS_TRIVIAL_COPY(T))
#else
#define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
#endif
#define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
#endif
-#ifdef BOOST_MOVE_HAS_TRIVIAL_COPY
- #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_COPY(T)
-#else
- #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
-#endif
-
#ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR
#define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)
#else
#endif
#ifdef BOOST_MOVE_HAS_TRIVIAL_ASSIGN
- #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T)
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value ||\
+ ( ::boost::move_detail::is_copy_assignable<T>::value &&\
+ BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T))
#else
#define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
#endif
{
//In several compilers BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE return true even with
//deleted copy constructors so make sure the type is copy constructible.
- static const bool value = ::boost::move_detail::is_pod<T>::value ||
- ( ::boost::move_detail::is_copy_constructible<T>::value &&
- BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) );
+ static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T);
};
//////////////////////////////////////
//////////////////////////////////////
template<class T>
struct is_trivially_move_constructible
-{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T); };
+{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T); };
//////////////////////////////////////
// is_trivially_copy_assignable
{
//In several compilers BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE return true even with
//deleted copy constructors so make sure the type is copy constructible.
- static const bool value = ::boost::move_detail::is_pod<T>::value ||
- ( ::boost::move_detail::is_copy_assignable<T>::value &&
- BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) );
+ static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T);
};
//////////////////////////////////////
template<class T, std::size_t Len>
union aligned_union
-{
+{
T aligner;
char dummy[Len];
};
//End of search defaults to max_align_t
template<std::size_t Len, std::size_t Align>
struct aligned_next<Len, Align, max_align_t, false>
-{ typedef aligned_union<max_align_t, Len> type; };
+{ typedef aligned_union<max_align_t, Len> type; };
//Now define a search list through types
#define BOOST_MOVE_ALIGNED_NEXT_STEP(TYPE, NEXT_TYPE)\
#ifndef BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP
#define BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP
-#include <boost/config/suffix.hpp>
+#include <boost/config.hpp>
namespace boost {
// ---------------------------------
/*`
- [heading `BOOST_HW_SIMD_X86_SSE4A_VERSION`]
+ [heading `BOOST_HW_SIMD_X86_AMD_SSE4A_VERSION`]
[@https://en.wikipedia.org/wiki/SSE4##SSE4A SSE4A] x86 extension (AMD specific).
#define BOOST_HW_SIMD_X86_AMD_SSE4A_VERSION BOOST_VERSION_NUMBER(4, 0, 0)
/*`
- [heading `BOOST_HW_SIMD_X86_FMA4_VERSION`]
+ [heading `BOOST_HW_SIMD_X86_AMD_FMA4_VERSION`]
[@https://en.wikipedia.org/wiki/FMA_instruction_set#FMA4_instruction_set FMA4] x86 extension (AMD specific).
#define BOOST_HW_SIMD_X86_AMD_FMA4_VERSION BOOST_VERSION_NUMBER(5, 1, 0)
/*`
- [heading `BOOST_HW_SIMD_X86_XOP_VERSION`]
+ [heading `BOOST_HW_SIMD_X86_AMD_XOP_VERSION`]
[@https://en.wikipedia.org/wiki/XOP_instruction_set XOP] x86 extension (AMD specific).
#pragma warning(disable:4244 4800)
#endif
+inline boost::intmax_t umax(mpl::false_ const&)
+{
+ // Get out clause here, just in case numeric_limits is unspecialized:
+ return std::numeric_limits<boost::intmax_t>::is_specialized ? (std::numeric_limits<boost::intmax_t>::max)() : INT_MAX;
+}
+inline boost::intmax_t umax(mpl::true_ const&)
+{
+ return (std::numeric_limits<std::size_t>::max)();
+}
+
+inline boost::intmax_t umax()
+{
+ return umax(mpl::bool_<std::numeric_limits<boost::intmax_t>::digits >= std::numeric_limits<std::size_t>::digits>());
+}
+
template <class charT, class traits>
class basic_regex_parser : public basic_regex_creator<charT, traits>
{
template <class charT, class traits>
bool basic_regex_parser<charT, traits>::parse_basic_escape()
{
- ++m_position;
+ if(++m_position == m_end)
+ {
+ fail(regex_constants::error_paren, m_position - m_base);
+ return false;
+ }
bool result = true;
switch(this->m_traits.escape_syntax_type(*m_position))
{
return false;
}
const charT* pc = m_position;
- int i = this->m_traits.toi(pc, m_end, 10);
+ boost::intmax_t i = this->m_traits.toi(pc, m_end, 10);
if((i < 0) && syn_end)
{
// Check for a named capture, get the leftmost one if there is more than one:
// parse a repeat-range:
//
std::size_t min, max;
- int v;
+ boost::intmax_t v;
// skip whitespace:
while((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space))
++m_position;
// get min:
v = this->m_traits.toi(m_position, m_end, 10);
// skip whitespace:
- if(v < 0)
+ if((v < 0) || (v > umax()))
{
if(this->flags() & (regbase::main_option_type | regbase::no_perl_ex))
{
while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_brace) --m_position;
return parse_literal();
}
- min = v;
+ min = static_cast<std::size_t>(v);
// see if we have a comma:
if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_comma)
{
}
// get the value if any:
v = this->m_traits.toi(m_position, m_end, 10);
- max = (v >= 0) ? (std::size_t)v : (std::numeric_limits<std::size_t>::max)();
+ max = ((v >= 0) && (v < umax())) ? (std::size_t)v : (std::numeric_limits<std::size_t>::max)();
}
else
{
// does a value fit in the specified charT type?
//
template <class charT>
-bool valid_value(charT, int v, const mpl::true_&)
+bool valid_value(charT, boost::intmax_t v, const mpl::true_&)
{
return (v >> (sizeof(charT) * CHAR_BIT)) == 0;
}
template <class charT>
-bool valid_value(charT, int, const mpl::false_&)
+bool valid_value(charT, boost::intmax_t, const mpl::false_&)
{
return true; // v will alsways fit in a charT
}
template <class charT>
-bool valid_value(charT c, int v)
+bool valid_value(charT c, boost::intmax_t v)
{
- return valid_value(c, v, mpl::bool_<(sizeof(charT) < sizeof(int))>());
+ return valid_value(c, v, mpl::bool_<(sizeof(charT) < sizeof(boost::intmax_t))>());
}
template <class charT, class traits>
fail(regex_constants::error_escape, m_position - m_base, "Missing } in hexadecimal escape sequence.");
return result;
}
- int i = this->m_traits.toi(m_position, m_end, 16);
+ boost::intmax_t i = this->m_traits.toi(m_position, m_end, 16);
if((m_position == m_end)
|| (i < 0)
- || ((std::numeric_limits<charT>::is_specialized) && (i > (int)(std::numeric_limits<charT>::max)()))
+ || ((std::numeric_limits<charT>::is_specialized) && (i > (boost::intmax_t)(std::numeric_limits<charT>::max)()))
|| (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace))
{
// Rewind to start of escape:
else
{
std::ptrdiff_t len = (std::min)(static_cast<std::ptrdiff_t>(2), static_cast<std::ptrdiff_t>(m_end - m_position));
- int i = this->m_traits.toi(m_position, m_position + len, 16);
+ boost::intmax_t i = this->m_traits.toi(m_position, m_position + len, 16);
if((i < 0)
|| !valid_value(charT(0), i))
{
// followed by up to 3 octal digits:
std::ptrdiff_t len = (std::min)(::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end), static_cast<std::ptrdiff_t>(4));
const charT* bp = m_position;
- int val = this->m_traits.toi(bp, bp + 1, 8);
+ boost::intmax_t val = this->m_traits.toi(bp, bp + 1, 8);
if(val != 0)
{
// Rewind to start of escape:
return result;
}
val = this->m_traits.toi(m_position, m_position + len, 8);
- if(val < 0)
+ if((val < 0) || (val > (boost::intmax_t)(std::numeric_limits<charT>::max)()))
{
// Rewind to start of escape:
--m_position;
{
BOOST_ASSERT(m_position != m_end);
const charT* pc = m_position;
- int i = this->m_traits.toi(pc, pc + 1, 10);
+ boost::intmax_t i = this->m_traits.toi(pc, pc + 1, 10);
if((i == 0) || (((this->flags() & regbase::main_option_type) == regbase::perl_syntax_group) && (this->flags() & regbase::no_bk_refs)))
{
// not a backref at all but an octal escape sequence:
int max_mark = m_max_mark;
m_mark_reset = -1;
m_max_mark = m_mark_count;
- int v;
+ boost::intmax_t v;
//
// select the actual extension used:
//
return m_pimpl->isctype(c, f);
#endif
}
- int toi(const charT*& p1, const charT* p2, int radix)const;
+ boost::intmax_t toi(const charT*& p1, const charT* p2, int radix)const;
int value(charT c, int radix)const
{
const charT* pc = &c;
- return toi(pc, pc + 1, radix);
+ return (int)toi(pc, pc + 1, radix);
}
locale_type imbue(locale_type l)
{
template <class charT>
-int cpp_regex_traits<charT>::toi(const charT*& first, const charT* last, int radix)const
+boost::intmax_t cpp_regex_traits<charT>::toi(const charT*& first, const charT* last, int radix)const
{
BOOST_REGEX_DETAIL_NS::parser_buf<charT> sbuf; // buffer for parsing numbers.
std::basic_istream<charT> is(&sbuf); // stream for parsing numbers.
if(std::abs(radix) == 16) is >> std::hex;
else if(std::abs(radix) == 8) is >> std::oct;
else is >> std::dec;
- int val;
+ boost::intmax_t val;
if(is >> val)
{
first = first + ((last - first) - sbuf.in_avail());
#endif
} // namespace
template BOOST_REGEX_DECL
-int cpp_regex_traits<BOOST_REGEX_CHAR_T>::toi(const BOOST_REGEX_CHAR_T*& first, const BOOST_REGEX_CHAR_T* last, int radix)const;
+boost::intmax_t cpp_regex_traits<BOOST_REGEX_CHAR_T>::toi(const BOOST_REGEX_CHAR_T*& first, const BOOST_REGEX_CHAR_T* last, int radix)const;
template BOOST_REGEX_DECL
std::string cpp_regex_traits<BOOST_REGEX_CHAR_T>::catalog_name(const std::string& name);
template BOOST_REGEX_DECL
bool unwind_recursion_pop(bool);
bool unwind_commit(bool);
bool unwind_then(bool);
+ bool unwind_case(bool);
void destroy_single_repeat();
void push_matched_paren(int index, const sub_match<BidiIterator>& sub);
void push_recursion_stopper();
void push_non_greedy_repeat(const re_syntax_base* ps);
void push_recursion(int idx, const re_syntax_base* p, results_type* presults);
void push_recursion_pop();
+ void push_case_change(bool);
// pointer to base of stack:
saved_state* m_stack_base;
search_base = base;
state_count = 0;
m_match_flags |= regex_constants::match_all;
- m_presult->set_size((m_match_flags & match_nosubs) ? 1 : 1 + re.mark_count(), search_base, last);
+ m_presult->set_size((m_match_flags & match_nosubs) ? 1u : static_cast<typename results_type::size_type>(1u + re.mark_count()), search_base, last);
m_presult->set_base(base);
m_presult->set_named_subs(this->re.get_named_subs());
if(m_match_flags & match_posix)
// reset our state machine:
search_base = position = base;
pstate = re.get_first_state();
- m_presult->set_size((m_match_flags & match_nosubs) ? 1 : 1 + re.mark_count(), base, last);
+ m_presult->set_size((m_match_flags & match_nosubs) ? 1u : static_cast<typename results_type::size_type>(1u + re.mark_count()), base, last);
m_presult->set_base(base);
m_presult->set_named_subs(this->re.get_named_subs());
m_match_flags |= regex_constants::match_init;
++position;
}
// reset $` start:
- m_presult->set_size((m_match_flags & match_nosubs) ? 1 : 1 + re.mark_count(), search_base, last);
+ m_presult->set_size((m_match_flags & match_nosubs) ? 1u : static_cast<typename results_type::size_type>(1u + re.mark_count()), search_base, last);
//if((base != search_base) && (base == backstop))
// m_match_flags |= match_prev_avail;
}
if(m_match_flags & match_posix)
{
- m_result.set_size(1 + re.mark_count(), base, last);
+ m_result.set_size(static_cast<typename results_type::size_type>(1u + re.mark_count()), base, last);
m_result.set_base(base);
}
return result;
}
-template <class BidiIterator, class Allocator, class traits>
-bool perl_matcher<BidiIterator, Allocator, traits>::match_toggle_case()
-{
- // change our case sensitivity:
- this->icase = static_cast<const re_case*>(pstate)->icase;
- pstate = pstate->next.p;
- return true;
-}
-
template <class BidiIterator, class Allocator, class traits>
bool perl_matcher<BidiIterator, Allocator, traits>::match_fail()
{
Results results;
};
+struct saved_change_case : public saved_state
+{
+ bool icase;
+ saved_change_case(bool c) : saved_state(18), icase(c) {}
+};
+
template <class BidiIterator, class Allocator, class traits>
bool perl_matcher<BidiIterator, Allocator, traits>::match_all_states()
{
m_backup_state = pmp;
}
+template <class BidiIterator, class Allocator, class traits>
+inline void perl_matcher<BidiIterator, Allocator, traits>::push_case_change(bool c)
+{
+ //BOOST_ASSERT(index);
+ saved_change_case* pmp = static_cast<saved_change_case*>(m_backup_state);
+ --pmp;
+ if(pmp < m_stack_base)
+ {
+ extend_stack();
+ pmp = static_cast<saved_change_case*>(m_backup_state);
+ --pmp;
+ }
+ (void) new (pmp)saved_change_case(c);
+ m_backup_state = pmp;
+}
+
template <class BidiIterator, class Allocator, class traits>
inline void perl_matcher<BidiIterator, Allocator, traits>::push_recursion_stopper()
{
m_backup_state = pmp;
}
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::match_toggle_case()
+{
+ // change our case sensitivity:
+ push_case_change(this->icase);
+ this->icase = static_cast<const re_case*>(pstate)->icase;
+ pstate = pstate->next.p;
+ return true;
+}
+
template <class BidiIterator, class Allocator, class traits>
bool perl_matcher<BidiIterator, Allocator, traits>::match_startmark()
{
&perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_pop,
&perl_matcher<BidiIterator, Allocator, traits>::unwind_commit,
&perl_matcher<BidiIterator, Allocator, traits>::unwind_then,
+ &perl_matcher<BidiIterator, Allocator, traits>::unwind_case,
};
m_recursive_result = have_match;
return false; // end of stack nothing more to search
}
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::unwind_case(bool)
+{
+ saved_change_case* pmp = static_cast<saved_change_case*>(m_backup_state);
+ icase = pmp->icase;
+ boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
+ m_backup_state = pmp;
+ return true;
+}
+
template <class BidiIterator, class Allocator, class traits>
bool perl_matcher<BidiIterator, Allocator, traits>::unwind_paren(bool have_match)
{
BidiIterator oldposition(position);
const re_syntax_base* old_pstate = jmp->alt.p;
pstate = pstate->next.p;
+ bool oldcase = icase;
m_have_then = false;
if(!match_all_states())
{
pstate = old_pstate;
position = oldposition;
+ icase = oldcase;
if(m_have_then)
{
m_can_backtrack = true;
return false;
}
+template <class BidiIterator, class Allocator, class traits>
+bool perl_matcher<BidiIterator, Allocator, traits>::match_toggle_case()
+{
+ // change our case sensitivity:
+ bool oldcase = this->icase;
+ this->icase = static_cast<const re_case*>(pstate)->icase;
+ pstate = pstate->next.p;
+ bool result = match_all_states();
+ this->icase = oldcase;
+ return result;
+}
+
+
+
template <class BidiIterator, class Allocator, class traits>
bool perl_matcher<BidiIterator, Allocator, traits>::skip_until_paren(int index, bool have_match)
{
}
int toi(const charT*& p1, const charT* p2, int radix)const
{
- return global_toi(p1, p2, radix, *this);
+ return (int)global_toi(p1, p2, radix, *this);
}
};
std::vector<char_type> v(i, j);
const char_type* start = &v[0];
const char_type* pos = start;
- int r = m_traits.toi(pos, &v[0] + v.size(), base);
+ int r = (int)m_traits.toi(pos, &v[0] + v.size(), base);
std::advance(i, pos - start);
return r;
}
{
return ((c & 0x7f) == c) ? get_default_escape_syntax_type(static_cast<char>(c)) : ::boost::regex_constants::escape_type_identity;
}
- int toi(const char_type*& p1, const char_type* p2, int radix)const
+ boost::intmax_t toi(const char_type*& p1, const char_type* p2, int radix)const
{
return ::boost::BOOST_REGEX_DETAIL_NS::global_toi(p1, p2, radix, *this);
}
return -1;
}
template <class charT, class traits>
-int global_toi(const charT*& p1, const charT* p2, int radix, const traits& t)
+boost::intmax_t global_toi(const charT*& p1, const charT* p2, int radix, const traits& t)
{
(void)t; // warning suppression
- int next_value = t.value(*p1, radix);
+ boost::intmax_t next_value = t.value(*p1, radix);
if((p1 == p2) || (next_value < 0) || (next_value >= radix))
return -1;
- int result = 0;
+ boost::intmax_t result = 0;
while(p1 != p2)
{
next_value = t.value(*p1, radix);
return true;
return false;
}
- int toi(const charT*& p1, const charT* p2, int radix)const
+ boost::intmax_t toi(const charT*& p1, const charT* p2, int radix)const
{
return ::boost::BOOST_REGEX_DETAIL_NS::global_toi(p1, p2, radix, *this);
}
int value(charT c, int radix)const
{
- int result = ::boost::BOOST_REGEX_DETAIL_NS::global_value(c);
+ int result = (int)::boost::BOOST_REGEX_DETAIL_NS::global_value(c);
return result < radix ? result : -1;
}
locale_type imbue(locale_type l)
struct foreign_shared_ptr_impl_base
{
virtual ~foreign_shared_ptr_impl_base() {}
- virtual void* get() const = 0;
virtual foreign_shared_ptr_impl_base * clone() const = 0;
};
public:
foreign_shared_ptr_impl(const FSP &p): _p(p)
{}
- virtual void * get() const
- {
- return _p.get();
- }
virtual foreign_shared_ptr_impl * clone() const
{
return new foreign_shared_ptr_impl(*this);
shared_ptr<detail::BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
<BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION> >
shared_pimpl(_weak_pimpl.lock());
- if(shared_pimpl == 0) throw expired_slot();
return (*shared_pimpl)(BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
}
result_type operator ()(BOOST_SIGNALS2_SIGNATURE_FULL_ARGS(BOOST_SIGNALS2_NUM_ARGS)) const
shared_ptr<detail::BOOST_SIGNALS2_SIGNAL_IMPL_CLASS_NAME(BOOST_SIGNALS2_NUM_ARGS)
<BOOST_SIGNALS2_SIGNAL_TEMPLATE_INSTANTIATION> >
shared_pimpl(_weak_pimpl.lock());
- if(shared_pimpl == 0) throw expired_slot();
return (*shared_pimpl)(BOOST_SIGNALS2_SIGNATURE_ARG_NAMES(BOOST_SIGNALS2_NUM_ARGS));
}
private:
#include <boost/assert.hpp>
#include <boost/aligned_storage.hpp>
+#include <boost/core/no_exceptions_support.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/optional.hpp>
#include <boost/scoped_ptr.hpp>
disconnected_slot_count(0),
m_active_slot(0)
{}
-
+
~slot_call_iterator_cache()
{
if(m_active_slot)
m_active_slot->dec_slot_refcount(lock);
}
}
-
+
template<typename M>
- void set_active_slot(garbage_collecting_lock<M> &lock,
+ void set_active_slot(garbage_collecting_lock<M> &lock,
connection_body_base *active_slot)
{
if(m_active_slot)
if(m_active_slot)
m_active_slot->inc_slot_refcount(lock);
}
-
+
optional<ResultType> result;
typedef auto_buffer<void_shared_ptr_variant, store_n_objects<10> > tracked_ptrs_type;
tracked_ptrs_type tracked_ptrs;
dereference() const
{
if (!cache->result) {
- try
+ BOOST_TRY
{
cache->result.reset(cache->f(*iter));
}
- catch(expired_slot &)
+ BOOST_CATCH(expired_slot &)
{
(*iter)->disconnect();
- throw;
+ BOOST_RETHROW
}
+ BOOST_CATCH_END
}
return cache->result.get();
}
else
cache->set_active_slot(lock, (*callable_iter).get());
}
-
+
void lock_next_callable() const
{
if(iter == callable_iter)
#ifndef BOOST_SIGNALS2_LAST_VALUE_HPP
#define BOOST_SIGNALS2_LAST_VALUE_HPP
+#include <boost/core/no_exceptions_support.hpp>
#include <boost/optional.hpp>
#include <boost/signals2/expired_slot.hpp>
+#include <boost/throw_exception.hpp>
#include <stdexcept>
namespace boost {
{
if(first == last)
{
- throw no_slots_error();
+ boost::throw_exception(no_slots_error());
}
optional<T> value;
while (first != last)
{
- try
+ BOOST_TRY
{
value = *first;
}
- catch(const expired_slot &) {}
+ BOOST_CATCH(const expired_slot &) {}
+ BOOST_CATCH_END
++first;
}
if(value) return value.get();
{
while (first != last)
{
- try
+ BOOST_TRY
{
*first;
}
- catch(const expired_slot &) {}
+ BOOST_CATCH(const expired_slot &) {}
+ BOOST_CATCH_END
++first;
}
return;
#ifndef BOOST_SIGNALS2_OPTIONAL_LAST_VALUE_HPP
#define BOOST_SIGNALS2_OPTIONAL_LAST_VALUE_HPP
+#include <boost/core/no_exceptions_support.hpp>
#include <boost/optional.hpp>
#include <boost/signals2/expired_slot.hpp>
optional<T> value;
while (first != last)
{
- try
+ BOOST_TRY
{
value = *first;
}
- catch(const expired_slot &) {}
+ BOOST_CATCH(const expired_slot &) {}
+ BOOST_CATCH_END
++first;
}
return value;
{
while (first != last)
{
- try
+ BOOST_TRY
{
*first;
}
- catch(const expired_slot &) {}
+ BOOST_CATCH(const expired_slot &) {}
+ BOOST_CATCH_END
++first;
}
return;
typedef std::vector<detail::void_shared_ptr_variant> locked_container_type;
const tracked_container_type& tracked_objects() const {return _tracked_objects;}
+ #if(!BOOST_NO_EXCEPTIONS)
locked_container_type lock() const
{
locked_container_type locked_objects;
}
return locked_objects;
}
+ #endif
bool expired() const
{
tracked_container_type::const_iterator it;
return *this;
}
+ // aliasing move
+ template<class Y>
+ shared_ptr( shared_ptr<Y> && r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn()
+ {
+ pn.swap( r.pn );
+ r.px = 0;
+ }
+
#endif
#if !defined( BOOST_NO_CXX11_NULLPTR )
{
this_type( r, p ).swap( *this );
}
-
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+ template<class Y> void reset( shared_ptr<Y> && r, element_type * p )
+ {
+ this_type( static_cast< shared_ptr<Y> && >( r ), p ).swap( *this );
+ }
+
+#endif
+
// never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
typename boost::detail::sp_dereference< T >::type operator* () const
{
/// Function that works exactly like C++ typeid(rtti_val) call, but returns boost::type_index.
///
-/// Retunrs runtime information about specified type.
+/// Returns runtime information about specified type.
///
/// \b Requirements: RTTI available or Base and Derived classes must be marked with BOOST_TYPE_INDEX_REGISTER_CLASS.
///
/// std::cout << ti.pretty_name(); // Outputs 'Derived'
/// \endcode
///
-/// \param runtime_val Varaible which runtime type must be returned.
+/// \param runtime_val Variable which runtime type must be returned.
/// \throw Nothing.
/// \return boost::typeindex::type_index with information about the specified variable.
template <class T>
//
-// Copyright (c) Antony Polukhin, 2013-2014.
+// Copyright (c) Antony Polukhin, 2013-2016.
//
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
#define BOOST_TYPE_INDEX_CTTI_TYPE_INDEX_HPP
/// \file ctti_type_index.hpp
-/// \brief Contains boost::typeindex::ctti_type_index class.
+/// \brief Contains boost::typeindex::ctti_type_index class that is constexpr if C++14 constexpr is supported by compiler.
///
-/// boost::typeindex::ctti_type_index class can be used as a drop-in replacement
+/// boost::typeindex::ctti_type_index class can be used as a drop-in replacement
/// for std::type_index.
///
/// It is used in situations when typeid() method is not available or
}
/// \class ctti_type_index
-/// This class is a wrapper that pretends to work exactly like stl_type_index, but does
+/// This class is a wrapper that pretends to work exactly like stl_type_index, but does
/// not require RTTI support. \b For \b description \b of \b functions \b see type_index_facade.
///
-/// This class produces slightly longer type names, so consider using stl_type_index
+/// This class on C++14 compatible compilers has following functions marked as constexpr:
+/// * default constructor
+/// * copy constructors and assignemnt operations
+/// * class methods: name(), before(const ctti_type_index& rhs), equal(const ctti_type_index& rhs)
+/// * static methods type_id<T>(), type_id_with_cvr<T>()
+/// * comparison operators
+///
+/// This class produces slightly longer type names, so consider using stl_type_index
/// in situations when typeid() is working.
class ctti_type_index: public type_index_facade<ctti_type_index, detail::ctti_data> {
- const detail::ctti_data* data_;
+ const char* data_;
inline std::size_t get_raw_name_length() const BOOST_NOEXCEPT;
+ BOOST_CXX14_CONSTEXPR inline explicit ctti_type_index(const char* data) BOOST_NOEXCEPT
+ : data_(data)
+ {}
+
public:
typedef detail::ctti_data type_info_t;
- inline ctti_type_index() BOOST_NOEXCEPT
- : data_(&ctti_construct<void>())
+ BOOST_CXX14_CONSTEXPR inline ctti_type_index() BOOST_NOEXCEPT
+ : data_(boost::detail::ctti<void>::n())
{}
inline ctti_type_index(const type_info_t& data) BOOST_NOEXCEPT
- : data_(&data)
+ : data_(reinterpret_cast<const char*>(&data))
{}
- inline const type_info_t& type_info() const BOOST_NOEXCEPT;
- inline const char* raw_name() const BOOST_NOEXCEPT;
+ inline const type_info_t& type_info() const BOOST_NOEXCEPT;
+ BOOST_CXX14_CONSTEXPR inline const char* raw_name() const BOOST_NOEXCEPT;
+ BOOST_CXX14_CONSTEXPR inline const char* name() const BOOST_NOEXCEPT;
inline std::string pretty_name() const;
inline std::size_t hash_code() const BOOST_NOEXCEPT;
+ BOOST_CXX14_CONSTEXPR inline bool equal(const ctti_type_index& rhs) const BOOST_NOEXCEPT;
+ BOOST_CXX14_CONSTEXPR inline bool before(const ctti_type_index& rhs) const BOOST_NOEXCEPT;
+
template <class T>
- inline static ctti_type_index type_id() BOOST_NOEXCEPT;
+ BOOST_CXX14_CONSTEXPR inline static ctti_type_index type_id() BOOST_NOEXCEPT;
template <class T>
- inline static ctti_type_index type_id_with_cvr() BOOST_NOEXCEPT;
+ BOOST_CXX14_CONSTEXPR inline static ctti_type_index type_id_with_cvr() BOOST_NOEXCEPT;
template <class T>
inline static ctti_type_index type_id_runtime(const T& variable) BOOST_NOEXCEPT;
inline const ctti_type_index::type_info_t& ctti_type_index::type_info() const BOOST_NOEXCEPT {
- return *data_;
+ return *reinterpret_cast<const detail::ctti_data*>(data_);
+}
+
+
+BOOST_CXX14_CONSTEXPR inline bool ctti_type_index::equal(const ctti_type_index& rhs) const BOOST_NOEXCEPT {
+ const char* const left = raw_name();
+ const char* const right = rhs.raw_name();
+ return /*left == right ||*/ !boost::typeindex::detail::constexpr_strcmp(left, right);
+}
+
+BOOST_CXX14_CONSTEXPR inline bool ctti_type_index::before(const ctti_type_index& rhs) const BOOST_NOEXCEPT {
+ const char* const left = raw_name();
+ const char* const right = rhs.raw_name();
+ return /*left != right &&*/ boost::typeindex::detail::constexpr_strcmp(left, right) < 0;
}
template <class T>
-inline ctti_type_index ctti_type_index::type_id() BOOST_NOEXCEPT {
+BOOST_CXX14_CONSTEXPR inline ctti_type_index ctti_type_index::type_id() BOOST_NOEXCEPT {
typedef BOOST_DEDUCED_TYPENAME boost::remove_reference<T>::type no_ref_t;
typedef BOOST_DEDUCED_TYPENAME boost::remove_cv<no_ref_t>::type no_cvr_t;
- return ctti_construct<no_cvr_t>();
+ return ctti_type_index(boost::detail::ctti<no_cvr_t>::n());
}
template <class T>
-inline ctti_type_index ctti_type_index::type_id_with_cvr() BOOST_NOEXCEPT {
- return ctti_construct<T>();
+BOOST_CXX14_CONSTEXPR inline ctti_type_index ctti_type_index::type_id_with_cvr() BOOST_NOEXCEPT {
+ return ctti_type_index(boost::detail::ctti<T>::n());
}
}
-inline const char* ctti_type_index::raw_name() const BOOST_NOEXCEPT {
- return reinterpret_cast<const char*>(data_);
+BOOST_CXX14_CONSTEXPR inline const char* ctti_type_index::raw_name() const BOOST_NOEXCEPT {
+ return data_;
+}
+
+
+BOOST_CXX14_CONSTEXPR inline const char* ctti_type_index::name() const BOOST_NOEXCEPT {
+ return data_;
}
inline std::size_t ctti_type_index::get_raw_name_length() const BOOST_NOEXCEPT {
//
-// Copyright (c) Antony Polukhin, 2012-2014.
+// Copyright (c) Antony Polukhin, 2012-2016.
//
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
#include <boost/config.hpp>
#include <boost/static_assert.hpp>
#include <boost/mpl/bool.hpp>
-#include <algorithm>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
BOOST_STATIC_CONSTEXPR bool ctti_skip_more_at_runtime = runtime_skip; \
BOOST_STATIC_CONSTEXPR char ctti_skip_until_runtime[] = runtime_skip_until; \
}}} /* namespace boost::typeindex::detail */ \
- /**/
+ /**/
/// @endcond
+
#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
/* Nothing to document. All the macro docs are moved to <boost/type_index.hpp> */
#elif defined(BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING)
-
# include <boost/preprocessor/facilities/expand.hpp>
BOOST_PP_EXPAND( BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING )
-
-#elif defined(_MSC_VER)
+#elif defined(_MSC_VER) && defined (BOOST_NO_CXX11_NOEXCEPT)
// sizeof("const char *__cdecl boost::detail::ctti<") - 1, sizeof(">::n(void)") - 1
BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(40, 10, false, "")
+#elif defined(_MSC_VER) && !defined (BOOST_NO_CXX11_NOEXCEPT)
+ // sizeof("const char *__cdecl boost::detail::ctti<") - 1, sizeof(">::n(void) noexcept") - 1
+ BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(40, 19, false, "")
#elif defined(__clang__) && defined(__APPLE__)
// Someone made __clang_major__ equal to LLVM version rather than compiler version
// on APPLE platform.
// sizeof("static const char *boost::detail::ctti<") - 1, sizeof(">::n()") - 1
// note: checked on 3.0
BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(39, 6, false, "")
-#elif defined(__clang__) && __clang_major__ == 3 && __clang_minor__ > 0
+#elif defined(__clang__) && (__clang_major__ >= 4 || (__clang_major__ == 3 && __clang_minor__ > 0))
// sizeof("static const char *boost::detail::ctti<") - 1, sizeof("]") - 1, true, "int>::n() [T = int"
// note: checked on 3.1, 3.4
BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(39, 1, true, "T = ")
-#elif defined(__GNUC__)
+#elif defined(__GNUC__) && !defined(BOOST_NO_CXX14_CONSTEXPR)
+ // sizeof("static contexpr char boost::detail::ctti<T>::s() [with long unsigned int I = 0ul; T = ") - 1, sizeof("]") - 1
+ BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(87, 1, false, "")
+#elif defined(__GNUC__) && defined(BOOST_NO_CXX14_CONSTEXPR)
// sizeof("static const char* boost::detail::ctti<T>::n() [with T = ") - 1, sizeof("]") - 1
BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(57, 1, false, "")
#else
namespace boost { namespace typeindex { namespace detail {
template <bool Condition>
- inline void assert_compile_time_legths() BOOST_NOEXCEPT {
+ BOOST_CXX14_CONSTEXPR inline void assert_compile_time_legths() BOOST_NOEXCEPT {
BOOST_STATIC_ASSERT_MSG(
Condition,
"TypeIndex library is misconfigured for your compiler. "
"'RTTI emulation limitations' of the documentation for more information."
);
}
-
+
+ template <class T>
+ BOOST_CXX14_CONSTEXPR inline void failed_to_get_function_name() BOOST_NOEXCEPT {
+ BOOST_STATIC_ASSERT_MSG(
+ sizeof(T) && false,
+ "TypeIndex library could not detect your compiler. "
+ "Please make the BOOST_TYPE_INDEX_FUNCTION_SIGNATURE macro use "
+ "correct compiler macro for getting the whole function name. "
+ "Define BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING to correct value after that."
+ );
+ }
+
template <std::size_t ArrayLength>
- inline const char* skip_begining_runtime(const char* begin, boost::mpl::false_) BOOST_NOEXCEPT {
+ BOOST_CXX14_CONSTEXPR inline const char* skip_begining_runtime(const char* begin, boost::mpl::false_) BOOST_NOEXCEPT {
return begin;
}
+ template<class ForwardIterator1, class ForwardIterator2>
+ BOOST_CXX14_CONSTEXPR inline ForwardIterator1 constexpr_search(
+ ForwardIterator1 first1,
+ ForwardIterator1 last1,
+ ForwardIterator2 first2,
+ ForwardIterator2 last2) BOOST_NOEXCEPT
+ {
+ if (first2 == last2) {
+ return first1; // specified in C++11
+ }
+
+ while (first1 != last1) {
+ ForwardIterator1 it1 = first1;
+ ForwardIterator2 it2 = first2;
+
+ while (*it1 == *it2) {
+ ++it1;
+ ++it2;
+ if (it2 == last2) return first1;
+ if (it1 == last1) return last1;
+ }
+
+ ++first1;
+ }
+
+ return last1;
+ }
+
+ BOOST_CXX14_CONSTEXPR inline int constexpr_strcmp(const char *v1, const char *v2) BOOST_NOEXCEPT {
+ while (*v1 != '\0' && *v1 == *v2) {
+ ++v1;
+ ++v2;
+ };
+
+ return static_cast<int>(*v1) - *v2;
+ }
+
template <std::size_t ArrayLength>
- inline const char* skip_begining_runtime(const char* begin, boost::mpl::true_) BOOST_NOEXCEPT {
- const char* const it = std::search(
+ BOOST_CXX14_CONSTEXPR inline const char* skip_begining_runtime(const char* begin, boost::mpl::true_) BOOST_NOEXCEPT {
+ const char* const it = constexpr_search(
begin, begin + ArrayLength,
ctti_skip_until_runtime, ctti_skip_until_runtime + sizeof(ctti_skip_until_runtime) - 1
);
}
template <std::size_t ArrayLength>
- inline const char* skip_begining(const char* begin) BOOST_NOEXCEPT {
+ BOOST_CXX14_CONSTEXPR inline const char* skip_begining(const char* begin) BOOST_NOEXCEPT {
assert_compile_time_legths<(ArrayLength > ctti_skip_size_at_begin + ctti_skip_size_at_end)>();
return skip_begining_runtime<ArrayLength - ctti_skip_size_at_begin>(
begin + ctti_skip_size_at_begin,
boost::mpl::bool_<ctti_skip_more_at_runtime>()
);
}
+
+#if !defined(__clang__) && defined(__GNUC__) && !defined(BOOST_NO_CXX14_CONSTEXPR)
+ template <std::size_t... I>
+ struct index_seq {};
+
+ template <typename Left, typename Right>
+ struct make_index_sequence_join;
+
+ template <std::size_t... Left, std::size_t... Right>
+ struct make_index_sequence_join<index_seq<Left...>, index_seq<Right...> > {
+ typedef index_seq<Left..., Right...> type;
+ };
+
+ template <std::size_t C, std::size_t D>
+ struct make_index_seq_impl {
+ typedef typename make_index_sequence_join<
+ typename make_index_seq_impl<C, D / 2>::type,
+ typename make_index_seq_impl<C + D / 2, (D + 1) / 2>::type
+ >::type type;
+ };
+
+ template <std::size_t C>
+ struct make_index_seq_impl<C, 0> {
+ typedef index_seq<> type;
+ };
+
+ template <std::size_t C>
+ struct make_index_seq_impl<C, 1> {
+ typedef index_seq<C> type;
+ };
+
+ template <char... C>
+ struct cstring {
+ static constexpr std::size_t size_ = sizeof...(C);
+ static constexpr char data_[size_] = { C... };
+ };
+
+ template <char... C>
+ constexpr char cstring<C...>::data_[];
+#endif
+
}}} // namespace boost::typeindex::detail
namespace boost { namespace detail {
/// This name must be as short as possible, to avoid code bloat
template <class T>
struct ctti {
+
+#if !defined(__clang__) && defined(__GNUC__) && !defined(BOOST_NO_CXX14_CONSTEXPR)
+ //helper functions
+ template <std::size_t I>
+ constexpr static char s() BOOST_NOEXCEPT { // step
+ constexpr std::size_t offset =
+ (I >= 10u ? 1u : 0u)
+ + (I >= 100u ? 1u : 0u)
+ + (I >= 1000u ? 1u : 0u)
+ + (I >= 10000u ? 1u : 0u)
+ + (I >= 100000u ? 1u : 0u)
+ + (I >= 1000000u ? 1u : 0u)
+ ;
+ #if defined(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE)
+ return BOOST_TYPE_INDEX_FUNCTION_SIGNATURE[I + offset];
+ #elif defined(__FUNCSIG__)
+ return __FUNCSIG__[I + offset];
+ #else
+ return __PRETTY_FUNCTION__[I + offset];
+ #endif
+ }
+
+ template <std::size_t ...Indexes>
+ constexpr static const char* impl(::boost::typeindex::detail::index_seq<Indexes...> ) BOOST_NOEXCEPT {
+ return ::boost::typeindex::detail::cstring<s<Indexes>()...>::data_;
+ }
+
+ template <std::size_t D = 0> // `D` means `Dummy`
+ constexpr static const char* n() BOOST_NOEXCEPT {
+ #if defined(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE)
+ constexpr std::size_t size = sizeof(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE);
+ #elif defined(__FUNCSIG__)
+ constexpr std::size_t size = sizeof(__FUNCSIG__);
+ #elif defined(__PRETTY_FUNCTION__) \
+ || defined(__GNUC__) \
+ || (defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130)) \
+ || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) \
+ || (defined(__ICC) && (__ICC >= 600)) \
+ || defined(__ghs__) \
+ || defined(__DMC__)
+ constexpr std::size_t size = sizeof(__PRETTY_FUNCTION__);
+ #else
+ boost::typeindex::detail::failed_to_get_function_name();
+ #endif
+
+ boost::typeindex::detail::assert_compile_time_legths<
+ (size > boost::typeindex::detail::ctti_skip_size_at_begin + boost::typeindex::detail::ctti_skip_size_at_end + sizeof("const *") - 1)
+ >();
+ static_assert(!boost::typeindex::detail::ctti_skip_more_at_runtime, "Skipping for GCC in C++14 mode is unsupported");
+
+ typedef typename boost::typeindex::detail::make_index_seq_impl<
+ boost::typeindex::detail::ctti_skip_size_at_begin,
+ size - sizeof("const *") + 1 - boost::typeindex::detail::ctti_skip_size_at_begin
+ >::type idx_seq;
+ return impl(idx_seq());
+ }
+#else
/// Returns raw name. Must be as short, as possible, to avoid code bloat
- static const char* n() BOOST_NOEXCEPT {
+ BOOST_CXX14_CONSTEXPR static const char* n() BOOST_NOEXCEPT {
#if defined(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE)
- return boost::typeindex::detail::skip_begining< sizeof(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE >(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE);
+ return boost::typeindex::detail::skip_begining< sizeof(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE) >(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE);
#elif defined(__FUNCSIG__)
return boost::typeindex::detail::skip_begining< sizeof(__FUNCSIG__) >(__FUNCSIG__);
#elif defined(__PRETTY_FUNCTION__) \
|| (defined(__ICC) && (__ICC >= 600)) \
|| defined(__ghs__) \
|| defined(__DMC__)
-
return boost::typeindex::detail::skip_begining< sizeof(__PRETTY_FUNCTION__) >(__PRETTY_FUNCTION__);
#else
- BOOST_STATIC_ASSERT_MSG(
- sizeof(T) && false,
- "TypeIndex library could not detect your compiler. "
- "Please make the BOOST_TYPE_INDEX_FUNCTION_SIGNATURE macro use "
- "correct compiler macro for getting the whole function name. "
- "Define BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING to correct value after that."
- );
+ boost::typeindex::detail::failed_to_get_function_name();
+ return "";
#endif
}
+#endif
};
}} // namespace boost::detail
class type_index_facade {
private:
/// @cond
- const Derived & derived() const BOOST_NOEXCEPT {
+ BOOST_CXX14_CONSTEXPR const Derived & derived() const BOOST_NOEXCEPT {
return *static_cast<Derived const*>(this);
}
/// @endcond
/// @cond
template <class Derived, class TypeInfo>
-inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+BOOST_CXX14_CONSTEXPR inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
return static_cast<Derived const&>(lhs).equal(static_cast<Derived const&>(rhs));
}
template <class Derived, class TypeInfo>
-inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
- return static_cast<Derived const&>(lhs).before(static_cast<Derived const&>(rhs));;
+BOOST_CXX14_CONSTEXPR inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return static_cast<Derived const&>(lhs).before(static_cast<Derived const&>(rhs));
}
template <class Derived, class TypeInfo>
-inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+BOOST_CXX14_CONSTEXPR inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
return rhs < lhs;
}
template <class Derived, class TypeInfo>
-inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+BOOST_CXX14_CONSTEXPR inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
return !(lhs > rhs);
}
template <class Derived, class TypeInfo>
-inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+BOOST_CXX14_CONSTEXPR inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
return !(lhs < rhs);
}
template <class Derived, class TypeInfo>
-inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+BOOST_CXX14_CONSTEXPR inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
return !(lhs == rhs);
}
#ifndef BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/intrinsics.hpp>
#ifndef BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
#define BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#ifndef BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/detail/config.hpp>
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#ifndef BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
#define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/is_pod.hpp>
#include <boost/type_traits/is_reference.hpp>
#ifndef BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#ifndef BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED
#define BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
// to degrade gracefully, rather than trash the compiler (John Maddock).
//
+#include <cstddef> // size_t
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#ifndef BOOST_IS_ABSTRACT
#define BOOST_TT_IS_ARRAY_HPP_INCLUDED
#include <boost/type_traits/integral_constant.hpp>
-#include <cstddef>
+#include <cstddef> // size_t
namespace boost {
#ifndef BOOST_TT_IS_ASSIGNABLE_HPP_INCLUDED
#define BOOST_TT_IS_ASSIGNABLE_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/integral_constant.hpp>
#include <boost/detail/workaround.hpp>
#ifndef BOOST_TT_IS_CONST_HPP_INCLUDED
#define BOOST_TT_IS_CONST_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/integral_constant.hpp>
namespace boost {
template <class T>
struct is_const : public false_type {};
template <class T> struct is_const<T const> : public true_type{};
- template <class T, size_t N> struct is_const<T const[N]> : public true_type{};
+ template <class T, std::size_t N> struct is_const<T const[N]> : public true_type{};
template <class T> struct is_const<T const[]> : public true_type{};
#endif
#ifndef BOOST_TT_IS_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED
#define BOOST_TT_IS_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/integral_constant.hpp>
#include <boost/detail/workaround.hpp>
#ifndef BOOST_TT_IS_DESTRUCTIBLE_HPP_INCLUDED
#define BOOST_TT_IS_DESTRUCTIBLE_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/integral_constant.hpp>
#include <boost/detail/workaround.hpp>
#ifndef BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED
#define BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/config.hpp>
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#ifndef BOOST_TT_IS_POD_HPP_INCLUDED
#define BOOST_TT_IS_POD_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/detail/config.hpp>
#include <boost/type_traits/is_void.hpp>
#include <boost/type_traits/is_scalar.hpp>
#ifndef BOOST_TT_IS_VOLATILE_HPP_INCLUDED
#define BOOST_TT_IS_VOLATILE_HPP_INCLUDED
+#include <cstddef> // size_t
#include <boost/type_traits/integral_constant.hpp>
namespace boost {
template <class T>
struct is_volatile : public false_type {};
template <class T> struct is_volatile<T volatile> : public true_type{};
- template <class T, size_t N> struct is_volatile<T volatile[N]> : public true_type{};
+ template <class T, std::size_t N> struct is_volatile<T volatile[N]> : public true_type{};
template <class T> struct is_volatile<T volatile[]> : public true_type{};
#endif
#define BOOST_TT_REMOVE_ALL_EXTENTS_HPP_INCLUDED
#include <boost/config.hpp>
-#include <cstddef>
+#include <cstddef> // size_t
#include <boost/detail/workaround.hpp>
namespace boost {
#define BOOST_TT_REMOVE_CONST_HPP_INCLUDED
#include <boost/config.hpp>
-#include <cstddef>
+#include <cstddef> // size_t
#include <boost/detail/workaround.hpp>
namespace boost {
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
-#include <cstddef>
+#include <cstddef> // size_t
namespace boost {
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
-#include <cstddef>
+#include <cstddef> // size_t
namespace boost {
namespace boost {
-#ifdef BOOST_MSVC
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1900)
namespace detail{
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
-#include <cstddef>
+#include <cstddef> // size_t
namespace boost {
#include <boost/type_traits/is_pod.hpp>
#include <boost/static_assert.hpp>
#include <boost/config.hpp>
-#include <cstddef>
+#include <cstddef> // size_t
#include <boost/detail/workaround.hpp>
#ifdef BOOST_MSVC
// {}
// This macro should only persist within this file.
-#define BOOST_PRIVATE_CTR_DEF( z, n, data ) \
- template < BOOST_PP_ENUM_PARAMS(n, typename T) > \
- explicit base_from_member( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) ) \
- : member( BOOST_PP_ENUM_PARAMS(n, x) ) \
- {} \
+#define BOOST_PRIVATE_CTR_DEF( z, n, data ) \
+ template < BOOST_PP_ENUM_PARAMS(n, typename T) > \
+ base_from_member( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) ) \
+ : member( BOOST_PP_ENUM_PARAMS(n, x) ) \
+ {} \
/**/
: member()
{}
- BOOST_PP_REPEAT_FROM_TO( 1, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
+ template < typename T0 > explicit base_from_member( T0 x0 ) : member( x0 ) {}
+ BOOST_PP_REPEAT_FROM_TO( 2, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
BOOST_PRIVATE_CTR_DEF, _ )
#endif
#ifndef BOOST_VARIANT_APPLY_VISITOR_HPP
#define BOOST_VARIANT_APPLY_VISITOR_HPP
-#include "boost/variant/detail/apply_visitor_unary.hpp"
-#include "boost/variant/detail/apply_visitor_binary.hpp"
-#include "boost/variant/detail/apply_visitor_delayed.hpp"
+#include <boost/variant/detail/apply_visitor_unary.hpp>
+#include <boost/variant/detail/apply_visitor_binary.hpp>
+#include <boost/variant/detail/apply_visitor_delayed.hpp>
#endif // BOOST_VARIANT_APPLY_VISITOR_HPP
#ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
-#include "boost/config.hpp"
-#include "boost/detail/workaround.hpp"
-#include "boost/variant/detail/generic_result_type.hpp"
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/variant/detail/generic_result_type.hpp>
-#include "boost/variant/detail/apply_visitor_unary.hpp"
+#include <boost/variant/detail/apply_visitor_unary.hpp>
#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
-#include "boost/utility/enable_if.hpp"
-#include "boost/mpl/not.hpp"
-#include "boost/type_traits/is_const.hpp"
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_const.hpp>
#endif
#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
-# include "boost/variant/detail/has_result_type.hpp"
+# include <boost/variant/detail/has_result_type.hpp>
#endif
namespace boost {
#ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
-#include "boost/variant/detail/generic_result_type.hpp"
+#include <boost/variant/detail/generic_result_type.hpp>
-#include "boost/variant/detail/apply_visitor_unary.hpp"
-#include "boost/variant/detail/apply_visitor_binary.hpp"
-#include "boost/variant/variant_fwd.hpp" // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+#include <boost/variant/detail/apply_visitor_unary.hpp>
+#include <boost/variant/detail/apply_visitor_binary.hpp>
+#include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
-#include "boost/variant/detail/has_result_type.hpp"
+#include <boost/variant/detail/has_result_type.hpp>
#include <boost/core/enable_if.hpp>
namespace boost {
#ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
-#include "boost/config.hpp"
-#include "boost/detail/workaround.hpp"
-#include "boost/variant/detail/generic_result_type.hpp"
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/variant/detail/generic_result_type.hpp>
#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
-#include "boost/core/enable_if.hpp"
-#include "boost/mpl/not.hpp"
-#include "boost/type_traits/is_const.hpp"
+#include <boost/core/enable_if.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_const.hpp>
#endif
#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
# include <boost/mpl/size.hpp>
# include <boost/utility/declval.hpp>
# include <boost/core/enable_if.hpp>
-# include "boost/variant/detail/has_result_type.hpp"
+# include <boost/variant/detail/has_result_type.hpp>
#endif
namespace boost {
#ifndef BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP
#define BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP
-#include "boost/config.hpp"
-#include "boost/assert.hpp"
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
namespace boost {
namespace detail { namespace variant {
#ifndef BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP
#define BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP
-#include "boost/config.hpp"
+#include <boost/config.hpp>
namespace boost {
namespace detail { namespace variant {
// See http://www.boost.org for updates, documentation, and revision history.
//-----------------------------------------------------------------------------
//
-// Copyright (c) 2003
-// Eric Friedman
+// Copyright (c) 2003 Eric Friedman
+// Copyright (c) 2016 Antony Polukhin
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
#ifndef BOOST_VARIANT_DETAIL_CONFIG_HPP
#define BOOST_VARIANT_DETAIL_CONFIG_HPP
-#include "boost/config.hpp"
-#include "boost/detail/workaround.hpp"
-
-///////////////////////////////////////////////////////////////////////////////
-// macro BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING
-//
-#if BOOST_WORKAROUND(__MWERKS__, <= 0x3201) \
- || BOOST_WORKAROUND(BOOST_INTEL, <= 700) \
- && !defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING)
-# define BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// macro BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND
-//
-#if !defined(BOOST_NO_SFINAE) \
- && !BOOST_WORKAROUND(BOOST_INTEL, <= 700) \
- && !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND)
-# define BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND
-#endif
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
#endif // BOOST_VARIANT_DETAIL_CONFIG_HPP
#ifndef BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
#define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
-#include "boost/mpl/aux_/config/ctps.hpp"
+#include <boost/mpl/aux_/config/ctps.hpp>
-#include "boost/mpl/bool_fwd.hpp"
+#include <boost/mpl/bool_fwd.hpp>
-# include "boost/mpl/bool.hpp"
+# include <boost/mpl/bool.hpp>
namespace boost {
namespace detail { namespace variant {
// See http://www.boost.org for updates, documentation, and revision history.
//-----------------------------------------------------------------------------
//
-// Copyright (c) 2003
-// Eric Friedman
+// Copyright (c) 2003 Eric Friedman
+// Copyright (c) 2015-2016 Antony Polukhin
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
#ifndef BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP
#define BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP
-#include "boost/config.hpp"
-#include "boost/variant/detail/generic_result_type.hpp"
-#include "boost/assert.hpp"
+#include <boost/config.hpp>
+#include <boost/variant/detail/generic_result_type.hpp>
+#include <boost/assert.hpp>
+#include <cstdlib> // std::abort
-namespace boost {
-namespace detail { namespace variant {
-///////////////////////////////////////////////////////////////////////////////
-// (detail) function template forced_return
-//
-// Logical error to permit invocation at runtime, but (artificially) satisfies
-// compile-time requirement of returning a result value.
-//
-
-#if !defined(BOOST_MSVC) \
- && !defined(BOOST_NO_VOID_RETURNS)
-
-// "standard" implementation:
-
-template <typename T>
-inline T forced_return()
-{
- // logical error: should never be here! (see above)
- BOOST_ASSERT(false);
+#ifdef BOOST_MSVC
+# pragma warning( push )
+# pragma warning( disable : 4702 ) // unreachable code
+#endif
- T (*dummy_function_ptr)() = 0;
- return dummy_function_ptr();
-}
+namespace boost { namespace detail { namespace variant {
-template <>
-inline void forced_return<void>()
-{
- // logical error: should never be here! (see above)
- BOOST_ASSERT(false);
+BOOST_NORETURN inline void forced_return_no_return() { // fixes `must return a value` warnings
+ using namespace std;
+ abort(); // some implementations have no std::abort
}
-#elif !defined(BOOST_MSVC)
-// workaround implementation
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template forced_return
//
-// TODO: Determine the most efficient way to handle this -- as below? by
-// throwing? by recursive call to forced_return itself? etc.
+// Logical error to permit invocation at runtime, but (artificially) satisfies
+// compile-time requirement of returning a result value.
//
-
template <typename T>
-inline
+BOOST_NORETURN inline
BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T)
forced_return()
{
// logical error: should never be here! (see above)
BOOST_ASSERT(false);
+ forced_return_no_return();
+
+#ifdef BOOST_NO_NORETURN
BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) (*dummy)() = 0;
return dummy();
+#endif
}
-#else // defined(BOOST_MSVC)
+}}} // namespace boost::detail::variant
-# pragma warning( push )
-# pragma warning( disable : 4702 ) // unreachable code
-// msvc-specific implementation
-//
-// Leverages __declspec(noreturn) for optimized implementation.
-//
-
-__declspec(noreturn)
-inline void forced_return_no_return() {};
-
-template <typename T>
-inline
- BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T)
-forced_return()
-{
- // logical error: should never be here! (see above)
- BOOST_ASSERT(false);
-
- forced_return_no_return();
-}
+#ifdef BOOST_MSVC
# pragma warning( pop )
-
-#endif // BOOST_MSVC optimization
-
-}} // namespace detail::variant
-} // namespace boost
+#endif
#endif // BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP
#ifndef BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP
#define BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP
-#include "boost/config.hpp"
+#include <boost/config.hpp>
//////////////////////////////////////////////////////////////////////////
// (workaround) macro BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE
#ifndef BOOST_VARIANT_DETAIL_HAS_RESULT_TYPE_HPP
#define BOOST_VARIANT_DETAIL_HAS_RESULT_TYPE_HPP
-#include "boost/config.hpp"
-#include "boost/type_traits/remove_reference.hpp"
+#include <boost/config.hpp>
+#include <boost/type_traits/remove_reference.hpp>
namespace boost { namespace detail { namespace variant {
#include <new> // for placement new
-#include "boost/config.hpp"
+#include <boost/config.hpp>
-#include "boost/call_traits.hpp"
-#include "boost/detail/reference_content.hpp"
-#include "boost/variant/recursive_wrapper_fwd.hpp"
-#include "boost/variant/detail/move.hpp"
+#include <boost/call_traits.hpp>
+#include <boost/detail/reference_content.hpp>
+#include <boost/variant/recursive_wrapper_fwd.hpp>
+#include <boost/variant/detail/move.hpp>
#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
-# include "boost/mpl/aux_/value_wknd.hpp"
-# include "boost/mpl/int.hpp"
-# include "boost/mpl/iter_fold.hpp"
-# include "boost/mpl/next.hpp"
-# include "boost/mpl/deref.hpp"
-# include "boost/mpl/pair.hpp"
-# include "boost/mpl/protect.hpp"
+# include <boost/mpl/aux_/value_wknd.hpp>
+# include <boost/mpl/int.hpp>
+# include <boost/mpl/iter_fold.hpp>
+# include <boost/mpl/next.hpp>
+# include <boost/mpl/deref.hpp>
+# include <boost/mpl/pair.hpp>
+# include <boost/mpl/protect.hpp>
#else
-# include "boost/variant/variant_fwd.hpp"
-# include "boost/preprocessor/cat.hpp"
-# include "boost/preprocessor/enum.hpp"
-# include "boost/preprocessor/repeat.hpp"
+# include <boost/variant/variant_fwd.hpp>
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/enum.hpp>
+# include <boost/preprocessor/repeat.hpp>
#endif
namespace boost {
return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which
}
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
static int initialize(void* dest, param2_T operand)
{
// This assert must newer trigger, because all the reference contents are
#ifndef BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
#define BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
-#include "boost/variant/variant_fwd.hpp"
+#include <boost/variant/variant_fwd.hpp>
-#include "boost/mpl/list.hpp"
-#include "boost/preprocessor/cat.hpp"
-#include "boost/preprocessor/enum.hpp"
+#include <boost/mpl/list.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/enum.hpp>
namespace boost {
namespace detail { namespace variant {
#include <iterator> // for iterator_traits
#include <new> // for placement new
-#include "boost/config.hpp"
-#include "boost/detail/workaround.hpp"
-#include "boost/move/move.hpp"
-#include "boost/move/adl_move_swap.hpp"
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/move/move.hpp>
+#include <boost/move/adl_move_swap.hpp>
namespace boost { namespace detail { namespace variant {
#ifndef BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP
#define BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP
-#include "boost/mpl/aux_/config/ctps.hpp"
+#include <boost/mpl/aux_/config/ctps.hpp>
namespace boost {
#ifndef BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
#define BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
-#include "boost/mpl/aux_/lambda_arity_param.hpp"
-#include "boost/mpl/aux_/template_arity.hpp"
-#include "boost/mpl/int_fwd.hpp"
+#include <boost/mpl/aux_/lambda_arity_param.hpp>
+#include <boost/mpl/aux_/template_arity.hpp>
+#include <boost/mpl/int_fwd.hpp>
///////////////////////////////////////////////////////////////////////////////
// Defined if 'substitute' is not implementable on the current compiler.
//
-#include "boost/mpl/aux_/config/ctps.hpp"
-#include "boost/mpl/aux_/config/ttp.hpp"
+#include <boost/mpl/aux_/config/ctps.hpp>
+#include <boost/mpl/aux_/config/ttp.hpp>
#if defined(BOOST_NO_TEMPLATE_TEMPLATE_PARAMETERS) \
&& !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
#include <iosfwd> // for std::basic_ostream forward declare
-#include "boost/variant/variant_fwd.hpp"
+#include <boost/variant/variant_fwd.hpp>
-#include "boost/detail/templated_streams.hpp"
-#include "boost/variant/static_visitor.hpp"
+#include <boost/detail/templated_streams.hpp>
+#include <boost/variant/static_visitor.hpp>
namespace boost {
#ifndef BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP
#define BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP
-#include "boost/config.hpp"
-
-#include "boost/variant/detail/backup_holder.hpp"
-#include "boost/variant/detail/cast_storage.hpp"
-#include "boost/variant/detail/forced_return.hpp"
-#include "boost/variant/detail/generic_result_type.hpp"
-#include "boost/variant/variant_fwd.hpp" // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
-
-#include "boost/mpl/eval_if.hpp"
-#include "boost/mpl/bool.hpp"
-#include "boost/mpl/identity.hpp"
-#include "boost/mpl/int.hpp"
-#include "boost/mpl/next.hpp"
-#include "boost/mpl/deref.hpp"
-#include "boost/mpl/or.hpp"
-#include "boost/preprocessor/cat.hpp"
-#include "boost/preprocessor/inc.hpp"
-#include "boost/preprocessor/repeat.hpp"
-#include "boost/type_traits/is_same.hpp"
-#include "boost/type_traits/has_nothrow_copy.hpp"
-#include "boost/type_traits/is_nothrow_move_constructible.hpp"
+#include <boost/config.hpp>
+
+#include <boost/variant/detail/backup_holder.hpp>
+#include <boost/variant/detail/cast_storage.hpp>
+#include <boost/variant/detail/forced_return.hpp>
+#include <boost/variant/detail/generic_result_type.hpp>
+#include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/has_nothrow_copy.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
# pragma warning (push)
#if !defined(BOOST_VARIANT_VISITATION_UNROLLING_LIMIT)
#ifndef BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
-# include "boost/mpl/limits/list.hpp"
+# include <boost/mpl/limits/list.hpp>
# define BOOST_VARIANT_VISITATION_UNROLLING_LIMIT \
BOOST_MPL_LIMIT_LIST_SIZE
#else
typedef typename is_same< next_type,apply_visitor_unrolled >::type
is_apply_visitor_unrolled;
- return visitation_impl(
+ return detail::variant::visitation_impl(
internal_which, logical_which
, visitor, storage
, is_apply_visitor_unrolled()
// See http://www.boost.org for updates, documentation, and revision history.
//-----------------------------------------------------------------------------
//
-// Copyright (c) 2002
-// Eric Friedman, Itay Maman
+// Copyright (c) 2002 Eric Friedman, Itay Maman
+// Copyright (c) 2016 Antony Polukhin
//
// Portions Copyright (C) 2002 David Abrahams
//
#define BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP
#include <boost/mpl/bool.hpp>
-#include "boost/mpl/aux_/config/ctps.hpp"
-#include "boost/mpl/aux_/lambda_support.hpp"
+#include <boost/mpl/aux_/config/ctps.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_constructible.hpp>
namespace boost {
//
template <typename T> class recursive_wrapper;
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction is_constructible partial specializations.
+//
+// recursive_wrapper<T> is constructible only from T and recursive_wrapper<T>.
+//
+template <class T> struct is_constructible<recursive_wrapper<T>, T> : boost::true_type{};
+template <class T> struct is_constructible<recursive_wrapper<T>, const T> : boost::true_type{};
+template <class T> struct is_constructible<recursive_wrapper<T>, T&> : boost::true_type{};
+template <class T> struct is_constructible<recursive_wrapper<T>, const T&> : boost::true_type{};
+template <class T> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<T> > : boost::true_type{};
+template <class T> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<T> > : boost::true_type{};
+template <class T> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<T>& > : boost::true_type{};
+template <class T> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<T>& > : boost::true_type{};
+
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, U > : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, const U > : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, U& > : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, const U& > : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<U> > : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<U> > : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<U>& > : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<U>& > : boost::false_type{};
+
+
///////////////////////////////////////////////////////////////////////////////
// metafunction is_recursive_wrapper (modeled on code by David Abrahams)
//
-// True iff specified type matches recursive_wrapper<T>.
+// True if specified type matches recursive_wrapper<T>.
//
namespace detail {
#ifndef BOOST_VARIANT_STATIC_VISITOR_HPP
#define BOOST_VARIANT_STATIC_VISITOR_HPP
-#include "boost/config.hpp"
-#include "boost/detail/workaround.hpp"
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
-#include "boost/mpl/if.hpp"
-#include "boost/type_traits/is_base_and_derived.hpp"
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
//-----------------------------------------------------------------------------
//
// Copyright (c) 2002-2003 Eric Friedman, Itay Maman
-// Copyright (c) 2012-2014 Antony Polukhin
+// Copyright (c) 2012-2016 Antony Polukhin
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
#include <cstddef> // for std::size_t
#include <new> // for placement new
-#include "boost/type_index.hpp"
-
-#include "boost/variant/detail/config.hpp"
-#include "boost/mpl/aux_/value_wknd.hpp"
-
-#include "boost/variant/variant_fwd.hpp"
-#include "boost/variant/detail/backup_holder.hpp"
-#include "boost/variant/detail/enable_recursive_fwd.hpp"
-#include "boost/variant/detail/forced_return.hpp"
-#include "boost/variant/detail/initializer.hpp"
-#include "boost/variant/detail/make_variant_list.hpp"
-#include "boost/variant/detail/over_sequence.hpp"
-#include "boost/variant/detail/visitation_impl.hpp"
-#include "boost/variant/detail/hash_variant.hpp"
-
-#include "boost/variant/detail/generic_result_type.hpp"
-#include "boost/variant/detail/move.hpp"
-
-#include "boost/detail/no_exceptions_support.hpp"
-#include "boost/detail/reference_content.hpp"
-#include "boost/aligned_storage.hpp"
-#include "boost/blank.hpp"
-#include "boost/math/common_factor_ct.hpp"
-#include "boost/static_assert.hpp"
-#include "boost/preprocessor/cat.hpp"
-#include "boost/preprocessor/repeat.hpp"
-#include "boost/type_traits/alignment_of.hpp"
-#include "boost/type_traits/add_const.hpp"
-#include "boost/type_traits/has_nothrow_constructor.hpp"
-#include "boost/type_traits/has_nothrow_copy.hpp"
-#include "boost/type_traits/is_nothrow_move_assignable.hpp"
-#include "boost/type_traits/is_nothrow_move_constructible.hpp"
-#include "boost/type_traits/is_const.hpp"
-#include "boost/type_traits/is_same.hpp"
-#include "boost/type_traits/is_rvalue_reference.hpp"
-#include "boost/utility/enable_if.hpp"
-#include "boost/utility/declval.hpp"
-#include "boost/variant/recursive_wrapper_fwd.hpp"
-#include "boost/variant/static_visitor.hpp"
-
-#include "boost/mpl/assert.hpp"
-#include "boost/mpl/begin_end.hpp"
-#include "boost/mpl/bool.hpp"
-#include "boost/mpl/deref.hpp"
-#include "boost/mpl/empty.hpp"
-#include "boost/mpl/eval_if.hpp"
-#include "boost/mpl/find_if.hpp"
-#include "boost/mpl/fold.hpp"
-#include "boost/mpl/front.hpp"
-#include "boost/mpl/identity.hpp"
-#include "boost/mpl/if.hpp"
-#include "boost/mpl/int.hpp"
-#include "boost/mpl/is_sequence.hpp"
-#include "boost/mpl/iterator_range.hpp"
-#include "boost/mpl/iter_fold_if.hpp"
-#include "boost/mpl/logical.hpp"
-#include "boost/mpl/max_element.hpp"
-#include "boost/mpl/next.hpp"
-#include "boost/mpl/not.hpp"
-#include "boost/mpl/pair.hpp"
-#include "boost/mpl/protect.hpp"
-#include "boost/mpl/push_front.hpp"
-#include "boost/mpl/same_as.hpp"
-#include "boost/mpl/size_t.hpp"
-#include "boost/mpl/sizeof.hpp"
-#include "boost/mpl/transform.hpp"
+#include <boost/type_index.hpp>
+
+#include <boost/variant/detail/config.hpp>
+#include <boost/mpl/aux_/value_wknd.hpp>
+
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/variant/detail/backup_holder.hpp>
+#include <boost/variant/detail/enable_recursive_fwd.hpp>
+#include <boost/variant/detail/forced_return.hpp>
+#include <boost/variant/detail/initializer.hpp>
+#include <boost/variant/detail/make_variant_list.hpp>
+#include <boost/variant/detail/over_sequence.hpp>
+#include <boost/variant/detail/visitation_impl.hpp>
+#include <boost/variant/detail/hash_variant.hpp>
+
+#include <boost/variant/detail/generic_result_type.hpp>
+#include <boost/variant/detail/move.hpp>
+
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/detail/reference_content.hpp>
+#include <boost/aligned_storage.hpp>
+#include <boost/blank.hpp>
+#include <boost/math/common_factor_ct.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/has_nothrow_constructor.hpp>
+#include <boost/type_traits/has_nothrow_copy.hpp>
+#include <boost/type_traits/is_nothrow_move_assignable.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_rvalue_reference.hpp>
+#include <boost/type_traits/is_constructible.hpp>
+#include <boost/type_traits/add_lvalue_reference.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/utility/declval.hpp>
+#include <boost/variant/recursive_wrapper_fwd.hpp>
+#include <boost/variant/static_visitor.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/empty.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/find_if.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/iterator_range.hpp>
+#include <boost/mpl/iter_fold_if.hpp>
+#include <boost/mpl/logical.hpp>
+#include <boost/mpl/max_element.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/pair.hpp>
+#include <boost/mpl/protect.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/same_as.hpp>
+#include <boost/mpl/size_t.hpp>
+#include <boost/mpl/sizeof.hpp>
+#include <boost/mpl/transform.hpp>
///////////////////////////////////////////////////////////////////////////////
// Implementation Macros:
#if defined(BOOST_VARIANT_MINIMIZE_SIZE)
# include <climits> // for SCHAR_MAX
-# include "boost/mpl/eval_if.hpp"
-# include "boost/mpl/equal_to.hpp"
-# include "boost/mpl/identity.hpp"
-# include "boost/mpl/int.hpp"
-# include "boost/mpl/if.hpp"
-# include "boost/mpl/less.hpp"
-# include "boost/mpl/long.hpp"
-# include "boost/mpl/O1_size.hpp"
+# include <boost/mpl/eval_if.hpp>
+# include <boost/mpl/equal_to.hpp>
+# include <boost/mpl/identity.hpp>
+# include <boost/mpl/int.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/less.hpp>
+# include <boost/mpl/long.hpp>
+# include <boost/mpl/O1_size.hpp>
#endif
};
#endif // BOOST_NO_CXX11_NOEXCEPT
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction is_variant_constructible_from
+//
+// Derives from true_type if at least one variant's type is constructible from T.
+//
+template <class T1, class T2>
+struct is_constructible_ext:
+ boost::mpl::or_<
+ boost::is_constructible<
+ T1,
+ T2
+ >,
+ boost::is_constructible<
+ T1,
+ typename boost::add_lvalue_reference<T2>::type
+ >
+ >
+{};
+
+template <class T, class Types>
+struct is_variant_constructible_from:
+ boost::mpl::not_< boost::is_same<
+ typename boost::mpl::find_if<
+ Types,
+ is_constructible_ext<boost::mpl::_1, T>
+ >::type,
+ typename boost::mpl::end<Types>::type
+ > >
+{};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), class Types>
+struct is_variant_constructible_from< boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Types >:
+ boost::is_same<
+ typename boost::mpl::find_if<
+ typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::recursive_enabled_types,
+ mpl::not_< is_variant_constructible_from< boost::mpl::_1, Types> >
+ >::type,
+ typename boost::mpl::end< typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::recursive_enabled_types >::type
+ >
+{};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), class Types>
+struct is_variant_constructible_from< const boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& , Types >:
+ is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Types >
+{};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), class Types>
+struct is_variant_constructible_from< boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& , Types >:
+ is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Types >
+{};
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), class Types>
+struct is_variant_constructible_from< boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>&& , Types >:
+ is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Types >
+{};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), class Types>
+struct is_variant_constructible_from< boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const && , Types >:
+ is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Types >
+{};
+
+#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCE
+
+
///////////////////////////////////////////////////////////////////////////////
// (detail) metafunction make_storage
//
public: // visitor interfaces
template <typename T>
- bool operator()(const T& rhs_content) const
+ bool operator()(T& rhs_content) const
{
// Since the precondition ensures lhs and rhs types are same, get T...
- known_get<const T> getter;
+ known_get<T> getter;
const T& lhs_content = lhs_.apply_visitor(getter);
// ...and compare lhs and rhs contents:
::boost::mpl::not_< mpl::empty<specified_types> >::value
));
+public: // public typedefs
typedef typename mpl::eval_if<
is_recursive_
, mpl::transform<
>
>
, mpl::identity< specified_types >
- >::type recursive_enabled_types;
-
-public: // public typedefs
+ >::type recursive_enabled_types; // used by is_variant_constructible_from<> trait
typedef typename mpl::transform<
recursive_enabled_types
#endif
template <BOOST_VARIANT_ENUM_PARAMS(typename U)>
- void convert_construct(
+ typename boost::enable_if<mpl::or_<
+ boost::is_same<boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>, variant>,
+ boost::detail::variant::is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>&, internal_types>
+ > >::type convert_construct(
boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>& operand
, long
)
}
template <BOOST_VARIANT_ENUM_PARAMS(typename U)>
- void convert_construct(
+ typename boost::enable_if<mpl::or_<
+ boost::is_same<boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>, variant>,
+ boost::detail::variant::is_variant_constructible_from<const boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>&, internal_types>
+ > >::type convert_construct(
const boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>& operand
, long
)
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <BOOST_VARIANT_ENUM_PARAMS(typename U)>
- void convert_construct(
+ typename boost::enable_if<mpl::or_<
+ boost::is_same<boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>, variant>,
+ boost::detail::variant::is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>&&, internal_types>
+ > >::type convert_construct(
boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>&& operand
, long
)
public: // structors, cont.
-#if !defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING)
-
template <typename T>
- variant(const T& operand)
- {
- convert_construct(operand, 1L);
- }
-
- template <typename T>
- variant(T& operand)
- {
- convert_construct(operand, 1L);
- }
-
-#elif defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND)
-
- // For compilers that cannot distinguish between T& and const T& in
- // template constructors, but do fully support SFINAE, we can workaround:
-
- template <typename T>
- variant(const T& operand)
+ variant(const T& operand,
+ typename boost::enable_if<mpl::and_<
+ mpl::not_< boost::is_same<T, variant> >,
+ boost::detail::variant::is_variant_constructible_from<const T&, internal_types>
+ > >::type* = 0)
{
convert_construct(operand, 1L);
}
template <typename T>
variant(
T& operand
- , typename enable_if<
- mpl::not_< is_const<T> >
- , void
- >::type* = 0
+ , typename boost::enable_if<mpl::and_<
+ mpl::not_< is_const<T> >,
+ mpl::not_< boost::is_same<T, variant> >,
+ boost::detail::variant::is_variant_constructible_from<T&, internal_types>
+ > >::type* = 0
)
{
convert_construct(operand, 1L);
}
-#else // !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND)
-
- // For compilers that cannot distinguish between T& and const T& in
- // template constructors, and do NOT support SFINAE, we can't workaround:
-
- template <typename T>
- variant(const T& operand)
- {
- convert_construct(operand, 1L);
- }
-#endif // BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING workarounds
-
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class T>
- variant(T&& operand, typename boost::enable_if<boost::is_rvalue_reference<T&&> >::type* = 0,
- typename boost::disable_if<boost::is_const<T> >::type* = 0)
+ variant(T&& operand,
+ typename boost::enable_if<mpl::and_<
+ boost::is_rvalue_reference<T&&>,
+ mpl::not_< boost::is_const<T> >,
+ mpl::not_< boost::is_same<T, variant> >,
+ boost::detail::variant::is_variant_constructible_from<T&&, internal_types>
+ > >::type* = 0)
{
convert_construct( detail::variant::move(operand), 1L);
}
// ...and activate the *this's primary storage on success:
indicate_which(operand.which());
}
-
+
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
variant(variant&& operand) BOOST_NOEXCEPT_IF(variant_move_noexcept_constructible::type::value)
{
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class T>
- typename boost::enable_if_c<boost::is_rvalue_reference<T&&>::value && !boost::is_const<T>::value, variant& >::type
- operator=(T&& rhs)
+ typename boost::enable_if<
+ boost::mpl::and_<
+ boost::is_rvalue_reference<T&&>,
+ mpl::not_< boost::is_const<T> >,
+ boost::detail::variant::is_variant_constructible_from<T&&, internal_types>
+ >,
+ variant&
+ >::type operator=(T&& rhs)
{
move_assign( detail::variant::move(rhs) );
return *this;
#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
template <typename T>
- variant& operator=(const T& rhs)
+ typename boost::enable_if<
+ mpl::or_<
+ boost::is_same<T, variant>,
+ boost::detail::variant::is_variant_constructible_from<const T&, internal_types>
+ >,
+ variant&
+ >::type operator=(const T& rhs)
{
assign(rhs);
return *this;
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
variant& operator=(variant&& rhs)
-#if !defined(__GNUC__) || (__GNUC__ != 4) || (__GNUC_MINOR__ > 6)
+#if !defined(__GNUC__) || (__GNUC__ != 4) || (__GNUC_MINOR__ > 6) || defined(__clang__)
BOOST_NOEXCEPT_IF(variant_move_noexcept_constructible::type::value && variant_move_noexcept_assignable::type::value)
#endif
{
public: // prevent comparison with foreign types
-// Obsolete. Remove.
-# define BOOST_VARIANT_AUX_FAIL_COMPARISON_RETURN_TYPE \
- void
-
template <typename U>
void operator==(const U&) const
{
// implementation additions
#if !defined(BOOST_NO_IOSTREAM)
-#include "boost/variant/detail/variant_io.hpp"
+#include <boost/variant/detail/variant_io.hpp>
#endif // BOOST_NO_IOSTREAM
#endif // BOOST_VARIANT_VARIANT_HPP
//-----------------------------------------------------------------------------
//
// Copyright (c) 2003 Eric Friedman, Itay Maman
-// Copyright (c) 2013 Antony Polukhin
+// Copyright (c) 2013-2016 Antony Polukhin
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
#ifndef BOOST_VARIANT_VARIANT_FWD_HPP
#define BOOST_VARIANT_VARIANT_FWD_HPP
-#include "boost/variant/detail/config.hpp"
+#include <boost/variant/detail/config.hpp>
-#include "boost/blank_fwd.hpp"
-#include "boost/mpl/arg.hpp"
-#include "boost/mpl/limits/arity.hpp"
-#include "boost/mpl/aux_/na.hpp"
-#include "boost/preprocessor/cat.hpp"
-#include "boost/preprocessor/enum.hpp"
-#include "boost/preprocessor/enum_params.hpp"
-#include "boost/preprocessor/enum_shifted_params.hpp"
-#include "boost/preprocessor/repeat.hpp"
-
-///////////////////////////////////////////////////////////////////////////////
-// macro BOOST_VARIANT_NO_REFERENCE_SUPPORT
-//
-// Defined if variant does not support references as bounded types.
-//
-#if defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING) \
- && !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND) \
- && !defined(BOOST_VARIANT_NO_REFERENCE_SUPPORT)
-# define BOOST_VARIANT_NO_REFERENCE_SUPPORT
-#endif
+#include <boost/blank_fwd.hpp>
+#include <boost/mpl/arg.hpp>
+#include <boost/mpl/limits/arity.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/enum.hpp>
+#include <boost/preprocessor/enum_params.hpp>
+#include <boost/preprocessor/enum_shifted_params.hpp>
+#include <boost/preprocessor/repeat.hpp>
///////////////////////////////////////////////////////////////////////////////
// macro BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT
// so only types declared w/ MPL lambda workarounds will work.
//
-#include "boost/variant/detail/substitute_fwd.hpp"
+#include <boost/variant/detail/substitute_fwd.hpp>
#if defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) \
&& !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
// Implementation-defined preprocessor symbol describing the actual
// length of variant's pseudo-variadic template parameter list.
//
-#include "boost/mpl/limits/list.hpp"
+#include <boost/mpl/limits/list.hpp>
#define BOOST_VARIANT_LIMIT_TYPES \
BOOST_MPL_LIMIT_LIST_SIZE
// arguments. That is,
// make_recursive_variant< ..., T<[1], recursive_variant_, ... [N]> >.
//
-#include "boost/mpl/limits/arity.hpp"
+#include <boost/mpl/limits/arity.hpp>
#define BOOST_VARIANT_RECURSIVE_VARIANT_MAX_ARITY \
BOOST_MPL_LIMIT_METAFUNCTION_ARITY
// BOOST_VERSION / 100 % 1000 is the minor version
// BOOST_VERSION / 100000 is the major version
-#define BOOST_VERSION 106100
+#define BOOST_VERSION 106200
//
// BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION
// number, y is the minor version number, and z is the patch level if not 0.
// This is used by <config/auto_link.hpp> to select which library version to link to.
-#define BOOST_LIB_VERSION "1_61"
+#define BOOST_LIB_VERSION "1_62"
#endif
projects / lyx.git / commitdiff