[prev in list] [next in list] [prev in thread] [next in thread]
List: fdo-commits
Subject: [fdo-commits] r7435 - trunk/Thirdparty/boost/boost
From: svn_fdo () osgeo ! org
Date: 2015-12-10 13:29:55
Message-ID: 20151210132956.0FA9F39012E () trac ! osgeo ! org
[Download RAW message or body]
Author: kwi
Date: 2015-12-10 05:29:55 -0800 (Thu, 10 Dec 2015)
New Revision: 7435
Added:
trunk/Thirdparty/boost/boost/align.hpp
trunk/Thirdparty/boost/boost/convert.hpp
trunk/Thirdparty/boost/boost/cstdfloat.hpp
trunk/Thirdparty/boost/boost/cxx11_char_types.hpp
trunk/Thirdparty/boost/boost/make_default.hpp
trunk/Thirdparty/boost/boost/make_unique.hpp
trunk/Thirdparty/boost/boost/polymorphic_cast.hpp
trunk/Thirdparty/boost/boost/polymorphic_pointer_cast.hpp
trunk/Thirdparty/boost/boost/predef.h
trunk/Thirdparty/boost/boost/type_index.hpp
Removed:
trunk/Thirdparty/boost/boost/align.hpp
trunk/Thirdparty/boost/boost/convert.hpp
trunk/Thirdparty/boost/boost/cstdfloat.hpp
trunk/Thirdparty/boost/boost/cxx11_char_types.hpp
Modified:
trunk/Thirdparty/boost/boost/memory_order.hpp
trunk/Thirdparty/boost/boost/multi_index_container.hpp
trunk/Thirdparty/boost/boost/multi_index_container_fwd.hpp
trunk/Thirdparty/boost/boost/next_prior.hpp
trunk/Thirdparty/boost/boost/noncopyable.hpp
trunk/Thirdparty/boost/boost/nondet_random.hpp
trunk/Thirdparty/boost/boost/none.hpp
trunk/Thirdparty/boost/boost/none_t.hpp
trunk/Thirdparty/boost/boost/operators.hpp
trunk/Thirdparty/boost/boost/pointee.hpp
trunk/Thirdparty/boost/boost/preprocessor.hpp
trunk/Thirdparty/boost/boost/program_options.hpp
trunk/Thirdparty/boost/boost/progress.hpp
trunk/Thirdparty/boost/boost/python.hpp
trunk/Thirdparty/boost/boost/random.hpp
trunk/Thirdparty/boost/boost/range.hpp
trunk/Thirdparty/boost/boost/rational.hpp
trunk/Thirdparty/boost/boost/ref.hpp
trunk/Thirdparty/boost/boost/scope_exit.hpp
trunk/Thirdparty/boost/boost/shared_container_iterator.hpp
trunk/Thirdparty/boost/boost/spirit.hpp
trunk/Thirdparty/boost/boost/swap.hpp
trunk/Thirdparty/boost/boost/throw_exception.hpp
trunk/Thirdparty/boost/boost/token_functions.hpp
trunk/Thirdparty/boost/boost/token_iterator.hpp
trunk/Thirdparty/boost/boost/type_traits.hpp
trunk/Thirdparty/boost/boost/unordered_map.hpp
trunk/Thirdparty/boost/boost/unordered_set.hpp
trunk/Thirdparty/boost/boost/version.hpp
trunk/Thirdparty/boost/boost/visit_each.hpp
Log:
RFC #70: VS 2015 - merge sandbox to trunk: thirdparty\boost root folder (Part II)
Deleted: trunk/Thirdparty/boost/boost/align.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/align.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/align.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -1,21 +0,0 @@
-/*
-(c) 2014-2015 Glen Joseph Fernandes
-glenjofe at gmail dot com
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_HPP
-#define BOOST_ALIGN_HPP
-
-#include <boost/align/align.hpp>
-#include <boost/align/aligned_alloc.hpp>
-#include <boost/align/aligned_allocator.hpp>
-#include <boost/align/aligned_allocator_adaptor.hpp>
-#include <boost/align/aligned_delete.hpp>
-#include <boost/align/alignment_of.hpp>
-#include <boost/align/assume_aligned.hpp>
-#include <boost/align/is_aligned.hpp>
-
-#endif
Copied: trunk/Thirdparty/boost/boost/align.hpp (from rev 7307, \
sandbox/v140/Thirdparty/boost/boost/align.hpp) \
===================================================================
--- trunk/Thirdparty/boost/boost/align.hpp (rev 0)
+++ trunk/Thirdparty/boost/boost/align.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -0,0 +1,21 @@
+/*
+(c) 2014-2015 Glen Joseph Fernandes
+glenjofe at gmail dot com
+
+Distributed under the Boost Software
+License, Version 1.0.
+http://boost.org/LICENSE_1_0.txt
+*/
+#ifndef BOOST_ALIGN_HPP
+#define BOOST_ALIGN_HPP
+
+#include <boost/align/align.hpp>
+#include <boost/align/aligned_alloc.hpp>
+#include <boost/align/aligned_allocator.hpp>
+#include <boost/align/aligned_allocator_adaptor.hpp>
+#include <boost/align/aligned_delete.hpp>
+#include <boost/align/alignment_of.hpp>
+#include <boost/align/assume_aligned.hpp>
+#include <boost/align/is_aligned.hpp>
+
+#endif
Deleted: trunk/Thirdparty/boost/boost/convert.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/convert.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/convert.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -1,216 +0,0 @@
-/// @file
-// Boost.Convert
-// Copyright (c) 2009-2014 Vladimir Batov.
-//
-// Many thanks to Julian Gonggrijp, Rob Stewart, Andrzej Krzemienski, Matus \
Chochlik, Jeroen Habraken,
-// Hartmut Kaiser, Joel De Guzman, Thijs (M.A.) van den Berg, Roland Bock, Gavin \
Lambert, Paul Bristow,
-// Alex Hagen-Zanker, Christopher Kormanyos for taking part in the Boost.Convert \
review.
-//
-// Special thanks to:
-//
-// 1. Alex Hagen-Zanker, Roland Bock, Rob Stewart for their considerable \
contributions to the design
-// and implementation of the library;
-// 2. Andrzej Krzemienski for helping to partition responsibilities and to \
ultimately pave
-// the way for the boost::optional and future std::tr2::optional deployment;
-// 3. Edward Diener the Boost Review Manager for helping with the converters' \
design, his continuous
-// involvement, technical and administrative help, guidance and advice;
-// 4. Joel De Guzman, Rob Stewart and Alex Hagen-Zanker for making sure the \
performance tests work
-// as they should;
-// 5. Paul Bristow for helping great deal with the documentation;
-// 6. Kevlin Henney and Dave Abrahams for their lexical_cast-related insights and \
explanations.
-//
-// Use, modification and distribution are subject to the Boost Software License,
-// Version 1.0. See http://www.boost.org/LICENSE_1_0.txt.
-
-#ifndef BOOST_CONVERT_HPP
-#define BOOST_CONVERT_HPP
-
-#include <boost/convert/detail/is_fun.hpp>
-#include <boost/ref.hpp>
-
-namespace boost
-{
- namespace detail { enum throw_on_failure {}; }
-
- /// @details The boost::throw_on_failure is the name of an object of the
- /// boost::detail::throw_on_failure type that is used to indicate
- /// desired exception-throwing behavior.
- detail::throw_on_failure const throw_on_failure = detail::throw_on_failure(0);
-
- namespace cnv
- {
- template<typename, typename, typename> struct reference;
- struct by_default;
- }
-
- /// @brief Boost.Convert main deployment interface
- /// @param[in] value_in Value of the TypeIn type to be converted to the TyeOut \
type
- /// @param[in] converter Converter to be used for conversion
- /// @return boost::optional<TypeOut> result of conversion together with the \
indication of
- /// success or failure of the conversion request.
- /// @details For example,
- /// @code
- /// boost::cnv::cstream cnv;
- ///
- /// boost::optional<int> i = boost::convert<int>("12", cnv);
- /// boost::optional<string> s = boost::convert<string>(123.456, cnv);
- /// @endcode
-
- template<typename TypeOut, typename TypeIn, typename Converter>
- boost::optional<TypeOut>
- convert(TypeIn const& value_in, Converter const& converter)
- {
- optional<TypeOut> result;
- boost::unwrap_ref(converter)(value_in, result);
- return result;
- }
-
- namespace cnv { namespace detail
- {
- template<typename TypeOut, typename TypeIn, typename Converter \
=boost::cnv::by_default>
- struct delayed_resolution
- {
- static optional<TypeOut> convert(TypeIn const& value_in)
- {
- return boost::convert<TypeOut>(value_in, Converter());
- }
- };
- }}
- /// @brief Boost.Convert deployment interface with the default converter
- /// @details For example,
- /// @code
- /// struct boost::cnv::by_default : public boost::cnv::cstream {};
- ///
- /// // boost::cnv::cstream (through boost::cnv::by_default) is deployed
- /// // as the default converter when no converter is provided explicitly.
- /// boost::optional<int> i = boost::convert<int>("12");
- /// boost::optional<string> s = boost::convert<string>(123.456);
- /// @endcode
-
- template<typename TypeOut, typename TypeIn>
- boost::optional<TypeOut>
- convert(TypeIn const& value_in)
- {
- return cnv::detail::delayed_resolution<TypeOut, TypeIn>::convert(value_in);
- }
-}
-
-namespace boost
-{
- /// @brief Boost.Convert non-optional deployment interface
-
- template<typename TypeOut, typename TypeIn, typename Converter>
- TypeOut
- convert(TypeIn const& value_in, Converter const& converter, \
boost::detail::throw_on_failure)
- {
- return convert<TypeOut>(value_in, converter).value();
- }
-
- template<typename TypeOut, typename TypeIn, typename Converter, typename \
Fallback>
- typename enable_if<is_convertible<Fallback, TypeOut>, TypeOut>::type
- convert(TypeIn const& value_in, Converter const& converter, Fallback const& \
fallback)
- {
- return convert<TypeOut>(value_in, converter).value_or(fallback);
- }
-
- template<typename TypeOut, typename TypeIn, typename Converter, typename \
Fallback>
- typename enable_if<cnv::is_fun<Fallback, TypeOut>, TypeOut>::type
- convert(TypeIn const& value_in, Converter const& converter, Fallback fallback)
- {
- return convert<TypeOut>(value_in, converter).value_or_eval(fallback);
- }
-}
-
-namespace boost { namespace cnv
-{
- template<typename Converter, typename TypeOut, typename TypeIn>
- struct reference
- {
- typedef reference this_type;
-
- reference(Converter const& cnv) : converter_(cnv) {}
-
-#ifdef BOOST_CONVERT_CXX11
- reference(Converter&& cnv) : converter_(std::move(cnv)) {}
-#endif
-
- this_type&
- value_or(TypeOut const& fallback)
- {
- return (fallback_ = fallback, *this);
- }
-
- TypeOut
- operator()(TypeIn const& value_in)
- {
- optional<TypeOut> result = convert<TypeOut>(value_in, converter_);
- return result ? result.get() : fallback_.value();
- }
-
- private:
-
- Converter converter_;
- optional<TypeOut> fallback_;
- };
- template<typename Converter, typename TypeOut>
- struct reference<Converter, TypeOut, void>
- {
- typedef reference this_type;
-
- reference(Converter const& cnv) : converter_(cnv) {}
-
-#ifdef BOOST_CONVERT_CXX11
- reference(Converter&& cnv) : converter_(std::move(cnv)) {}
-#endif
-
- this_type&
- value_or(TypeOut const& fallback)
- {
- return (fallback_ = fallback, *this);
- }
-
- template<typename TypeIn>
- TypeOut
- operator()(TypeIn const& value_in)
- {
- optional<TypeOut> result = convert<TypeOut>(value_in, converter_);
- return result ? result.get() : fallback_.value();
- }
-
- private:
-
- Converter converter_;
- optional<TypeOut> fallback_;
- };
-
- /// @brief Boost.Convert deployment interface with algorithms
- /// @details For example,
- /// @code
- /// boost::array<char const*, 3> strs = {{ " 5", "0XF", "not an int" }};
- /// std::vector<int> ints;
- /// boost::cnv::cstream cnv;
- ///
- /// cnv(std::hex)(std::skipws);
- ///
- /// std::transform(
- /// strs.begin(),
- /// strs.end(),
- /// std::back_inserter(ints),
- /// boost::cnv::apply<int>(boost::cref(cnv)).value_or(-1));
- /// @endcode
-
- template<typename TypeOut, typename TypeIn, typename Converter>
- reference<Converter, TypeOut, TypeIn>
- apply(Converter const& cnv)
- {
- return cnv::reference<Converter, TypeOut, TypeIn>(cnv);
- }
- template<typename TypeOut, typename Converter>
- reference<Converter, TypeOut, void>
- apply(Converter const& cnv)
- {
- return cnv::reference<Converter, TypeOut, void>(cnv);
- }
-}}
-
-#endif // BOOST_CONVERT_HPP
Copied: trunk/Thirdparty/boost/boost/convert.hpp (from rev 7307, \
sandbox/v140/Thirdparty/boost/boost/convert.hpp) \
===================================================================
--- trunk/Thirdparty/boost/boost/convert.hpp (rev 0)
+++ trunk/Thirdparty/boost/boost/convert.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -0,0 +1,216 @@
+/// @file
+// Boost.Convert
+// Copyright (c) 2009-2014 Vladimir Batov.
+//
+// Many thanks to Julian Gonggrijp, Rob Stewart, Andrzej Krzemienski, Matus \
Chochlik, Jeroen Habraken, +// Hartmut Kaiser, Joel De Guzman, Thijs (M.A.) van den \
Berg, Roland Bock, Gavin Lambert, Paul Bristow, +// Alex Hagen-Zanker, Christopher \
Kormanyos for taking part in the Boost.Convert review. +//
+// Special thanks to:
+//
+// 1. Alex Hagen-Zanker, Roland Bock, Rob Stewart for their considerable \
contributions to the design +// and implementation of the library;
+// 2. Andrzej Krzemienski for helping to partition responsibilities and to \
ultimately pave +// the way for the boost::optional and future std::tr2::optional \
deployment; +// 3. Edward Diener the Boost Review Manager for helping with the \
converters' design, his continuous +// involvement, technical and administrative \
help, guidance and advice; +// 4. Joel De Guzman, Rob Stewart and Alex Hagen-Zanker \
for making sure the performance tests work +// as they should;
+// 5. Paul Bristow for helping great deal with the documentation;
+// 6. Kevlin Henney and Dave Abrahams for their lexical_cast-related insights and \
explanations. +//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. See http://www.boost.org/LICENSE_1_0.txt.
+
+#ifndef BOOST_CONVERT_HPP
+#define BOOST_CONVERT_HPP
+
+#include <boost/convert/detail/is_fun.hpp>
+#include <boost/ref.hpp>
+
+namespace boost
+{
+ namespace detail { enum throw_on_failure {}; }
+
+ /// @details The boost::throw_on_failure is the name of an object of the
+ /// boost::detail::throw_on_failure type that is used to indicate
+ /// desired exception-throwing behavior.
+ detail::throw_on_failure const throw_on_failure = detail::throw_on_failure(0);
+
+ namespace cnv
+ {
+ template<typename, typename, typename> struct reference;
+ struct by_default;
+ }
+
+ /// @brief Boost.Convert main deployment interface
+ /// @param[in] value_in Value of the TypeIn type to be converted to the TyeOut \
type + /// @param[in] converter Converter to be used for conversion
+ /// @return boost::optional<TypeOut> result of conversion together with the \
indication of + /// success or failure of the conversion request.
+ /// @details For example,
+ /// @code
+ /// boost::cnv::cstream cnv;
+ ///
+ /// boost::optional<int> i = boost::convert<int>("12", cnv);
+ /// boost::optional<string> s = boost::convert<string>(123.456, cnv);
+ /// @endcode
+
+ template<typename TypeOut, typename TypeIn, typename Converter>
+ boost::optional<TypeOut>
+ convert(TypeIn const& value_in, Converter const& converter)
+ {
+ optional<TypeOut> result;
+ boost::unwrap_ref(converter)(value_in, result);
+ return result;
+ }
+
+ namespace cnv { namespace detail
+ {
+ template<typename TypeOut, typename TypeIn, typename Converter \
=boost::cnv::by_default> + struct delayed_resolution
+ {
+ static optional<TypeOut> convert(TypeIn const& value_in)
+ {
+ return boost::convert<TypeOut>(value_in, Converter());
+ }
+ };
+ }}
+ /// @brief Boost.Convert deployment interface with the default converter
+ /// @details For example,
+ /// @code
+ /// struct boost::cnv::by_default : public boost::cnv::cstream {};
+ ///
+ /// // boost::cnv::cstream (through boost::cnv::by_default) is deployed
+ /// // as the default converter when no converter is provided explicitly.
+ /// boost::optional<int> i = boost::convert<int>("12");
+ /// boost::optional<string> s = boost::convert<string>(123.456);
+ /// @endcode
+
+ template<typename TypeOut, typename TypeIn>
+ boost::optional<TypeOut>
+ convert(TypeIn const& value_in)
+ {
+ return cnv::detail::delayed_resolution<TypeOut, TypeIn>::convert(value_in);
+ }
+}
+
+namespace boost
+{
+ /// @brief Boost.Convert non-optional deployment interface
+
+ template<typename TypeOut, typename TypeIn, typename Converter>
+ TypeOut
+ convert(TypeIn const& value_in, Converter const& converter, \
boost::detail::throw_on_failure) + {
+ return convert<TypeOut>(value_in, converter).value();
+ }
+
+ template<typename TypeOut, typename TypeIn, typename Converter, typename \
Fallback> + typename enable_if<is_convertible<Fallback, TypeOut>, TypeOut>::type
+ convert(TypeIn const& value_in, Converter const& converter, Fallback const& \
fallback) + {
+ return convert<TypeOut>(value_in, converter).value_or(fallback);
+ }
+
+ template<typename TypeOut, typename TypeIn, typename Converter, typename \
Fallback> + typename enable_if<cnv::is_fun<Fallback, TypeOut>, TypeOut>::type
+ convert(TypeIn const& value_in, Converter const& converter, Fallback fallback)
+ {
+ return convert<TypeOut>(value_in, converter).value_or_eval(fallback);
+ }
+}
+
+namespace boost { namespace cnv
+{
+ template<typename Converter, typename TypeOut, typename TypeIn>
+ struct reference
+ {
+ typedef reference this_type;
+
+ reference(Converter const& cnv) : converter_(cnv) {}
+
+#ifdef BOOST_CONVERT_CXX11
+ reference(Converter&& cnv) : converter_(std::move(cnv)) {}
+#endif
+
+ this_type&
+ value_or(TypeOut const& fallback)
+ {
+ return (fallback_ = fallback, *this);
+ }
+
+ TypeOut
+ operator()(TypeIn const& value_in)
+ {
+ optional<TypeOut> result = convert<TypeOut>(value_in, converter_);
+ return result ? result.get() : fallback_.value();
+ }
+
+ private:
+
+ Converter converter_;
+ optional<TypeOut> fallback_;
+ };
+ template<typename Converter, typename TypeOut>
+ struct reference<Converter, TypeOut, void>
+ {
+ typedef reference this_type;
+
+ reference(Converter const& cnv) : converter_(cnv) {}
+
+#ifdef BOOST_CONVERT_CXX11
+ reference(Converter&& cnv) : converter_(std::move(cnv)) {}
+#endif
+
+ this_type&
+ value_or(TypeOut const& fallback)
+ {
+ return (fallback_ = fallback, *this);
+ }
+
+ template<typename TypeIn>
+ TypeOut
+ operator()(TypeIn const& value_in)
+ {
+ optional<TypeOut> result = convert<TypeOut>(value_in, converter_);
+ return result ? result.get() : fallback_.value();
+ }
+
+ private:
+
+ Converter converter_;
+ optional<TypeOut> fallback_;
+ };
+
+ /// @brief Boost.Convert deployment interface with algorithms
+ /// @details For example,
+ /// @code
+ /// boost::array<char const*, 3> strs = {{ " 5", "0XF", "not an int" }};
+ /// std::vector<int> ints;
+ /// boost::cnv::cstream cnv;
+ ///
+ /// cnv(std::hex)(std::skipws);
+ ///
+ /// std::transform(
+ /// strs.begin(),
+ /// strs.end(),
+ /// std::back_inserter(ints),
+ /// boost::cnv::apply<int>(boost::cref(cnv)).value_or(-1));
+ /// @endcode
+
+ template<typename TypeOut, typename TypeIn, typename Converter>
+ reference<Converter, TypeOut, TypeIn>
+ apply(Converter const& cnv)
+ {
+ return cnv::reference<Converter, TypeOut, TypeIn>(cnv);
+ }
+ template<typename TypeOut, typename Converter>
+ reference<Converter, TypeOut, void>
+ apply(Converter const& cnv)
+ {
+ return cnv::reference<Converter, TypeOut, void>(cnv);
+ }
+}}
+
+#endif // BOOST_CONVERT_HPP
Deleted: trunk/Thirdparty/boost/boost/cstdfloat.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/cstdfloat.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/cstdfloat.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -1,58 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright Christopher Kormanyos 2014.
-// Copyright John Maddock 2014.
-// Copyright Paul Bristow 2014.
-// Distributed under the Boost Software License,
-// Version 1.0. (See accompanying file LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// <boost/cstdfloat.hpp> implements floating-point typedefs having
-// specified widths, as described in N3626 (proposed for C++14).
-// See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3626.pdf
-
-#ifndef _BOOST_CSTDFLOAT_2014_01_09_HPP_
- #define _BOOST_CSTDFLOAT_2014_01_09_HPP_
-
- // Include the floating-point type definitions.
- #include <boost/math/cstdfloat/cstdfloat_types.hpp>
-
- // Support a specialization of std::numeric_limits<> for the wrapped quadmath \
library (if available).
- #if !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_LIMITS)
- #include <boost/math/cstdfloat/cstdfloat_limits.hpp>
- #endif
-
- // Support <cmath> functions for the wrapped quadmath library (if available).
- #if !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_CMATH)
- #include <boost/math/cstdfloat/cstdfloat_cmath.hpp>
- #endif
-
- // Support I/O stream operations for the wrapped quadmath library (if available).
- #if !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_IOSTREAM)
- #if defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_CMATH)
- #error You can not use <boost/math/cstdfloat/cstdfloat_iostream.hpp> with \
BOOST_CSTDFLOAT_NO_LIBQUADMATH_CMATH defined.
- #endif
- #include <boost/math/cstdfloat/cstdfloat_iostream.hpp>
- #endif
-
- // Support a specialization of std::complex<> for the wrapped quadmath library (if \
available).
- #if !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_COMPLEX)
- #if defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_LIMITS)
- #error You can not use <boost/math/cstdfloat/cstdfloat_complex.hpp> with \
BOOST_CSTDFLOAT_NO_LIBQUADMATH_LIMITS defined.
- #endif
- #if defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_CMATH)
- #error You can not use <boost/math/cstdfloat/cstdfloat_complex.hpp> with \
BOOST_CSTDFLOAT_NO_LIBQUADMATH_CMATH defined.
- #endif
- #if defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_IOSTREAM)
- #error You can not use <boost/math/cstdfloat/cstdfloat_complex.hpp> with \
BOOST_CSTDFLOAT_NO_LIBQUADMATH_IOSTREAM defined.
- #endif
- #include <boost/math/cstdfloat/cstdfloat_complex.hpp>
- #endif
-
-
- // Undefine BOOST_NO_FLOAT128_T because this constant is not meant for public use.
- #if defined(BOOST_CSTDFLOAT_HAS_INTERNAL_FLOAT128_T)
- #undef BOOST_CSTDFLOAT_HAS_INTERNAL_FLOAT128_T
- #endif
-
-#endif // _BOOST_CSTDFLOAT_2014_01_09_HPP_
Copied: trunk/Thirdparty/boost/boost/cstdfloat.hpp (from rev 7307, \
sandbox/v140/Thirdparty/boost/boost/cstdfloat.hpp) \
===================================================================
--- trunk/Thirdparty/boost/boost/cstdfloat.hpp (rev 0)
+++ trunk/Thirdparty/boost/boost/cstdfloat.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -0,0 +1,58 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright Christopher Kormanyos 2014.
+// Copyright John Maddock 2014.
+// Copyright Paul Bristow 2014.
+// Distributed under the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// <boost/cstdfloat.hpp> implements floating-point typedefs having
+// specified widths, as described in N3626 (proposed for C++14).
+// See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3626.pdf
+
+#ifndef _BOOST_CSTDFLOAT_2014_01_09_HPP_
+ #define _BOOST_CSTDFLOAT_2014_01_09_HPP_
+
+ // Include the floating-point type definitions.
+ #include <boost/math/cstdfloat/cstdfloat_types.hpp>
+
+ // Support a specialization of std::numeric_limits<> for the wrapped quadmath \
library (if available). + #if !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_LIMITS)
+ #include <boost/math/cstdfloat/cstdfloat_limits.hpp>
+ #endif
+
+ // Support <cmath> functions for the wrapped quadmath library (if available).
+ #if !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_CMATH)
+ #include <boost/math/cstdfloat/cstdfloat_cmath.hpp>
+ #endif
+
+ // Support I/O stream operations for the wrapped quadmath library (if available).
+ #if !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_IOSTREAM)
+ #if defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_CMATH)
+ #error You can not use <boost/math/cstdfloat/cstdfloat_iostream.hpp> with \
BOOST_CSTDFLOAT_NO_LIBQUADMATH_CMATH defined. + #endif
+ #include <boost/math/cstdfloat/cstdfloat_iostream.hpp>
+ #endif
+
+ // Support a specialization of std::complex<> for the wrapped quadmath library (if \
available). + #if !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_COMPLEX)
+ #if defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_LIMITS)
+ #error You can not use <boost/math/cstdfloat/cstdfloat_complex.hpp> with \
BOOST_CSTDFLOAT_NO_LIBQUADMATH_LIMITS defined. + #endif
+ #if defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_CMATH)
+ #error You can not use <boost/math/cstdfloat/cstdfloat_complex.hpp> with \
BOOST_CSTDFLOAT_NO_LIBQUADMATH_CMATH defined. + #endif
+ #if defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_IOSTREAM)
+ #error You can not use <boost/math/cstdfloat/cstdfloat_complex.hpp> with \
BOOST_CSTDFLOAT_NO_LIBQUADMATH_IOSTREAM defined. + #endif
+ #include <boost/math/cstdfloat/cstdfloat_complex.hpp>
+ #endif
+
+
+ // Undefine BOOST_NO_FLOAT128_T because this constant is not meant for public use.
+ #if defined(BOOST_CSTDFLOAT_HAS_INTERNAL_FLOAT128_T)
+ #undef BOOST_CSTDFLOAT_HAS_INTERNAL_FLOAT128_T
+ #endif
+
+#endif // _BOOST_CSTDFLOAT_2014_01_09_HPP_
Deleted: trunk/Thirdparty/boost/boost/cxx11_char_types.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/cxx11_char_types.hpp 2015-12-10 13:11:27 UTC (rev \
7434)
+++ trunk/Thirdparty/boost/boost/cxx11_char_types.hpp 2015-12-10 13:29:55 UTC (rev \
7435) @@ -1,70 +0,0 @@
-// boost cxx11_char_types.hpp \
--------------------------------------------------------//
-
-// Copyright Beman Dawes 2011
-
-// Distributed under the Boost Software License, Version 1.0.
-// See http://www.boost.org/LICENSE_1_0.txt
-
-//--------------------------------------------------------------------------------------//
-// \
//
-// The purpose of this header is to emulate the C++11 char16_t and char32_t \
//
-// character and string types so that they can be used in both C++11 and C++03 \
//
-// programs. \
//
-// \
//
-// The emulation names use char16/char32 rather than char16_t/char32_t to avoid use \
//
-// of names that are keywords in C++11. \
//
-// \
//
-// The emulation names are placed in namespace boost, as is usual for Boost C++11 \
//
-// emulation names such as those in header <boost/cstdint.hpp>. \
//
-// \
//
-// An alternative would would have been to place the C++11 emulation names at \
global //
-// scope, and put the C++11 string types in namespace std. That is the approach \
taken //
-// by Microsoft Visual Studio 2010, but is controversion with some Boost users and \
//
-// developers, and runs counter to usual Boost practice. \
//
-// \
//
-// Thanks to Mathias Gaunard and others for discussions leading to the final form \
//
-// of these typedefs. \
//
-// \
//
-// Boost C++11 C++03 \
//
-// ---------------- -------------- -------------------------------- \
//
-// boost::char16 char16_t uint16_t \
//
-// boost::char32 char32_t uint32_t \
//
-// boost::u16string std::u16string std::basic_string<boost::char16> \
//
-// boost::u32string std::u32string std::basic_string<boost::char32> \
//
-// \
//
-// Uses the typedefs provided by Microsoft Visual C++ 2010 if present \
//
-// \
//
-// Thanks to Mathias Gaunard and others for discussions leading to the final form \
//
-// of these typedefs. \
//
-// \
//
-//--------------------------------------------------------------------------------------//
-
-#if !defined(BOOST_CXX11_CHAR_TYPES_HPP)
-# define BOOST_CXX11_CHAR_TYPES_HPP
-
-# include <boost/config.hpp>
-# include <boost/cstdint.hpp>
-# include <string>
-
-namespace boost
-{
-
-# if defined(BOOST_NO_CHAR16_T) && (!defined(_MSC_VER) || _MSC_VER < 1600) // 1600 \
== VC++10
- typedef boost::uint_least16_t char16;
- typedef std::basic_string<boost::char16> u16string;
-# else
- typedef char16_t char16;
- typedef std::u16string u16string;
-# endif
-
-# if defined(BOOST_NO_CHAR32_T) && (!defined(_MSC_VER) || _MSC_VER < 1600) // 1600 \
== VC++10
- typedef boost::uint_least32_t char32;
- typedef std::basic_string<boost::char32> u32string;
-# else
- typedef char32_t char32;
- typedef std::u32string u32string;
-# endif
-
-} // namespace boost
-
-#endif // !defined(BOOST_CXX11_CHAR_TYPES_HPP)
Copied: trunk/Thirdparty/boost/boost/cxx11_char_types.hpp (from rev 7307, \
sandbox/v140/Thirdparty/boost/boost/cxx11_char_types.hpp) \
===================================================================
--- trunk/Thirdparty/boost/boost/cxx11_char_types.hpp (rev 0)
+++ trunk/Thirdparty/boost/boost/cxx11_char_types.hpp 2015-12-10 13:29:55 UTC (rev \
7435) @@ -0,0 +1,70 @@
+// boost cxx11_char_types.hpp \
--------------------------------------------------------// +
+// Copyright Beman Dawes 2011
+
+// Distributed under the Boost Software License, Version 1.0.
+// See http://www.boost.org/LICENSE_1_0.txt
+
+//--------------------------------------------------------------------------------------//
+// \
// +// The purpose of this header is to emulate the C++11 char16_t and char32_t \
// +// character and string types so that they can be used in both C++11 and C++03 \
// +// programs. \
// +// \
// +// The emulation names use char16/char32 rather than char16_t/char32_t to avoid \
use // +// of names that are keywords in C++11. \
// +// \
// +// The emulation names are placed in namespace boost, as is usual for Boost \
C++11 // +// emulation names such as those in header <boost/cstdint.hpp>. \
// +// \
// +// An alternative would would have been to place the C++11 emulation names at \
global // +// scope, and put the C++11 string types in namespace std. That is the \
approach taken // +// by Microsoft Visual Studio 2010, but is controversion with \
some Boost users and // +// developers, and runs counter to usual Boost \
practice. // +// \
// +// Thanks to Mathias Gaunard and others for discussions leading to the final \
form // +// of these typedefs. \
// +// \
// +// Boost C++11 C++03 \
// +// ---------------- -------------- -------------------------------- \
// +// boost::char16 char16_t uint16_t \
// +// boost::char32 char32_t uint32_t \
// +// boost::u16string std::u16string std::basic_string<boost::char16> \
// +// boost::u32string std::u32string std::basic_string<boost::char32> \
// +// \
// +// Uses the typedefs provided by Microsoft Visual C++ 2010 if present \
// +// \
// +// Thanks to Mathias Gaunard and others for discussions leading to the final \
form // +// of these typedefs. \
// +// \
// +//--------------------------------------------------------------------------------------//
+
+#if !defined(BOOST_CXX11_CHAR_TYPES_HPP)
+# define BOOST_CXX11_CHAR_TYPES_HPP
+
+# include <boost/config.hpp>
+# include <boost/cstdint.hpp>
+# include <string>
+
+namespace boost
+{
+
+# if defined(BOOST_NO_CHAR16_T) && (!defined(_MSC_VER) || _MSC_VER < 1600) // 1600 \
== VC++10 + typedef boost::uint_least16_t char16;
+ typedef std::basic_string<boost::char16> u16string;
+# else
+ typedef char16_t char16;
+ typedef std::u16string u16string;
+# endif
+
+# if defined(BOOST_NO_CHAR32_T) && (!defined(_MSC_VER) || _MSC_VER < 1600) // 1600 \
== VC++10 + typedef boost::uint_least32_t char32;
+ typedef std::basic_string<boost::char32> u32string;
+# else
+ typedef char32_t char32;
+ typedef std::u32string u32string;
+# endif
+
+} // namespace boost
+
+#endif // !defined(BOOST_CXX11_CHAR_TYPES_HPP)
Copied: trunk/Thirdparty/boost/boost/make_default.hpp (from rev 7307, \
sandbox/v140/Thirdparty/boost/boost/make_default.hpp) \
===================================================================
--- trunk/Thirdparty/boost/boost/make_default.hpp (rev 0)
+++ trunk/Thirdparty/boost/boost/make_default.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -0,0 +1,40 @@
+/// @file
+// Copyright (c) 2009-2014 Vladimir Batov.
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. See http://www.boost.org/LICENSE_1_0.txt.
+
+#ifndef BOOST_MAKE_DEFAULT_HPP
+#define BOOST_MAKE_DEFAULT_HPP
+
+namespace boost
+{
+ /// @details A considerable number of libraries require an instance of a class
+ /// provided (storage created and initialized). For example,
+ /// @code
+ /// Type result;
+ /// ...
+ /// istream >> result;
+ /// @endcode
+ /// In generic code that results in the Default Constructibility requirement \
imposed + /// on every type 'Type' to be used with the respective code. \
Inevitably, that requirement + /// a) either excludes all the classes that for \
various reasons do not meet that requirement or + /// b) imposes certain (not \
necessarily desirable) design/implementation onto respective classes. + ///
+ /// Deployment of boost::make_default() eliminates the Default Constructibility \
requirement with + /// @code
+ /// Type result = boost::make_default<Type>();
+ /// ...
+ /// istream >> result;
+ /// @endcode
+ /// Classes with no default constructor can now be included via a \
boost::make_default() specialization: + /// @code
+ /// namespace boost
+ /// {
+ /// template<> inline Type make_default<Type>() { return Type(parameters); }
+ /// }
+ /// @endcode
+
+ template<typename T> T make_default() { return T(); }
+}
+
+#endif // BOOST_MAKE_DEFAULT_HPP
Copied: trunk/Thirdparty/boost/boost/make_unique.hpp (from rev 7307, \
sandbox/v140/Thirdparty/boost/boost/make_unique.hpp) \
===================================================================
--- trunk/Thirdparty/boost/boost/make_unique.hpp (rev 0)
+++ trunk/Thirdparty/boost/boost/make_unique.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2014 Glen Joseph Fernandes
+ * glenfe at live dot com
+ *
+ * Distributed under the Boost Software License,
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt
+ * or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+#ifndef BOOST_MAKE_UNIQUE_HPP_INCLUDED
+#define BOOST_MAKE_UNIQUE_HPP_INCLUDED
+
+#include <boost/smart_ptr/make_unique.hpp>
+
+#endif
Modified: trunk/Thirdparty/boost/boost/memory_order.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/memory_order.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/memory_order.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -37,15 +37,19 @@
//
// if( mo & ( memory_order_acquire | memory_order_consume ) ) { ...fence... }
//
+// The values are also in the order of increasing "strength"
+// of the fences so that success/failure orders can be checked
+// efficiently in compare_exchange methods.
+//
enum memory_order
{
memory_order_relaxed = 0,
- memory_order_acquire = 1,
- memory_order_release = 2,
- memory_order_acq_rel = 3, // acquire | release
- memory_order_seq_cst = 7, // acq_rel | 4
- memory_order_consume = 8
+ memory_order_consume = 1,
+ memory_order_acquire = 2,
+ memory_order_release = 4,
+ memory_order_acq_rel = 6, // acquire | release
+ memory_order_seq_cst = 14 // acq_rel | 8
};
} // namespace boost
Modified: trunk/Thirdparty/boost/boost/multi_index_container.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/multi_index_container.hpp 2015-12-10 13:11:27 UTC \
(rev 7434)
+++ trunk/Thirdparty/boost/boost/multi_index_container.hpp 2015-12-10 13:29:55 UTC \
(rev 7435) @@ -1,6 +1,6 @@
/* Multiply indexed container.
*
- * Copyright 2003-2011 Joaquin M Lopez Munoz.
+ * Copyright 2003-2014 Joaquin M Lopez Munoz.
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
@@ -11,7 +11,7 @@
#ifndef BOOST_MULTI_INDEX_HPP
#define BOOST_MULTI_INDEX_HPP
-#if defined(_MSC_VER)&&(_MSC_VER>=1200)
+#if defined(_MSC_VER)
#pragma once
#endif
@@ -20,6 +20,7 @@
#include <boost/detail/allocator_utilities.hpp>
#include <boost/detail/no_exceptions_support.hpp>
#include <boost/detail/workaround.hpp>
+#include <boost/move/core.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/contains.hpp>
#include <boost/mpl/find_if.hpp>
@@ -31,17 +32,22 @@
#include <boost/multi_index/detail/access_specifier.hpp>
#include <boost/multi_index/detail/adl_swap.hpp>
#include <boost/multi_index/detail/base_type.hpp>
+#include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
#include <boost/multi_index/detail/converter.hpp>
#include <boost/multi_index/detail/header_holder.hpp>
#include <boost/multi_index/detail/has_tag.hpp>
#include <boost/multi_index/detail/no_duplicate_tags.hpp>
-#include <boost/multi_index/detail/prevent_eti.hpp>
#include <boost/multi_index/detail/safe_mode.hpp>
#include <boost/multi_index/detail/scope_guard.hpp>
+#include <boost/multi_index/detail/vartempl_support.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/utility/base_from_member.hpp>
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#include <initializer_list>
+#endif
+
#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
#include <boost/multi_index/detail/archive_constructed.hpp>
#include <boost/multi_index/detail/serialization_version.hpp>
@@ -54,11 +60,14 @@
#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
#include <boost/multi_index/detail/invariant_assert.hpp>
-#define BOOST_MULTI_INDEX_CHECK_INVARIANT \
+#define BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x) \
detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)= \
- detail::make_obj_guard(*this,&multi_index_container::check_invariant_); \
+ detail::make_obj_guard(x,&multi_index_container::check_invariant_); \
BOOST_JOIN(check_invariant_,__LINE__).touch();
+#define BOOST_MULTI_INDEX_CHECK_INVARIANT \
+ BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(*this)
#else
+#define BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x)
#define BOOST_MULTI_INDEX_CHECK_INVARIANT
#endif
@@ -66,6 +75,11 @@
namespace multi_index{
+#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
+#pragma warning(push)
+#pragma warning(disable:4522) /* spurious warning on multiple operator=()'s */
+#endif
+
template<typename Value,typename IndexSpecifierList,typename Allocator>
class multi_index_container:
private ::boost::base_from_member<
@@ -75,13 +89,10 @@
Value,IndexSpecifierList,Allocator>::type
>::type>,
BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS detail::header_holder<
- typename detail::prevent_eti<
+ typename boost::detail::allocator::rebind_to<
Allocator,
- typename boost::detail::allocator::rebind_to<
- Allocator,
- typename detail::multi_index_node_type<
- Value,IndexSpecifierList,Allocator>::type
- >::type
+ typename detail::multi_index_node_type<
+ Value,IndexSpecifierList,Allocator>::type
>::type::pointer,
multi_index_container<Value,IndexSpecifierList,Allocator> >,
public detail::multi_index_base_type<
@@ -98,6 +109,8 @@
#endif
private:
+ BOOST_COPYABLE_AND_MOVABLE(multi_index_container)
+
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
template <typename,typename,typename> friend class detail::index_base;
template <typename,typename> friend struct detail::header_holder;
@@ -108,52 +121,25 @@
Value,IndexSpecifierList,Allocator>::type super;
typedef typename
boost::detail::allocator::rebind_to<
- Allocator,
- typename super::node_type
+ Allocator,
+ typename super::node_type
>::type node_allocator;
typedef ::boost::base_from_member<
node_allocator> bfm_allocator;
typedef detail::header_holder<
- typename detail::prevent_eti<
- Allocator,
- node_allocator
- >::type::pointer,
+ typename node_allocator::pointer,
multi_index_container> bfm_header;
-#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
- /* see definition of index_type_list below */
- typedef typename super::index_type_list super_index_type_list;
-#endif
public:
/* All types are inherited from super, a few are explicitly
* brought forward here to save us some typename's.
*/
- typedef typename super::ctor_args_list ctor_args_list;
- typedef IndexSpecifierList index_specifier_type_list;
+ typedef typename super::ctor_args_list ctor_args_list;
+ typedef IndexSpecifierList index_specifier_type_list;
-#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
- /* MSVC++ 6.0 chokes on moderately long index lists (around 6 indices
- * or more), with errors ranging from corrupt exes to duplicate
- * comdats. The following type hiding hack alleviates this condition;
- * best results combined with type hiding of the indexed_by construct
- * itself, as explained in the "Compiler specifics" section of
- * the documentation.
- */
-
- struct index_type_list:super_index_type_list
- {
- typedef index_type_list type;
- typedef typename super_index_type_list::back back;
- typedef mpl::v_iter<type,0> begin;
- typedef mpl::v_iter<
- type,
- mpl::size<super_index_type_list>::value> end;
- };
-#else
typedef typename super::index_type_list index_type_list;
-#endif
typedef typename super::iterator_type_list iterator_type_list;
typedef typename super::const_iterator_type_list const_iterator_type_list;
@@ -194,7 +180,7 @@
node_count(0)
{
BOOST_MULTI_INDEX_CHECK_INVARIANT;
- }
+ }
explicit multi_index_container(const allocator_type& al):
bfm_allocator(al),
@@ -203,7 +189,7 @@
{
BOOST_MULTI_INDEX_CHECK_INVARIANT;
}
-
+
template<typename InputIterator>
multi_index_container(
InputIterator first,InputIterator last,
@@ -232,7 +218,36 @@
BOOST_TRY{
iterator hint=super::end();
for(;first!=last;++first){
+ hint=super::make_iterator(
+ insert_ref_(*first,hint.get_node()).first);
+ ++hint;
+ }
+ }
+ BOOST_CATCH(...){
+ clear_();
+ BOOST_RETHROW;
+ }
+ BOOST_CATCH_END
+ }
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+ multi_index_container(
+ std::initializer_list<Value> list,
+ const ctor_args_list& args_list=ctor_args_list(),
+ const allocator_type& al=allocator_type()):
+ bfm_allocator(al),
+ super(args_list,bfm_allocator::member),
+ node_count(0)
+ {
+ BOOST_MULTI_INDEX_CHECK_INVARIANT;
+ BOOST_TRY{
+ typedef const Value* init_iterator;
+
+ iterator hint=super::end();
+ for(init_iterator first=list.begin(),last=list.end();
+ first!=last;++first){
hint=super::make_iterator(insert_(*first,hint.get_node()).first);
+ ++hint;
}
}
BOOST_CATCH(...){
@@ -241,6 +256,7 @@
}
BOOST_CATCH_END
}
+#endif
multi_index_container(
const multi_index_container<Value,IndexSpecifierList,Allocator>& x):
@@ -264,21 +280,72 @@
BOOST_MULTI_INDEX_CHECK_INVARIANT;
}
+ multi_index_container(BOOST_RV_REF(multi_index_container) x):
+ bfm_allocator(x.bfm_allocator::member),
+ bfm_header(),
+ super(x,detail::do_not_copy_elements_tag()),
+ node_count(0)
+ {
+ BOOST_MULTI_INDEX_CHECK_INVARIANT;
+ BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x);
+ swap_elements_(x);
+ }
+
~multi_index_container()
{
delete_all_nodes_();
}
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ /* As per http://www.boost.org/doc/html/move/emulation_limitations.html
+ * #move.emulation_limitations.assignment_operator
+ */
+
multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
- multi_index_container<Value,IndexSpecifierList,Allocator> x)
+ const multi_index_container<Value,IndexSpecifierList,Allocator>& x)
{
- BOOST_MULTI_INDEX_CHECK_INVARIANT;
+ multi_index_container y(x);
+ this->swap(y);
+ return *this;
+ }
+#endif
+
+ multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
+ BOOST_COPY_ASSIGN_REF(multi_index_container) x)
+ {
+ multi_index_container y(x);
+ this->swap(y);
+ return *this;
+ }
+
+ multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
+ BOOST_RV_REF(multi_index_container) x)
+ {
this->swap(x);
return *this;
}
- allocator_type get_allocator()const
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+ multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
+ std::initializer_list<Value> list)
{
+ BOOST_MULTI_INDEX_CHECK_INVARIANT;
+ typedef const Value* init_iterator;
+
+ multi_index_container x(*this,detail::do_not_copy_elements_tag());
+ iterator hint=x.end();
+ for(init_iterator first=list.begin(),last=list.end();
+ first!=last;++first){
+ hint=x.make_iterator(x.insert_(*first,hint.get_node()).first);
+ ++hint;
+ }
+ x.swap_elements_(*this);
+ return*this;
+ }
+#endif
+
+ allocator_type get_allocator()const BOOST_NOEXCEPT
+ {
return allocator_type(bfm_allocator::member);
}
@@ -293,15 +360,14 @@
};
template<int N>
- typename nth_index<N>::type& get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+ typename nth_index<N>::type& get()BOOST_NOEXCEPT
{
BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
return *this;
}
template<int N>
- const typename nth_index<N>::type& get(
- BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const
+ const typename nth_index<N>::type& get()const BOOST_NOEXCEPT
{
BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
return *this;
@@ -327,14 +393,13 @@
};
template<typename Tag>
- typename index<Tag>::type& get(BOOST_EXPLICIT_TEMPLATE_TYPE(Tag))
+ typename index<Tag>::type& get()BOOST_NOEXCEPT
{
return *this;
}
template<typename Tag>
- const typename index<Tag>::type& get(
- BOOST_EXPLICIT_TEMPLATE_TYPE(Tag))const
+ const typename index<Tag>::type& get()const BOOST_NOEXCEPT
{
return *this;
}
@@ -356,11 +421,9 @@
};
template<int N,typename IteratorType>
- typename nth_index_iterator<N>::type project(
- IteratorType it
- BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+ typename nth_index_iterator<N>::type project(IteratorType it)
{
- typedef typename nth_index<N>::type index;
+ typedef typename nth_index<N>::type index_type;
#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
BOOST_STATIC_ASSERT(
@@ -371,15 +434,13 @@
BOOST_MULTI_INDEX_CHECK_IS_OWNER(
it,static_cast<typename IteratorType::container_type&>(*this));
- return index::make_iterator(static_cast<node_type*>(it.get_node()));
+ return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
}
template<int N,typename IteratorType>
- typename nth_index_const_iterator<N>::type project(
- IteratorType it
- BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const
+ typename nth_index_const_iterator<N>::type project(IteratorType it)const
{
- typedef typename nth_index<N>::type index;
+ typedef typename nth_index<N>::type index_type;
#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
BOOST_STATIC_ASSERT((
@@ -390,7 +451,7 @@
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
BOOST_MULTI_INDEX_CHECK_IS_OWNER(
it,static_cast<const typename IteratorType::container_type&>(*this));
- return index::make_iterator(static_cast<node_type*>(it.get_node()));
+ return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
}
#endif
@@ -410,11 +471,9 @@
};
template<typename Tag,typename IteratorType>
- typename index_iterator<Tag>::type project(
- IteratorType it
- BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
+ typename index_iterator<Tag>::type project(IteratorType it)
{
- typedef typename index<Tag>::type index;
+ typedef typename index<Tag>::type index_type;
#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
BOOST_STATIC_ASSERT(
@@ -424,15 +483,13 @@
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
BOOST_MULTI_INDEX_CHECK_IS_OWNER(
it,static_cast<typename IteratorType::container_type&>(*this));
- return index::make_iterator(static_cast<node_type*>(it.get_node()));
+ return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
}
template<typename Tag,typename IteratorType>
- typename index_const_iterator<Tag>::type project(
- IteratorType it
- BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))const
+ typename index_const_iterator<Tag>::type project(IteratorType it)const
{
- typedef typename index<Tag>::type index;
+ typedef typename index<Tag>::type index_type;
#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
BOOST_STATIC_ASSERT((
@@ -443,13 +500,26 @@
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
BOOST_MULTI_INDEX_CHECK_IS_OWNER(
it,static_cast<const typename IteratorType::container_type&>(*this));
- return index::make_iterator(static_cast<node_type*>(it.get_node()));
+ return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
}
#endif
BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
typedef typename super::copy_map_type copy_map_type;
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+ multi_index_container(
+ const multi_index_container<Value,IndexSpecifierList,Allocator>& x,
+ detail::do_not_copy_elements_tag):
+ bfm_allocator(x.bfm_allocator::member),
+ bfm_header(),
+ super(x,detail::do_not_copy_elements_tag()),
+ node_count(0)
+ {
+ BOOST_MULTI_INDEX_CHECK_INVARIANT;
+ }
+#endif
+
node_type* header()const
{
return &*bfm_header::member;
@@ -481,19 +551,53 @@
return static_cast<std::size_t >(-1);
}
+ template<typename Variant>
+ std::pair<node_type*,bool> insert_(const Value& v,Variant variant)
+ {
+ node_type* x=0;
+ node_type* res=super::insert_(v,x,variant);
+ if(res==x){
+ ++node_count;
+ return std::pair<node_type*,bool>(res,true);
+ }
+ else{
+ return std::pair<node_type*,bool>(res,false);
+ }
+ }
+
std::pair<node_type*,bool> insert_(const Value& v)
{
+ return insert_(v,detail::lvalue_tag());
+ }
+
+ std::pair<node_type*,bool> insert_rv_(const Value& v)
+ {
+ return insert_(v,detail::rvalue_tag());
+ }
+
+ template<typename T>
+ std::pair<node_type*,bool> insert_ref_(T& t)
+ {
node_type* x=allocate_node();
BOOST_TRY{
- node_type* res=super::insert_(v,x);
- if(res==x){
- ++node_count;
- return std::pair<node_type*,bool>(res,true);
+ new(&x->value()) value_type(t);
+ BOOST_TRY{
+ node_type* res=super::insert_(x->value(),x,detail::emplaced_tag());
+ if(res==x){
+ ++node_count;
+ return std::pair<node_type*,bool>(res,true);
+ }
+ else{
+ boost::detail::allocator::destroy(&x->value());
+ deallocate_node(x);
+ return std::pair<node_type*,bool>(res,false);
+ }
}
- else{
- deallocate_node(x);
- return std::pair<node_type*,bool>(res,false);
+ BOOST_CATCH(...){
+ boost::detail::allocator::destroy(&x->value());
+ BOOST_RETHROW;
}
+ BOOST_CATCH_END
}
BOOST_CATCH(...){
deallocate_node(x);
@@ -502,19 +606,99 @@
BOOST_CATCH_END
}
+ std::pair<node_type*,bool> insert_ref_(const value_type& x)
+ {
+ return insert_(x);
+ }
+
+ std::pair<node_type*,bool> insert_ref_(value_type& x)
+ {
+ return insert_(x);
+ }
+
+ template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+ std::pair<node_type*,bool> emplace_(
+ BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+ {
+ node_type* x=allocate_node();
+ BOOST_TRY{
+ detail::vartempl_placement_new(
+ &x->value(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+ BOOST_TRY{
+ node_type* res=super::insert_(x->value(),x,detail::emplaced_tag());
+ if(res==x){
+ ++node_count;
+ return std::pair<node_type*,bool>(res,true);
+ }
+ else{
+ boost::detail::allocator::destroy(&x->value());
+ deallocate_node(x);
+ return std::pair<node_type*,bool>(res,false);
+ }
+ }
+ BOOST_CATCH(...){
+ boost::detail::allocator::destroy(&x->value());
+ BOOST_RETHROW;
+ }
+ BOOST_CATCH_END
+ }
+ BOOST_CATCH(...){
+ deallocate_node(x);
+ BOOST_RETHROW;
+ }
+ BOOST_CATCH_END
+ }
+
+ template<typename Variant>
+ std::pair<node_type*,bool> insert_(
+ const Value& v,node_type* position,Variant variant)
+ {
+ node_type* x=0;
+ node_type* res=super::insert_(v,position,x,variant);
+ if(res==x){
+ ++node_count;
+ return std::pair<node_type*,bool>(res,true);
+ }
+ else{
+ return std::pair<node_type*,bool>(res,false);
+ }
+ }
+
std::pair<node_type*,bool> insert_(const Value& v,node_type* position)
{
+ return insert_(v,position,detail::lvalue_tag());
+ }
+
+ std::pair<node_type*,bool> insert_rv_(const Value& v,node_type* position)
+ {
+ return insert_(v,position,detail::rvalue_tag());
+ }
+
+ template<typename T>
+ std::pair<node_type*,bool> insert_ref_(
+ T& t,node_type* position)
+ {
node_type* x=allocate_node();
BOOST_TRY{
- node_type* res=super::insert_(v,position,x);
- if(res==x){
- ++node_count;
- return std::pair<node_type*,bool>(res,true);
+ new(&x->value()) value_type(t);
+ BOOST_TRY{
+ node_type* res=super::insert_(
+ x->value(),position,x,detail::emplaced_tag());
+ if(res==x){
+ ++node_count;
+ return std::pair<node_type*,bool>(res,true);
+ }
+ else{
+ boost::detail::allocator::destroy(&x->value());
+ deallocate_node(x);
+ return std::pair<node_type*,bool>(res,false);
+ }
}
- else{
- deallocate_node(x);
- return std::pair<node_type*,bool>(res,false);
+ BOOST_CATCH(...){
+ boost::detail::allocator::destroy(&x->value());
+ BOOST_RETHROW;
}
+ BOOST_CATCH_END
}
BOOST_CATCH(...){
deallocate_node(x);
@@ -523,6 +707,53 @@
BOOST_CATCH_END
}
+ std::pair<node_type*,bool> insert_ref_(
+ const value_type& x,node_type* position)
+ {
+ return insert_(x,position);
+ }
+
+ std::pair<node_type*,bool> insert_ref_(
+ value_type& x,node_type* position)
+ {
+ return insert_(x,position);
+ }
+
+ template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
+ std::pair<node_type*,bool> emplace_hint_(
+ node_type* position,
+ BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
+ {
+ node_type* x=allocate_node();
+ BOOST_TRY{
+ detail::vartempl_placement_new(
+ &x->value(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
+ BOOST_TRY{
+ node_type* res=super::insert_(
+ x->value(),position,x,detail::emplaced_tag());
+ if(res==x){
+ ++node_count;
+ return std::pair<node_type*,bool>(res,true);
+ }
+ else{
+ boost::detail::allocator::destroy(&x->value());
+ deallocate_node(x);
+ return std::pair<node_type*,bool>(res,false);
+ }
+ }
+ BOOST_CATCH(...){
+ boost::detail::allocator::destroy(&x->value());
+ BOOST_RETHROW;
+ }
+ BOOST_CATCH_END
+ }
+ BOOST_CATCH(...){
+ deallocate_node(x);
+ BOOST_RETHROW;
+ }
+ BOOST_CATCH_END
+ }
+
void erase_(node_type* x)
{
--node_count;
@@ -558,11 +789,24 @@
std::swap(node_count,x.node_count);
}
+ void swap_elements_(
+ multi_index_container<Value,IndexSpecifierList,Allocator>& x)
+ {
+ std::swap(bfm_header::member,x.bfm_header::member);
+ super::swap_elements_(x);
+ std::swap(node_count,x.node_count);
+ }
+
bool replace_(const Value& k,node_type* x)
{
- return super::replace_(k,x);
+ return super::replace_(k,x,detail::lvalue_tag());
}
+ bool replace_rv_(const Value& k,node_type* x)
+ {
+ return super::replace_(k,x,detail::rvalue_tag());
+ }
+
template<typename Modifier>
bool modify_(Modifier& mod,node_type* x)
{
@@ -585,7 +829,7 @@
}
template<typename Modifier,typename Rollback>
- bool modify_(Modifier& mod,Rollback& back,node_type* x)
+ bool modify_(Modifier& mod,Rollback& back_,node_type* x)
{
mod(const_cast<value_type&>(x->value()));
@@ -595,7 +839,7 @@
}
BOOST_CATCH(...){
BOOST_TRY{
- back(const_cast<value_type&>(x->value()));
+ back_(const_cast<value_type&>(x->value()));
BOOST_RETHROW;
}
BOOST_CATCH(...){
@@ -608,7 +852,7 @@
BOOST_TRY{
if(!b){
- back(const_cast<value_type&>(x->value()));
+ back_(const_cast<value_type&>(x->value()));
return false;
}
else return true;
@@ -633,17 +877,10 @@
template<class Archive>
void save(Archive& ar,const unsigned int version)const
{
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
const serialization::collection_size_type s(size_());
const detail::serialization_version<value_type> value_version;
ar<<serialization::make_nvp("count",s);
ar<<serialization::make_nvp("value_version",value_version);
-#else
- const std::size_t s=size_();
- const unsigned int value_version=0;
- ar<<serialization::make_nvp("count",s);
-#endif
index_saver_type sm(bfm_allocator::member,s);
@@ -663,8 +900,6 @@
BOOST_MULTI_INDEX_CHECK_INVARIANT;
clear_();
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
serialization::collection_size_type s;
detail::serialization_version<value_type> value_version;
if(version<1){
@@ -681,11 +916,6 @@
else{
ar>>serialization::make_nvp("value_version",value_version);
}
-#else
- std::size_t s;
- unsigned int value_version=0;
- ar>>serialization::make_nvp("count",s);
-#endif
index_loader_type lm(bfm_allocator::member,s);
@@ -728,6 +958,10 @@
#endif
};
+#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
+#pragma warning(pop) /* C4522 */
+#endif
+
/* retrieval of indices by number */
template<typename MultiIndexContainer,int N>
@@ -745,8 +979,7 @@
typename nth_index<
multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
get(
- multi_index_container<Value,IndexSpecifierList,Allocator>& m
- BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+ multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
{
typedef multi_index_container<
Value,IndexSpecifierList,Allocator> multi_index_type;
@@ -754,7 +987,7 @@
multi_index_container<
Value,IndexSpecifierList,Allocator>,
N
- >::type index;
+ >::type index_type;
BOOST_STATIC_ASSERT(N>=0&&
N<
@@ -762,7 +995,7 @@
BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
>::type::value);
- return detail::converter<multi_index_type,index>::index(m);
+ return detail::converter<multi_index_type,index_type>::index(m);
}
template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
@@ -770,7 +1003,7 @@
multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
get(
const multi_index_container<Value,IndexSpecifierList,Allocator>& m
- BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+)BOOST_NOEXCEPT
{
typedef multi_index_container<
Value,IndexSpecifierList,Allocator> multi_index_type;
@@ -778,7 +1011,7 @@
multi_index_container<
Value,IndexSpecifierList,Allocator>,
N
- >::type index;
+ >::type index_type;
BOOST_STATIC_ASSERT(N>=0&&
N<
@@ -786,7 +1019,7 @@
BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
>::type::value);
- return detail::converter<multi_index_type,index>::index(m);
+ return detail::converter<multi_index_type,index_type>::index(m);
}
/* retrieval of indices by tag */
@@ -814,8 +1047,7 @@
typename ::boost::multi_index::index<
multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
get(
- multi_index_container<Value,IndexSpecifierList,Allocator>& m
- BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
+ multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
{
typedef multi_index_container<
Value,IndexSpecifierList,Allocator> multi_index_type;
@@ -823,9 +1055,9 @@
multi_index_container<
Value,IndexSpecifierList,Allocator>,
Tag
- >::type index;
+ >::type index_type;
- return detail::converter<multi_index_type,index>::index(m);
+ return detail::converter<multi_index_type,index_type>::index(m);
}
template<
@@ -835,7 +1067,7 @@
multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
get(
const multi_index_container<Value,IndexSpecifierList,Allocator>& m
- BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
+)BOOST_NOEXCEPT
{
typedef multi_index_container<
Value,IndexSpecifierList,Allocator> multi_index_type;
@@ -843,9 +1075,9 @@
multi_index_container<
Value,IndexSpecifierList,Allocator>,
Tag
- >::type index;
+ >::type index_type;
- return detail::converter<multi_index_type,index>::index(m);
+ return detail::converter<multi_index_type,index_type>::index(m);
}
/* projection of iterators by number */
@@ -853,18 +1085,13 @@
template<typename MultiIndexContainer,int N>
struct nth_index_iterator
{
- typedef typename detail::prevent_eti<
- nth_index<MultiIndexContainer,N>,
- typename nth_index<MultiIndexContainer,N>::type>::type::iterator type;
+ typedef typename nth_index<MultiIndexContainer,N>::type::iterator type;
};
template<typename MultiIndexContainer,int N>
struct nth_index_const_iterator
{
- typedef typename detail::prevent_eti<
- nth_index<MultiIndexContainer,N>,
- typename nth_index<MultiIndexContainer,N>::type
- >::type::const_iterator type;
+ typedef typename nth_index<MultiIndexContainer,N>::type::const_iterator type;
};
template<
@@ -874,15 +1101,13 @@
multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
project(
multi_index_container<Value,IndexSpecifierList,Allocator>& m,
- IteratorType it
- BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+ IteratorType it)
{
typedef multi_index_container<
Value,IndexSpecifierList,Allocator> multi_index_type;
- typedef typename nth_index<multi_index_type,N>::type index;
+ typedef typename nth_index<multi_index_type,N>::type index_type;
-#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\
- (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
BOOST_STATIC_ASSERT((
mpl::contains<
BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
@@ -898,7 +1123,7 @@
BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
#endif
- return detail::converter<multi_index_type,index>::iterator(
+ return detail::converter<multi_index_type,index_type>::iterator(
m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
}
@@ -909,15 +1134,13 @@
multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
project(
const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
- IteratorType it
- BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+ IteratorType it)
{
typedef multi_index_container<
Value,IndexSpecifierList,Allocator> multi_index_type;
- typedef typename nth_index<multi_index_type,N>::type index;
+ typedef typename nth_index<multi_index_type,N>::type index_type;
-#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\
- (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
BOOST_STATIC_ASSERT((
mpl::contains<
BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
@@ -936,7 +1159,7 @@
BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
#endif
- return detail::converter<multi_index_type,index>::const_iterator(
+ return detail::converter<multi_index_type,index_type>::const_iterator(
m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
}
@@ -963,16 +1186,14 @@
multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
project(
multi_index_container<Value,IndexSpecifierList,Allocator>& m,
- IteratorType it
- BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
+ IteratorType it)
{
typedef multi_index_container<
Value,IndexSpecifierList,Allocator> multi_index_type;
typedef typename ::boost::multi_index::index<
- multi_index_type,Tag>::type index;
+ multi_index_type,Tag>::type index_type;
-#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\
- (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
BOOST_STATIC_ASSERT((
mpl::contains<
BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
@@ -988,7 +1209,7 @@
BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
#endif
- return detail::converter<multi_index_type,index>::iterator(
+ return detail::converter<multi_index_type,index_type>::iterator(
m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
}
@@ -999,16 +1220,14 @@
multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
project(
const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
- IteratorType it
- BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
+ IteratorType it)
{
typedef multi_index_container<
Value,IndexSpecifierList,Allocator> multi_index_type;
typedef typename ::boost::multi_index::index<
- multi_index_type,Tag>::type index;
+ multi_index_type,Tag>::type index_type;
-#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\
- (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
BOOST_STATIC_ASSERT((
mpl::contains<
BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
@@ -1027,7 +1246,7 @@
BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
#endif
- return detail::converter<multi_index_type,index>::const_iterator(
+ return detail::converter<multi_index_type,index_type>::const_iterator(
m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
}
@@ -1111,8 +1330,7 @@
} /* namespace multi_index */
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)&&\
- !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
/* class version = 1 : we now serialize the size through
* boost::serialization::collection_size_type.
* class version = 2 : proper use of {save|load}_construct_data.
@@ -1139,5 +1357,6 @@
} /* namespace boost */
#undef BOOST_MULTI_INDEX_CHECK_INVARIANT
+#undef BOOST_MULTI_INDEX_CHECK_INVARIANT_OF
#endif
Modified: trunk/Thirdparty/boost/boost/multi_index_container_fwd.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/multi_index_container_fwd.hpp 2015-12-10 13:11:27 \
UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/multi_index_container_fwd.hpp 2015-12-10 13:29:55 \
UTC (rev 7435) @@ -1,4 +1,4 @@
-/* Copyright 2003-2008 Joaquin M Lopez Munoz.
+/* Copyright 2003-2013 Joaquin M Lopez Munoz.
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
@@ -9,7 +9,7 @@
#ifndef BOOST_MULTI_INDEX_FWD_HPP
#define BOOST_MULTI_INDEX_FWD_HPP
-#if defined(_MSC_VER)&&(_MSC_VER>=1200)
+#if defined(_MSC_VER)
#pragma once
#endif
Modified: trunk/Thirdparty/boost/boost/next_prior.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/next_prior.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/next_prior.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -13,6 +13,17 @@
#define BOOST_NEXT_PRIOR_HPP_INCLUDED
#include <iterator>
+#if defined(_MSC_VER) && _MSC_VER <= 1310
+#include <boost/mpl/and.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#endif
+#include <boost/type_traits/is_unsigned.hpp>
+#include <boost/type_traits/integral_promotion.hpp>
+#include <boost/type_traits/make_signed.hpp>
+#include <boost/type_traits/has_plus.hpp>
+#include <boost/type_traits/has_plus_assign.hpp>
+#include <boost/type_traits/has_minus.hpp>
+#include <boost/type_traits/has_minus_assign.hpp>
namespace boost {
@@ -26,14 +37,118 @@
// Contributed by Dave Abrahams
+namespace next_prior_detail {
+
+template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance \
>::value > +struct next_impl2
+{
+ static T call(T x, Distance n)
+ {
+ std::advance(x, n);
+ return x;
+ }
+};
+
+template< typename T, typename Distance >
+struct next_impl2< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ return x + n;
+ }
+};
+
+
+template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, \
Distance >::value > +struct next_impl1 :
+ public next_impl2< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct next_impl1< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ x += n;
+ return x;
+ }
+};
+
+
+template<
+ typename T,
+ typename Distance,
+ typename PromotedDistance = typename integral_promotion< Distance >::type,
+#if !defined(_MSC_VER) || _MSC_VER > 1310
+ bool IsUInt = is_unsigned< PromotedDistance >::value
+#else
+ // MSVC 7.1 has problems with applying is_unsigned to non-integral types
+ bool IsUInt = mpl::and_< is_integral< PromotedDistance >, is_unsigned< \
PromotedDistance > >::value +#endif
+>
+struct prior_impl3
+{
+ static T call(T x, Distance n)
+ {
+ std::advance(x, -n);
+ return x;
+ }
+};
+
+template< typename T, typename Distance, typename PromotedDistance >
+struct prior_impl3< T, Distance, PromotedDistance, true >
+{
+ static T call(T x, Distance n)
+ {
+ typedef typename make_signed< PromotedDistance >::type signed_distance;
+ std::advance(x, -static_cast< signed_distance >(static_cast< \
PromotedDistance >(n))); + return x;
+ }
+};
+
+
+template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance \
>::value > +struct prior_impl2 :
+ public prior_impl3< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_impl2< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ return x - n;
+ }
+};
+
+
+template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, \
Distance >::value > +struct prior_impl1 :
+ public prior_impl2< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_impl1< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ x -= n;
+ return x;
+ }
+};
+
+} // namespace next_prior_detail
+
template <class T>
inline T next(T x) { return ++x; }
template <class T, class Distance>
inline T next(T x, Distance n)
{
- std::advance(x, n);
- return x;
+ return next_prior_detail::next_impl1< T, Distance >::call(x, n);
}
template <class T>
@@ -42,8 +157,7 @@
template <class T, class Distance>
inline T prior(T x, Distance n)
{
- std::advance(x, -n);
- return x;
+ return next_prior_detail::prior_impl1< T, Distance >::call(x, n);
}
} // namespace boost
Modified: trunk/Thirdparty/boost/boost/noncopyable.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/noncopyable.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/noncopyable.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -1,48 +1,17 @@
-// Boost noncopyable.hpp header file --------------------------------------//
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ */
-// (C) Copyright Beman Dawes 1999-2003. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_NONCOPYABLE_HPP
+#define BOOST_NONCOPYABLE_HPP
-// See http://www.boost.org/libs/utility for documentation.
+// The header file at this path is deprecated;
+// use boost/core/noncopyable.hpp instead.
-#ifndef BOOST_NONCOPYABLE_HPP_INCLUDED
-#define BOOST_NONCOPYABLE_HPP_INCLUDED
+#include <boost/core/noncopyable.hpp>
-#include <boost/config.hpp>
-
-namespace boost {
-
-// Private copy constructor and copy assignment ensure classes derived from
-// class noncopyable cannot be copied.
-
-// Contributed by Dave Abrahams
-
-namespace noncopyable_ // protection from unintended ADL
-{
- class noncopyable
- {
- protected:
-#ifndef BOOST_NO_DEFAULTED_FUNCTIONS
- BOOST_CONSTEXPR noncopyable() = default;
- ~noncopyable() = default;
-#else
- noncopyable() {}
- ~noncopyable() {}
#endif
-#ifndef BOOST_NO_DELETED_FUNCTIONS
- noncopyable( const noncopyable& ) = delete;
- noncopyable& operator=( const noncopyable& ) = delete;
-#else
- private: // emphasize the following members are private
- noncopyable( const noncopyable& );
- noncopyable& operator=( const noncopyable& );
-#endif
- };
-}
-
-typedef noncopyable_::noncopyable noncopyable;
-
-} // namespace boost
-
-#endif // BOOST_NONCOPYABLE_HPP_INCLUDED
Modified: trunk/Thirdparty/boost/boost/nondet_random.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/nondet_random.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/nondet_random.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -5,7 +5,7 @@
* accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
- * $Id: nondet_random.hpp 71018 2011-04-05 21:27:52Z steven_watanabe $
+ * $Id$
*
* Revision history
* 2000-02-18 Portability fixes (thanks to Beman Dawes)
Modified: trunk/Thirdparty/boost/boost/none.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/none.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/none.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -1,4 +1,5 @@
// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2014 Andrzej Krzemienski.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -20,8 +21,32 @@
namespace boost {
+#ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
none_t const none = (static_cast<none_t>(0)) ;
+#else
+namespace detail { namespace optional_detail {
+
+ // the trick here is to make boost::none defined once as a global but in a header \
file + template <typename T>
+ struct none_instance
+ {
+ static const T instance;
+ };
+
+ template <typename T>
+ const T none_instance<T>::instance = T(); // global, but because 'tis a template, \
no cpp file required +
+} } // namespace detail::optional_detail
+
+
+namespace {
+ // TU-local
+ const none_t& none = detail::optional_detail::none_instance<none_t>::instance;
+}
+
+#endif
+
} // namespace boost
#endif
Modified: trunk/Thirdparty/boost/boost/none_t.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/none_t.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/none_t.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -1,4 +1,5 @@
// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2014 Andrzej Krzemienski.
//
// Use, modification, and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -14,9 +15,12 @@
namespace boost {
+#ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
namespace detail { struct none_helper{}; }
-
typedef int detail::none_helper::*none_t ;
+#else
+class none_t {};
+#endif
} // namespace boost
Modified: trunk/Thirdparty/boost/boost/operators.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/operators.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/operators.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -97,15 +97,8 @@
namespace boost {
namespace detail {
-template <typename T> class empty_base {
+template <typename T> class empty_base {};
-// Helmut Zeisel, empty base class optimization bug with GCC 3.0.0
-#if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0
- bool dummy;
-#endif
-
-};
-
} // namespace detail
} // namespace boost
@@ -711,7 +704,6 @@
// the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
// necessary.
//
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
// is_chained_base<> - a traits class used to distinguish whether an operator
// template argument is being used for base class chaining, or is specifying a
@@ -809,25 +801,7 @@
BOOST_OPERATOR_TEMPLATE1(template_name##1)
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-# define BOOST_OPERATOR_TEMPLATE4(template_name4) \
- BOOST_IMPORT_TEMPLATE4(template_name4)
-# define BOOST_OPERATOR_TEMPLATE3(template_name3) \
- BOOST_IMPORT_TEMPLATE3(template_name3)
-# define BOOST_OPERATOR_TEMPLATE2(template_name2) \
- BOOST_IMPORT_TEMPLATE2(template_name2)
-# define BOOST_OPERATOR_TEMPLATE1(template_name1) \
- BOOST_IMPORT_TEMPLATE1(template_name1)
-
- // In this case we can only assume that template_name<> is equivalent to the
- // more commonly needed template_name1<> form.
-# define BOOST_OPERATOR_TEMPLATE(template_name) \
- template <class T, class B = ::boost::detail::empty_base<T> > \
- struct template_name : template_name##1<T, B> {};
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
namespace boost {
BOOST_OPERATOR_TEMPLATE(less_than_comparable)
@@ -897,14 +871,10 @@
, bitwise2<T,U
> > > {};
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <class T, class U = T>
struct operators : operators2<T, U> {};
template <class T> struct operators<T, T>
-#else
-template <class T> struct operators
-#endif
: totally_ordered<T
, integer_arithmetic<T
, bitwise<T
Modified: trunk/Thirdparty/boost/boost/pointee.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/pointee.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/pointee.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -20,7 +20,7 @@
# include <boost/mpl/if.hpp>
# include <boost/mpl/eval_if.hpp>
-namespace boost {
+namespace boost {
namespace detail
{
@@ -34,25 +34,25 @@
struct iterator_pointee
{
typedef typename iterator_traits<Iterator>::value_type value_type;
-
+
struct impl
{
template <class T>
static char test(T const&);
-
+
static char (& test(value_type&) )[2];
-
+
static Iterator& x;
};
-
+
BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1);
-
+
typedef typename mpl::if_c<
# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
::boost::detail::iterator_pointee<Iterator>::is_constant
# else
is_constant
-# endif
+# endif
, typename add_const<value_type>::type
, value_type
>::type type;
@@ -68,7 +68,7 @@
>
{
};
-
+
} // namespace boost
#endif // POINTEE_DWA200415_HPP
Copied: trunk/Thirdparty/boost/boost/polymorphic_cast.hpp (from rev 7307, \
sandbox/v140/Thirdparty/boost/boost/polymorphic_cast.hpp) \
===================================================================
--- trunk/Thirdparty/boost/boost/polymorphic_cast.hpp (rev 0)
+++ trunk/Thirdparty/boost/boost/polymorphic_cast.hpp 2015-12-10 13:29:55 UTC (rev \
7435) @@ -0,0 +1,100 @@
+// boost polymorphic_cast.hpp header file \
----------------------------------------------// +
+// (C) Copyright Kevlin Henney and Dave Abrahams 1999.
+// (C) Copyright Boris Rasin 2014.
+// Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org/libs/conversion for Documentation.
+
+// Revision History
+// 10 Nov 14 polymorphic_pointer_downcast moved to a separate header,
+// minor improvements to stisfy latest Boost coding style
+// 08 Nov 14 Add polymorphic_pointer_downcast (Boris Rasin)
+// 09 Jun 14 "cast.hpp" was renamed to "polymorphic_cast.hpp" and
+// inclusion of numeric_cast was removed (Antony Polukhin)
+// 23 Jun 05 numeric_cast removed and redirected to the new verion (Fernando \
Cacciola) +// 02 Apr 01 Removed BOOST_NO_LIMITS workarounds and included
+// <boost/limits.hpp> instead (the workaround did not
+// actually compile when BOOST_NO_LIMITS was defined in
+// any case, so we loose nothing). (John Maddock)
+// 21 Jan 01 Undid a bug I introduced yesterday. numeric_cast<> never
+// worked with stock GCC; trying to get it to do that broke
+// vc-stlport.
+// 20 Jan 01 Moved BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS to config.hpp.
+// Removed unused BOOST_EXPLICIT_TARGET macro. Moved
+// boost::detail::type to boost/type.hpp. Made it compile with
+// stock gcc again (Dave Abrahams)
+// 29 Nov 00 Remove nested namespace cast, cleanup spacing before Formal
+// Review (Beman Dawes)
+// 19 Oct 00 Fix numeric_cast for floating-point types (Dave Abrahams)
+// 15 Jul 00 Suppress numeric_cast warnings for GCC, Borland and MSVC
+// (Dave Abrahams)
+// 30 Jun 00 More MSVC6 wordarounds. See comments below. (Dave Abrahams)
+// 28 Jun 00 Removed implicit_cast<>. See comment below. (Beman Dawes)
+// 27 Jun 00 More MSVC6 workarounds
+// 15 Jun 00 Add workarounds for MSVC6
+// 2 Feb 00 Remove bad_numeric_cast ";" syntax error (Doncho Angelov)
+// 26 Jan 00 Add missing throw() to bad_numeric_cast::what(0 (Adam Levar)
+// 29 Dec 99 Change using declarations so usages in other namespaces work
+// correctly (Dave Abrahams)
+// 23 Sep 99 Change polymorphic_downcast assert to also detect M.I. errors
+// as suggested Darin Adler and improved by Valentin Bonnard.
+// 2 Sep 99 Remove controversial asserts, simplify, rename.
+// 30 Aug 99 Move to cast.hpp, replace value_cast with numeric_cast,
+// place in nested namespace.
+// 3 Aug 99 Initial version
+
+#ifndef BOOST_POLYMORPHIC_CAST_HPP
+#define BOOST_POLYMORPHIC_CAST_HPP
+
+# include <boost/config.hpp>
+# include <boost/assert.hpp>
+# include <boost/throw_exception.hpp>
+# include <typeinfo>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost
+{
+// See the documentation for descriptions of how to choose between
+// static_cast<>, dynamic_cast<>, polymorphic_cast<> and polymorphic_downcast<>
+
+// polymorphic_cast --------------------------------------------------------//
+
+ // Runtime checked polymorphic downcasts and crosscasts.
+ // Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup,
+ // section 15.8 exercise 1, page 425.
+
+ template <class Target, class Source>
+ inline Target polymorphic_cast(Source* x)
+ {
+ Target tmp = dynamic_cast<Target>(x);
+ if ( tmp == 0 ) boost::throw_exception( std::bad_cast() );
+ return tmp;
+ }
+
+// polymorphic_downcast ----------------------------------------------------//
+
+ // BOOST_ASSERT() checked polymorphic downcast. Crosscasts prohibited.
+
+ // WARNING: Because this cast uses BOOST_ASSERT(), it violates
+ // the One Definition Rule if used in multiple translation units
+ // where BOOST_DISABLE_ASSERTS, BOOST_ENABLE_ASSERT_HANDLER
+ // NDEBUG are defined inconsistently.
+
+ // Contributed by Dave Abrahams
+
+ template <class Target, class Source>
+ inline Target polymorphic_downcast(Source* x)
+ {
+ BOOST_ASSERT( dynamic_cast<Target>(x) == x ); // detect logic error
+ return static_cast<Target>(x);
+ }
+
+} // namespace boost
+
+#endif // BOOST_POLYMORPHIC_CAST_HPP
Copied: trunk/Thirdparty/boost/boost/polymorphic_pointer_cast.hpp (from rev 7307, \
sandbox/v140/Thirdparty/boost/boost/polymorphic_pointer_cast.hpp) \
===================================================================
--- trunk/Thirdparty/boost/boost/polymorphic_pointer_cast.hpp \
(rev 0)
+++ trunk/Thirdparty/boost/boost/polymorphic_pointer_cast.hpp 2015-12-10 13:29:55 UTC \
(rev 7435) @@ -0,0 +1,78 @@
+// boost polymorphic_pointer_cast.hpp header file \
----------------------------------------------// +// (C) Copyright Boris Rasin and \
Antony Polukhin 2014-2015. +// Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org/libs/conversion for Documentation.
+
+#ifndef BOOST_CONVERSION_POLYMORPHIC_POINTER_CAST_HPP
+#define BOOST_CONVERSION_POLYMORPHIC_POINTER_CAST_HPP
+
+# include <boost/config.hpp>
+# include <boost/assert.hpp>
+# include <boost/pointer_cast.hpp>
+# include <boost/throw_exception.hpp>
+# include <boost/utility/declval.hpp>
+# ifdef BOOST_NO_CXX11_DECLTYPE
+# include <boost/typeof/typeof.hpp>
+# endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost
+{
+// See the documentation for descriptions of how to choose between
+// static_pointer_cast<>, dynamic_pointer_cast<>, polymorphic_pointer_cast<> and \
polymorphic_pointer_downcast<> +
+// polymorphic_pointer_downcast --------------------------------------------//
+
+ // BOOST_ASSERT() checked polymorphic downcast. Crosscasts prohibited.
+ // Supports any type with static_pointer_cast/dynamic_pointer_cast functions:
+ // built-in pointers, std::shared_ptr, boost::shared_ptr, boost::intrusive_ptr, \
etc. +
+ // WARNING: Because this cast uses BOOST_ASSERT(), it violates
+ // the One Definition Rule if used in multiple translation units
+ // where BOOST_DISABLE_ASSERTS, BOOST_ENABLE_ASSERT_HANDLER
+ // NDEBUG are defined inconsistently.
+
+ // Contributed by Boris Rasin
+
+ namespace detail
+ {
+ template <typename Target, typename Source>
+ struct dynamic_pointer_cast_result
+ {
+#ifdef BOOST_NO_CXX11_DECLTYPE
+ BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, \
dynamic_pointer_cast<Target>(boost::declval<Source>())) + typedef typename \
nested::type type; +#else
+ typedef decltype(dynamic_pointer_cast<Target>(boost::declval<Source>())) \
type; +#endif
+ };
+ }
+
+ template <typename Target, typename Source>
+ inline typename detail::dynamic_pointer_cast_result<Target, Source>::type
+ polymorphic_pointer_downcast (const Source& x)
+ {
+ BOOST_ASSERT(dynamic_pointer_cast<Target> (x) == x);
+ return static_pointer_cast<Target> (x);
+ }
+
+ template <typename Target, typename Source>
+ inline typename detail::dynamic_pointer_cast_result<Target, Source>::type
+ polymorphic_pointer_cast (const Source& x)
+ {
+ typename detail::dynamic_pointer_cast_result<Target, Source>::type tmp
+ = dynamic_pointer_cast<Target> (x);
+ if ( !tmp ) boost::throw_exception( std::bad_cast() );
+
+ return tmp;
+ }
+
+} // namespace boost
+
+#endif // BOOST_CONVERSION_POLYMORPHIC_POINTER_CAST_HPP
Copied: trunk/Thirdparty/boost/boost/predef.h (from rev 7307, \
sandbox/v140/Thirdparty/boost/boost/predef.h) \
===================================================================
--- trunk/Thirdparty/boost/boost/predef.h (rev 0)
+++ trunk/Thirdparty/boost/boost/predef.h 2015-12-10 13:29:55 UTC (rev 7435)
@@ -0,0 +1,23 @@
+/*
+Copyright Rene Rivera 2008-2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#if !defined(BOOST_PREDEF_H) || defined(BOOST_PREDEF_INTERNAL_GENERATE_TESTS)
+#ifndef BOOST_PREDEF_H
+#define BOOST_PREDEF_H
+#endif
+
+#include <boost/predef/language.h>
+#include <boost/predef/architecture.h>
+#include <boost/predef/compiler.h>
+#include <boost/predef/library.h>
+#include <boost/predef/os.h>
+#include <boost/predef/other.h>
+#include <boost/predef/platform.h>
+
+#include <boost/predef/version.h>
+
+#endif
Modified: trunk/Thirdparty/boost/boost/preprocessor.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/preprocessor.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/preprocessor.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -7,7 +7,7 @@
# * http://www.boost.org/LICENSE_1_0.txt)
# */
#
-# /* Revised by Paul Mensonides (2002) */
+# /* Revised by Paul Mensonides (2002) */
#
# /* See http://www.boost.org/libs/preprocessor for documentation. */
#
Modified: trunk/Thirdparty/boost/boost/program_options.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/program_options.hpp 2015-12-10 13:11:27 UTC (rev \
7434)
+++ trunk/Thirdparty/boost/boost/program_options.hpp 2015-12-10 13:29:55 UTC (rev \
7435) @@ -8,7 +8,7 @@
#ifndef PROGRAM_OPTIONS_VP_2003_05_19
#define PROGRAM_OPTIONS_VP_2003_05_19
-#if _MSC_VER >= 1020
+#if defined(_MSC_VER)
#pragma once
#endif
Modified: trunk/Thirdparty/boost/boost/progress.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/progress.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/progress.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -20,7 +20,7 @@
#define BOOST_PROGRESS_HPP
#include <boost/timer.hpp>
-#include <boost/utility.hpp> // for noncopyable
+#include <boost/noncopyable.hpp>
#include <boost/cstdint.hpp> // for uintmax_t
#include <iostream> // for ostream, cout, etc
#include <string> // for string
@@ -38,7 +38,7 @@
public:
explicit progress_timer( std::ostream & os = std::cout )
// os is hint; implementation may ignore, particularly in embedded systems
- : m_os(os) {}
+ : timer(), noncopyable(), m_os(os) {}
~progress_timer()
{
// A) Throwing an exception from a destructor is a Bad Thing.
@@ -77,20 +77,20 @@
class progress_display : private noncopyable
{
public:
- explicit progress_display( unsigned long expected_count,
+ explicit progress_display( unsigned long expected_count_,
std::ostream & os = std::cout,
const std::string & s1 = "\n", //leading strings
const std::string & s2 = "",
const std::string & s3 = "" )
// os is hint; implementation may ignore, particularly in embedded systems
- : m_os(os), m_s1(s1), m_s2(s2), m_s3(s3) { restart(expected_count); }
+ : noncopyable(), m_os(os), m_s1(s1), m_s2(s2), m_s3(s3) { \
restart(expected_count_); }
- void restart( unsigned long expected_count )
+ void restart( unsigned long expected_count_ )
// Effects: display appropriate scale
- // Postconditions: count()==0, expected_count()==expected_count
+ // Postconditions: count()==0, expected_count()==expected_count_
{
_count = _next_tic_count = _tic = 0;
- _expected_count = expected_count;
+ _expected_count = expected_count_;
m_os << m_s1 << "0% 10 20 30 40 50 60 70 80 90 100%\n"
<< m_s2 << "|----|----|----|----|----|----|----|----|----|----|"
Modified: trunk/Thirdparty/boost/boost/python.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/python.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/python.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -53,6 +53,7 @@
# include <boost/python/pointee.hpp>
# include <boost/python/pure_virtual.hpp>
# include <boost/python/ptr.hpp>
+# include <boost/python/raw_function.hpp>
# include <boost/python/reference_existing_object.hpp>
# include <boost/python/register_ptr_to_python.hpp>
# include <boost/python/return_arg.hpp>
@@ -61,7 +62,9 @@
# include <boost/python/return_value_policy.hpp>
# include <boost/python/scope.hpp>
# include <boost/python/self.hpp>
+# include <boost/python/slice.hpp>
# include <boost/python/slice_nil.hpp>
+# include <boost/python/stl_iterator.hpp>
# include <boost/python/str.hpp>
# include <boost/python/to_python_converter.hpp>
# include <boost/python/to_python_indirect.hpp>
Modified: trunk/Thirdparty/boost/boost/random.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/random.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/random.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -7,7 +7,7 @@
*
* See http://www.boost.org/libs/random for documentation.
*
- * $Id: random.hpp 71018 2011-04-05 21:27:52Z steven_watanabe $
+ * $Id$
*
* Revision history
* 2000-02-18 portability fixes (thanks to Beman Dawes)
@@ -67,6 +67,7 @@
#include <boost/random/geometric_distribution.hpp>
#include <boost/random/lognormal_distribution.hpp>
#include <boost/random/negative_binomial_distribution.hpp>
+#include <boost/random/non_central_chi_squared_distribution.hpp>
#include <boost/random/normal_distribution.hpp>
#include <boost/random/piecewise_constant_distribution.hpp>
#include <boost/random/piecewise_linear_distribution.hpp>
Modified: trunk/Thirdparty/boost/boost/range.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/range.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/range.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -11,23 +11,13 @@
#ifndef BOOST_RANGE_HPP_27_07_04
#define BOOST_RANGE_HPP_27_07_04
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
-#if _MSC_VER == 1300 // experiment
-
-#include <boost/range/detail/collection_traits.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/range/sub_range.hpp>
-
-#else
-
#include <boost/range/functions.hpp>
#include <boost/range/metafunctions.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/sub_range.hpp>
-#endif // _MSC_VER == 1300 // experiment
-
#endif
Modified: trunk/Thirdparty/boost/boost/rational.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/rational.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/rational.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -21,6 +21,15 @@
// Nickolay Mladenov, for the implementation of operator+=
// Revision History
+// 02 Sep 13 Remove unneeded forward declarations; tweak private helper
+// function (Daryle Walker)
+// 30 Aug 13 Improve exception safety of "assign"; start modernizing I/O code
+// (Daryle Walker)
+// 27 Aug 13 Add cross-version constructor template, plus some private helper
+// functions; add constructor to exception class to take custom
+// messages (Daryle Walker)
+// 25 Aug 13 Add constexpr qualification wherever possible (Daryle Walker)
+// 05 May 12 Reduced use of implicit gcd (Mario Lang)
// 05 Nov 06 Change rational_cast to not depend on division between different
// types (Daryle Walker)
// 04 Nov 06 Off-load GCD and LCM to Boost.Math; add some invariant checks;
@@ -28,9 +37,9 @@
// 31 Oct 06 Recoded both operator< to use round-to-negative-infinity
// divisions; the rational-value version now uses continued fraction
// expansion to avoid overflows, for bug #798357 (Daryle Walker)
-// 20 Oct 06 Fix operator bool_type for CW 8.3 (Joaquín M López Muñoz)
+// 20 Oct 06 Fix operator bool_type for CW 8.3 (JoaquÃn M López Muñoz)
// 18 Oct 06 Use EXPLICIT_TEMPLATE_TYPE helper macros from Boost.Config
-// (Joaquín M López Muñoz)
+// (JoaquÃn M López Muñoz)
// 27 Dec 05 Add Boolean conversion operator (Daryle Walker)
// 28 Sep 02 Use _left versions of operators from operators.hpp
// 05 Jul 01 Recode gcd(), avoiding std::swap (Helmut Zeisel)
@@ -54,17 +63,23 @@
#ifndef BOOST_RATIONAL_HPP
#define BOOST_RATIONAL_HPP
-#include <iostream> // for std::istream and std::ostream
-#include <ios> // for std::noskipws
+#include <boost/config.hpp> // for BOOST_NO_STDC_NAMESPACE, BOOST_MSVC, etc
+#ifndef BOOST_NO_IOSTREAM
+#include <iomanip> // for std::setw
+#include <ios> // for std::noskipws, streamsize
+#include <istream> // for std::istream
+#include <ostream> // for std::ostream
+#include <sstream> // for std::ostringstream
+#endif
+#include <cstddef> // for NULL
#include <stdexcept> // for std::domain_error
#include <string> // for std::string implicit constructor
#include <boost/operators.hpp> // for boost::addable etc
#include <cstdlib> // for std::abs
#include <boost/call_traits.hpp> // for boost::call_traits
-#include <boost/config.hpp> // for BOOST_NO_STDC_NAMESPACE, BOOST_MSVC
#include <boost/detail/workaround.hpp> // for BOOST_WORKAROUND
#include <boost/assert.hpp> // for BOOST_ASSERT
-#include <boost/math/common_factor_rt.hpp> // for boost::math::gcd, lcm
+#include <boost/integer/common_factor_rt.hpp> // for boost::integer::gcd, lcm
#include <limits> // for std::numeric_limits
#include <boost/static_assert.hpp> // for BOOST_STATIC_ASSERT
@@ -80,14 +95,14 @@
IntType gcd(IntType n, IntType m)
{
// Defer to the version in Boost.Math
- return math::gcd( n, m );
+ return integer::gcd( n, m );
}
template <typename IntType>
IntType lcm(IntType n, IntType m)
{
// Defer to the version in Boost.Math
- return math::lcm( n, m );
+ return integer::lcm( n, m );
}
#endif // BOOST_CONTROL_RATIONAL_HAS_GCD
@@ -95,15 +110,10 @@
{
public:
explicit bad_rational() : std::domain_error("bad rational: zero denominator") {}
+ explicit bad_rational( char const *what ) : std::domain_error( what ) {}
};
template <typename IntType>
-class rational;
-
-template <typename IntType>
-rational<IntType> abs(const rational<IntType>& r);
-
-template <typename IntType>
class rational :
less_than_comparable < rational<IntType>,
equality_comparable < rational<IntType>,
@@ -133,21 +143,37 @@
typedef IntType (helper::* bool_type)[2];
public:
+ // Component type
typedef IntType int_type;
+
+ BOOST_CONSTEXPR
rational() : num(0), den(1) {}
+ BOOST_CONSTEXPR
rational(param_type n) : num(n), den(1) {}
rational(param_type n, param_type d) : num(n), den(d) { normalize(); }
+#ifndef BOOST_NO_MEMBER_TEMPLATES
+ template < typename NewType >
+ BOOST_CONSTEXPR explicit
+ rational( rational<NewType> const &r )
+ : num( r.numerator() ), den( is_normalized(int_type( r.numerator() ),
+ int_type( r.denominator() )) ? r.denominator() :
+ throw bad_rational("bad rational: denormalized conversion") )
+ {}
+#endif
+
// Default copy constructor and assignment are fine
// Add assignment from IntType
- rational& operator=(param_type n) { return assign(n, 1); }
+ rational& operator=(param_type i) { num = i; den = 1; return *this; }
// Assign in place
rational& assign(param_type n, param_type d);
// Access to representation
+ BOOST_CONSTEXPR
IntType numerator() const { return num; }
+ BOOST_CONSTEXPR
IntType denominator() const { return den; }
// Arithmetic assignment operators
@@ -156,16 +182,17 @@
rational& operator*= (const rational& r);
rational& operator/= (const rational& r);
- rational& operator+= (param_type i);
- rational& operator-= (param_type i);
+ rational& operator+= (param_type i) { num += i * den; return *this; }
+ rational& operator-= (param_type i) { num -= i * den; return *this; }
rational& operator*= (param_type i);
rational& operator/= (param_type i);
// Increment and decrement
- const rational& operator++();
- const rational& operator--();
+ const rational& operator++() { num += den; return *this; }
+ const rational& operator--() { num -= den; return *this; }
// Operator not
+ BOOST_CONSTEXPR
bool operator!() const { return !num; }
// Boolean conversion
@@ -177,6 +204,7 @@
#pragma parse_mfunc_templ off
#endif
+ BOOST_CONSTEXPR
operator bool_type() const { return operator !() ? 0 : &helper::parts; }
#if BOOST_WORKAROUND(__MWERKS__,<=0x3003)
@@ -185,10 +213,12 @@
// Comparison operators
bool operator< (const rational& r) const;
+ BOOST_CONSTEXPR
bool operator== (const rational& r) const;
bool operator< (param_type i) const;
bool operator> (param_type i) const;
+ BOOST_CONSTEXPR
bool operator== (param_type i) const;
private:
@@ -197,26 +227,42 @@
IntType num;
IntType den;
+ // Helper functions
+ static BOOST_CONSTEXPR
+ int_type inner_gcd( param_type a, param_type b, int_type const &zero =
+ int_type(0) )
+ { return b == zero ? a : inner_gcd(b, a % b, zero); }
+
+ static BOOST_CONSTEXPR
+ int_type inner_abs( param_type x, int_type const &zero = int_type(0) )
+ { return x < zero ? -x : +x; }
+
// Representation note: Fractions are kept in normalized form at all
// times. normalized form is defined as gcd(num,den) == 1 and den > 0.
// In particular, note that the implementation of abs() below relies
// on den always being positive.
bool test_invariant() const;
void normalize();
+
+ static BOOST_CONSTEXPR
+ bool is_normalized( param_type n, param_type d, int_type const &zero =
+ int_type(0), int_type const &one = int_type(1) )
+ {
+ return d > zero && ( n != zero || d == one ) && inner_abs( inner_gcd(n,
+ d, zero), zero ) == one;
+ }
};
// Assign in place
template <typename IntType>
inline rational<IntType>& rational<IntType>::assign(param_type n, param_type d)
{
- num = n;
- den = d;
- normalize();
- return *this;
+ return *this = rational( n, d );
}
// Unary plus and minus
template <typename IntType>
+BOOST_CONSTEXPR
inline rational<IntType> operator+ (const rational<IntType>& r)
{
return r;
@@ -254,10 +300,10 @@
IntType r_num = r.num;
IntType r_den = r.den;
- IntType g = math::gcd(den, r_den);
+ IntType g = integer::gcd(den, r_den);
den /= g; // = b1 from the calculations above
num = num * (r_den / g) + r_num * den;
- g = math::gcd(num, g);
+ g = integer::gcd(num, g);
num /= g;
den *= r_den/g;
@@ -273,10 +319,10 @@
// This calculation avoids overflow, and minimises the number of expensive
// calculations. It corresponds exactly to the += case above
- IntType g = math::gcd(den, r_den);
+ IntType g = integer::gcd(den, r_den);
den /= g;
num = num * (r_den / g) - r_num * den;
- g = math::gcd(num, g);
+ g = integer::gcd(num, g);
num /= g;
den *= r_den/g;
@@ -291,8 +337,8 @@
IntType r_den = r.den;
// Avoid overflow and preserve normalization
- IntType gcd1 = math::gcd(num, r_den);
- IntType gcd2 = math::gcd(r_num, den);
+ IntType gcd1 = integer::gcd(num, r_den);
+ IntType gcd2 = integer::gcd(r_num, den);
num = (num/gcd1) * (r_num/gcd2);
den = (den/gcd2) * (r_den/gcd1);
return *this;
@@ -315,8 +361,8 @@
return *this;
// Avoid overflow and preserve normalization
- IntType gcd1 = math::gcd(num, r_num);
- IntType gcd2 = math::gcd(r_den, den);
+ IntType gcd1 = integer::gcd(num, r_num);
+ IntType gcd2 = integer::gcd(r_den, den);
num = (num/gcd1) * (r_den/gcd2);
den = (den/gcd2) * (r_num/gcd1);
@@ -330,46 +376,36 @@
// Mixed-mode operators
template <typename IntType>
inline rational<IntType>&
-rational<IntType>::operator+= (param_type i)
+rational<IntType>::operator*= (param_type i)
{
- return operator+= (rational<IntType>(i));
-}
+ // Avoid overflow and preserve normalization
+ IntType gcd = integer::gcd(i, den);
+ num *= i / gcd;
+ den /= gcd;
-template <typename IntType>
-inline rational<IntType>&
-rational<IntType>::operator-= (param_type i)
-{
- return operator-= (rational<IntType>(i));
+ return *this;
}
template <typename IntType>
-inline rational<IntType>&
-rational<IntType>::operator*= (param_type i)
-{
- return operator*= (rational<IntType>(i));
-}
-
-template <typename IntType>
-inline rational<IntType>&
+rational<IntType>&
rational<IntType>::operator/= (param_type i)
{
- return operator/= (rational<IntType>(i));
-}
+ // Avoid repeated construction
+ IntType const zero(0);
-// Increment and decrement
-template <typename IntType>
-inline const rational<IntType>& rational<IntType>::operator++()
-{
- // This can never denormalise the fraction
- num += den;
- return *this;
-}
+ if (i == zero) throw bad_rational();
+ if (num == zero) return *this;
-template <typename IntType>
-inline const rational<IntType>& rational<IntType>::operator--()
-{
- // This can never denormalise the fraction
- num -= den;
+ // Avoid overflow and preserve normalization
+ IntType const gcd = integer::gcd(num, i);
+ num /= gcd;
+ den *= i / gcd;
+
+ if (den < zero) {
+ num = -num;
+ den = -den;
+ }
+
return *this;
}
@@ -389,9 +425,11 @@
// Determine relative order by expanding each value to its simple continued
// fraction representation using the Euclidian GCD algorithm.
- struct { int_type n, d, q, r; } ts = { this->num, this->den, this->num /
- this->den, this->num % this->den }, rs = { r.num, r.den, r.num / r.den,
- r.num % r.den };
+ struct { int_type n, d, q, r; }
+ ts = { this->num, this->den, static_cast<int_type>(this->num / this->den),
+ static_cast<int_type>(this->num % this->den) },
+ rs = { r.num, r.den, static_cast<int_type>(r.num / r.den),
+ static_cast<int_type>(r.num % r.den) };
unsigned reverse = 0u;
// Normalize negative moduli by repeatedly adding the (positive) denominator
@@ -403,7 +441,7 @@
while ( rs.r < zero ) { rs.r += rs.d; --rs.q; }
// Loop through and compare each variable's continued-fraction components
- while ( true )
+ for ( ;; )
{
// The quotients of the current cycle are the continued-fraction
// components. Comparing two c.f. is comparing their sequences,
@@ -477,21 +515,18 @@
template <typename IntType>
bool rational<IntType>::operator> (param_type i) const
{
- // Trap equality first
- if (num == i && den == IntType(1))
- return false;
-
- // Otherwise, we can use operator<
- return !operator<(i);
+ return operator==(i)? false: !operator<(i);
}
template <typename IntType>
+BOOST_CONSTEXPR
inline bool rational<IntType>::operator== (const rational<IntType>& r) const
{
return ((num == r.num) && (den == r.den));
}
template <typename IntType>
+BOOST_CONSTEXPR
inline bool rational<IntType>::operator== (param_type i) const
{
return ((den == IntType(1)) && (num == i));
@@ -501,7 +536,7 @@
template <typename IntType>
inline bool rational<IntType>::test_invariant() const
{
- return ( this->den > int_type(0) ) && ( math::gcd(this->num, this->den) ==
+ return ( this->den > int_type(0) ) && ( integer::gcd(this->num, this->den) ==
int_type(1) );
}
@@ -521,7 +556,7 @@
return;
}
- IntType g = math::gcd(num, den);
+ IntType g = integer::gcd(num, den);
num /= g;
den /= g;
@@ -532,9 +567,17 @@
den = -den;
}
+ // ...But acknowledge that the previous step doesn't always work.
+ // (Nominally, this should be done before the mutating steps, but this
+ // member function is only called during the constructor, so we never have
+ // to worry about zombie objects.)
+ if (den < zero)
+ throw bad_rational( "bad rational: non-zero singular denominator" );
+
BOOST_ASSERT( this->test_invariant() );
}
+#ifndef BOOST_NO_IOSTREAM
namespace detail {
// A utility class to reset the format flags for an istream at end
@@ -552,26 +595,34 @@
template <typename IntType>
std::istream& operator>> (std::istream& is, rational<IntType>& r)
{
+ using std::ios;
+
IntType n = IntType(0), d = IntType(1);
char c = 0;
detail::resetter sentry(is);
- is >> n;
- c = is.get();
+ if ( is >> n )
+ {
+ if ( is.get(c) )
+ {
+ if ( c == '/' )
+ {
+ if ( is >> std::noskipws >> d )
+ try {
+ r.assign( n, d );
+ } catch ( bad_rational & ) { // normalization fail
+ try { is.setstate(ios::failbit); }
+ catch ( ... ) {} // don't throw ios_base::failure...
+ if ( is.exceptions() & ios::failbit )
+ throw; // ...but the original exception instead
+ // ELSE: suppress the exception, use just error flags
+ }
+ }
+ else
+ is.setstate( ios::failbit );
+ }
+ }
- if (c != '/')
- is.clear(std::istream::badbit); // old GNU c++ lib has no ios_base
-
-#if !defined(__GNUC__) || (defined(__GNUC__) && (__GNUC__ >= 3)) || defined \
__SGI_STL_PORT
- is >> std::noskipws;
-#else
- is.unsetf(ios::skipws); // compiles, but seems to have no effect.
-#endif
- is >> d;
-
- if (is)
- r.assign(n, d);
-
return is;
}
@@ -579,14 +630,34 @@
template <typename IntType>
std::ostream& operator<< (std::ostream& os, const rational<IntType>& r)
{
- os << r.numerator() << '/' << r.denominator();
- return os;
+ using namespace std;
+
+ // The slash directly precedes the denominator, which has no prefixes.
+ ostringstream ss;
+
+ ss.copyfmt( os );
+ ss.tie( NULL );
+ ss.exceptions( ios::goodbit );
+ ss.width( 0 );
+ ss << noshowpos << noshowbase << '/' << r.denominator();
+
+ // The numerator holds the showpos, internal, and showbase flags.
+ string const tail = ss.str();
+ streamsize const w = os.width() - static_cast<streamsize>( tail.size() );
+
+ ss.clear();
+ ss.str( "" );
+ ss.flags( os.flags() );
+ ss << setw( w < 0 || (os.flags() & ios::adjustfield) != ios::internal ? 0 :
+ w ) << r.numerator();
+ return os << ss.str() + tail;
}
+#endif // BOOST_NO_IOSTREAM
// Type conversion
template <typename T, typename IntType>
-inline T rational_cast(
- const rational<IntType>& src BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T))
+BOOST_CONSTEXPR
+inline T rational_cast(const rational<IntType>& src)
{
return static_cast<T>(src.numerator())/static_cast<T>(src.denominator());
}
@@ -597,10 +668,7 @@
template <typename IntType>
inline rational<IntType> abs(const rational<IntType>& r)
{
- if (r.numerator() >= IntType(0))
- return r;
-
- return rational<IntType>(-r.numerator(), r.denominator());
+ return r.numerator() >= IntType(0)? r: -r;
}
} // namespace boost
Modified: trunk/Thirdparty/boost/boost/ref.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/ref.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/ref.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -1,189 +1,17 @@
-#ifndef BOOST_REF_HPP_INCLUDED
-#define BOOST_REF_HPP_INCLUDED
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ */
-// MS compatible compilers support #pragma once
+#ifndef BOOST_REF_HPP
+#define BOOST_REF_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
+// The header file at this path is deprecated;
+// use boost/core/ref.hpp instead.
-#include <boost/config.hpp>
-#include <boost/utility/addressof.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/core/ref.hpp>
-//
-// ref.hpp - ref/cref, useful helper functions
-//
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2001, 2002 Peter Dimov
-// Copyright (C) 2002 David Abrahams
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/bind/ref.html for documentation.
-//
-
-namespace boost
-{
-
-template<class T> class reference_wrapper
-{
-public:
- typedef T type;
-
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1300 )
-
- explicit reference_wrapper(T& t): t_(&t) {}
-
-#else
-
- explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
-
#endif
-
- operator T& () const { return *t_; }
-
- T& get() const { return *t_; }
-
- T* get_pointer() const { return t_; }
-
-private:
-
- T* t_;
-};
-
-# if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, \
BOOST_TESTED_AT(0x581) )
-# define BOOST_REF_CONST
-# else
-# define BOOST_REF_CONST const
-# endif
-
-template<class T> inline reference_wrapper<T> BOOST_REF_CONST ref(T & t)
-{
- return reference_wrapper<T>(t);
-}
-
-template<class T> inline reference_wrapper<T const> BOOST_REF_CONST cref(T const & \
t)
-{
- return reference_wrapper<T const>(t);
-}
-
-# undef BOOST_REF_CONST
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-template<typename T>
-class is_reference_wrapper
- : public mpl::false_
-{
-};
-
-template<typename T>
-class unwrap_reference
-{
- public:
- typedef T type;
-};
-
-# define AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(X) \
-template<typename T> \
-class is_reference_wrapper< X > \
- : public mpl::true_ \
-{ \
-}; \
-\
-template<typename T> \
-class unwrap_reference< X > \
-{ \
- public: \
- typedef T type; \
-}; \
-/**/
-
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T>)
-#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const)
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> volatile)
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const volatile)
-#endif
-
-# undef AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF
-
-# else // no partial specialization
-
-} // namespace boost
-
-#include <boost/type.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
- typedef char (&yes_reference_wrapper_t)[1];
- typedef char (&no_reference_wrapper_t)[2];
-
- no_reference_wrapper_t is_reference_wrapper_test(...);
-
- template<typename T>
- yes_reference_wrapper_t is_reference_wrapper_test(type< reference_wrapper<T> >);
-
- template<bool wrapped>
- struct reference_unwrapper
- {
- template <class T>
- struct apply
- {
- typedef T type;
- };
- };
-
- template<>
- struct reference_unwrapper<true>
- {
- template <class T>
- struct apply
- {
- typedef typename T::type type;
- };
- };
-}
-
-template<typename T>
-class is_reference_wrapper
-{
- public:
- BOOST_STATIC_CONSTANT(
- bool, value = (
- sizeof(detail::is_reference_wrapper_test(type<T>()))
- == sizeof(detail::yes_reference_wrapper_t)));
-
- typedef ::boost::mpl::bool_<value> type;
-};
-
-template <typename T>
-class unwrap_reference
- : public detail::reference_unwrapper<
- is_reference_wrapper<T>::value
- >::template apply<T>
-{};
-
-# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-template <class T> inline typename unwrap_reference<T>::type&
-unwrap_ref(T& t)
-{
- return t;
-}
-
-template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
-{
- return r.get_pointer();
-}
-
-} // namespace boost
-
-#endif // #ifndef BOOST_REF_HPP_INCLUDED
Modified: trunk/Thirdparty/boost/boost/scope_exit.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/scope_exit.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/scope_exit.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -11,9 +11,6 @@
#ifndef DOXYGEN
-#include <boost/local_function/detail/preprocessor/line_counter.hpp>
-#include <boost/local_function/detail/preprocessor/void_list.hpp>
-#include <boost/local_function/detail/preprocessor/keyword/thisunderscore.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/int.hpp>
@@ -24,6 +21,7 @@
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/control/iif.hpp>
#include <boost/preprocessor/control/expr_iif.hpp>
+#include <boost/preprocessor/comparison/equal.hpp>
#include <boost/preprocessor/logical/bitor.hpp>
#include <boost/preprocessor/logical/bitand.hpp>
#include <boost/preprocessor/facilities/empty.hpp>
@@ -32,13 +30,17 @@
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/punctuation/paren_if.hpp>
#include <boost/preprocessor/seq/cat.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <boost/preprocessor/seq/to_tuple.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/tuple/eat.hpp>
+#include <boost/preprocessor/tuple/to_list.hpp>
#include <boost/preprocessor/list/append.hpp>
#include <boost/preprocessor/list/fold_left.hpp>
#include <boost/preprocessor/list/enum.hpp>
#include <boost/preprocessor/list/adt.hpp>
#include <boost/preprocessor/list/for_each_i.hpp>
+#include <boost/preprocessor/detail/is_unary.hpp>
// PRIVATE/PROTECTED //
@@ -65,6 +67,123 @@
# define BOOST_SCOPE_EXIT_AUX_TYPEOF_THIS_MSVC_WORKAROUND_01 0
#endif
+// MSVC has problems expanding __LINE__ so use (the non standard) __COUNTER__.
+#ifdef BOOST_MSVC
+# define BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER __COUNTER__
+#else
+# define BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER __LINE__
+#endif
+
+// Preprocessor "keyword" detection.
+
+// These are not a local macros, do not #undefine them (these are used by the
+// ..._BACK macros below).
+#define this_BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_THISUNDERSCORE_IS (1) /* unary */
+#define void_BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_VOID_IS (1) /* unary */
+
+#define BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_BACK_(token, checking_postfix) \
+ BOOST_PP_IS_UNARY(BOOST_PP_CAT(token, checking_postfix))
+
+#define BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_THISUNDERSCORE_BACK(token) \
+ BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_BACK_(token, \
+ BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_THISUNDERSCORE_IS)
+
+#define BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_VOID_BACK(token) \
+ BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_BACK_(token, \
+ _BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_VOID_IS)
+
+// Preprocessor "void-list".
+
+// NOTE: Empty list must always be represented as void (which is also a way to
+// specify no function parameter) and it can never be empty because (1)
+// IS_EMPTY(&var) fails (because of the leading non alphanumeric symbol) and
+// (2) some compilers (MSVC) fail to correctly pass empty macro parameters
+// even if they support variadic macros. Therefore, always using void to
+// represent is more portable.
+
+// Argument: (token1)...
+#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_SEQ_(unused, seq) \
+ BOOST_PP_TUPLE_TO_LIST(BOOST_PP_SEQ_SIZE(seq), BOOST_PP_SEQ_TO_TUPLE(seq))
+
+// Token: void | token1
+#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_VOID_( \
+ is_void_macro, token) \
+ BOOST_PP_IIF(is_void_macro(token), \
+ BOOST_PP_NIL \
+ , \
+ (token, BOOST_PP_NIL) \
+ )
+
+// Token: (a)(b)... | empty | void | token
+#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_SEQ_( \
+ is_void_macro, token) \
+ BOOST_PP_IIF(BOOST_PP_IS_UNARY(token), /* unary paren (a)... */ \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_SEQ_ \
+ , \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_VOID_ \
+ )(is_void_macro, token)
+
+#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_NEVER_(tokens) \
+ 0 /* void check always returns false */
+
+#ifdef BOOST_NO_CXX11_VARIADIC_MACROS
+
+#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_(is_void_macro, seq) \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_SEQ_(is_void_macro, seq)
+
+// Expand `void | (a)(b)...` to pp-list `NIL | (a, (b, NIL))`.
+#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(sign) \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \
+ BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_VOID_BACK, sign)
+
+// Expand `(a)(b)...` to pp-list `(a, (b, NIL))`.
+#define BOOST_SCOPE_EXIT_AUX_PP_NON_VOID_LIST(seq) \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_NEVER_, seq)
+
+#else // VARIADICS
+
+// FUTURE: Replace this with BOOST_PP_VARIADIC_SIZE when and if
+// BOOST_PP_VARIAIDCS detection will match !BOOST_NO_CXX11_VARIADIC_MACROS (for
+// now Boost.Preprocessor and Boost.Config disagree on detecting compiler
+// variadic support while this VARIADIC_SIZE works on compilers not detected by
+// PP).
+#if BOOST_MSVC
+# define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_(...) \
+ BOOST_PP_CAT(BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_I_(__VA_ARGS__, \
64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, \
43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, \
22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,),) \
+#else // MSVC +# define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_(...) \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_I_(__VA_ARGS__, 64, 63, 62, \
61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, \
40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, \
19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,) +#endif // MSVC
+#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_I_(e0, e1, e2, e3, e4, e5, \
e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, \
e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, \
e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, \
e58, e59, e60, e61, e62, e63, size, ...) size +
+// Argument: token1, ...
+#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_VARIADIC_(unused, ...) \
+ BOOST_PP_TUPLE_TO_LIST( \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_( \
+ __VA_ARGS__), (__VA_ARGS__))
+
+#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_(is_void_macro, ...) \
+ BOOST_PP_IIF(BOOST_PP_EQUAL( \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_( \
+ __VA_ARGS__), 1), \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_SEQ_ \
+ , \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_VARIADIC_ \
+ )(is_void_macro, __VA_ARGS__)
+
+// Expand `void | (a)(b)... | a, b, ...` to pp-list `NIL | (a, (b, NIL))`.
+#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(...) \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \
+ BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_VOID_BACK, __VA_ARGS__)
+
+// Expand `(a)(b)... | a, b, ...` to pp-list `(a, (b, NIL))`.
+#define BOOST_SCOPE_EXIT_AUX_PP_NON_VOID_LIST(...) \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_NEVER_, __VA_ARGS__)
+
+#endif // VARIADICS
+
// Steven Watanabe's trick with a modification suggested by Kim Barrett
namespace boost { namespace scope_exit { namespace detail {
@@ -222,7 +341,7 @@
#include <boost/type_traits/is_function.hpp>
#include <boost/utility/enable_if.hpp>
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1310)
+#if defined(BOOST_MSVC)
# include <typeinfo>
#endif
@@ -230,7 +349,7 @@
namespace msvc_typeof_this {
// compile-time constant code
-#if BOOST_WORKAROUND(BOOST_MSVC, >=1300) && defined(_MSC_EXTENSIONS)
+#if defined(BOOST_MSVC) && defined(_MSC_EXTENSIONS)
template<int N> struct the_counter;
@@ -278,28 +397,8 @@
#endif // compile-time constant code
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1300) // type-of code
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) // type-of code
-template<typename ID>
-struct msvc_extract_type
-{
- template<bool>
- struct id2type_impl;
-
- typedef id2type_impl<true> id2type;
-};
-
-template<typename T, typename ID>
-struct msvc_register_type : msvc_extract_type<ID>
-{
- template<>
- struct id2type_impl<true> { // VC7.0 specific bug-feature.
- typedef T type;
- };
-};
-
-#elif BOOST_WORKAROUND(BOOST_MSVC, >= 1400) // type-of code
-
struct msvc_extract_type_default_param {};
template<typename ID, typename T = msvc_extract_type_default_param>
@@ -565,7 +664,7 @@
(captures, 1 /* has this (note, no error if multiple this_) */)
#define BOOST_SCOPE_EXIT_AUX_TRAITS_OP(d, captures_this, capture) \
- BOOST_PP_IIF(BOOST_LOCAL_FUNCTION_DETAIL_PP_KEYWORD_IS_THISUNDERSCORE_BACK(\
+ BOOST_PP_IIF(BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_THISUNDERSCORE_BACK(\
capture), \
BOOST_SCOPE_EXIT_AUX_TRAITS_OP_THIS \
, \
@@ -762,16 +861,16 @@
# define BOOST_SCOPE_EXIT_ID(id, void_or_seq) \
BOOST_SCOPE_EXIT_AUX_IMPL(id, BOOST_PP_EMPTY(), \
BOOST_SCOPE_EXIT_AUX_TRAITS( \
- BOOST_LOCAL_FUNCTION_DETAIL_PP_VOID_LIST(void_or_seq)))
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(void_or_seq)))
# define BOOST_SCOPE_EXIT_ID_TPL(id, void_or_seq) \
BOOST_SCOPE_EXIT_AUX_IMPL(id, typename, \
BOOST_SCOPE_EXIT_AUX_TRAITS( \
- BOOST_LOCAL_FUNCTION_DETAIL_PP_VOID_LIST(void_or_seq)))
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(void_or_seq)))
# define BOOST_SCOPE_EXIT(void_or_seq) \
- BOOST_SCOPE_EXIT_ID(BOOST_LOCAL_FUNCTION_DETAIL_PP_LINE_COUNTER, \
+ BOOST_SCOPE_EXIT_ID(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, \
void_or_seq)
# define BOOST_SCOPE_EXIT_TPL(void_or_seq) \
- BOOST_SCOPE_EXIT_ID_TPL(BOOST_LOCAL_FUNCTION_DETAIL_PP_LINE_COUNTER, \
+ BOOST_SCOPE_EXIT_ID_TPL(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, \
void_or_seq)
# if !defined(BOOST_NO_CXX11_LAMBDAS)
# define BOOST_SCOPE_EXIT_ALL_ID(id, seq) \
@@ -782,25 +881,25 @@
/* typename, always use `this` instead of `this_`) */ \
typename, \
BOOST_SCOPE_EXIT_AUX_TRAITS_ALL( \
- BOOST_LOCAL_FUNCTION_DETAIL_PP_NON_VOID_LIST(seq)))
+ BOOST_SCOPE_EXIT_AUX_PP_NON_VOID_LIST(seq)))
# define BOOST_SCOPE_EXIT_ALL(seq) \
BOOST_SCOPE_EXIT_ALL_ID( \
- BOOST_LOCAL_FUNCTION_DETAIL_PP_LINE_COUNTER, seq)
+ BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, seq)
# endif
#else // Variadic macros (both sequences and variadic tuples).
# define BOOST_SCOPE_EXIT_ID(id, ...) \
BOOST_SCOPE_EXIT_AUX_IMPL(id, BOOST_PP_EMPTY(), \
BOOST_SCOPE_EXIT_AUX_TRAITS( \
- BOOST_LOCAL_FUNCTION_DETAIL_PP_VOID_LIST(__VA_ARGS__)))
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(__VA_ARGS__)))
# define BOOST_SCOPE_EXIT_ID_TPL(id, ...) \
BOOST_SCOPE_EXIT_AUX_IMPL(id, typename, \
BOOST_SCOPE_EXIT_AUX_TRAITS( \
- BOOST_LOCAL_FUNCTION_DETAIL_PP_VOID_LIST(__VA_ARGS__)))
+ BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(__VA_ARGS__)))
# define BOOST_SCOPE_EXIT(...) \
- BOOST_SCOPE_EXIT_ID(BOOST_LOCAL_FUNCTION_DETAIL_PP_LINE_COUNTER, \
+ BOOST_SCOPE_EXIT_ID(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, \
__VA_ARGS__)
# define BOOST_SCOPE_EXIT_TPL(...) \
- BOOST_SCOPE_EXIT_ID_TPL(BOOST_LOCAL_FUNCTION_DETAIL_PP_LINE_COUNTER, \
+ BOOST_SCOPE_EXIT_ID_TPL(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, \
__VA_ARGS__)
# if !defined(BOOST_NO_CXX11_LAMBDAS)
# define BOOST_SCOPE_EXIT_ALL_ID(id, ...) \
@@ -811,11 +910,11 @@
/* typename, always use `this` instead of `this_`) */ \
typename, \
BOOST_SCOPE_EXIT_AUX_TRAITS_ALL( \
- BOOST_LOCAL_FUNCTION_DETAIL_PP_NON_VOID_LIST( \
+ BOOST_SCOPE_EXIT_AUX_PP_NON_VOID_LIST( \
__VA_ARGS__)))
# define BOOST_SCOPE_EXIT_ALL(...) \
BOOST_SCOPE_EXIT_ALL_ID( \
- BOOST_LOCAL_FUNCTION_DETAIL_PP_LINE_COUNTER, __VA_ARGS__)
+ BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, __VA_ARGS__)
# endif
#endif // Variadics.
@@ -828,7 +927,7 @@
} BOOST_SCOPE_EXIT_AUX_GUARD(id)(BOOST_SCOPE_EXIT_AUX_ARGS.value);
#endif // Using lambdas.
#define BOOST_SCOPE_EXIT_END \
- BOOST_SCOPE_EXIT_END_ID(BOOST_LOCAL_FUNCTION_DETAIL_PP_LINE_COUNTER)
+ BOOST_SCOPE_EXIT_END_ID(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER)
// DOCUMENTATION //
Modified: trunk/Thirdparty/boost/boost/shared_container_iterator.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/shared_container_iterator.hpp 2015-12-10 13:11:27 \
UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/shared_container_iterator.hpp 2015-12-10 13:29:55 \
UTC (rev 7435) @@ -13,6 +13,7 @@
#include <utility>
namespace boost {
+namespace iterators {
template <typename Container>
class shared_container_iterator : public iterator_adaptor<
@@ -37,7 +38,7 @@
};
template <typename Container>
-shared_container_iterator<Container>
+inline shared_container_iterator<Container>
make_shared_container_iterator(typename Container::iterator iter,
boost::shared_ptr<Container> const& container) {
typedef shared_container_iterator<Container> iterator;
@@ -47,7 +48,7 @@
template <typename Container>
-std::pair<
+inline std::pair<
shared_container_iterator<Container>,
shared_container_iterator<Container> >
make_shared_container_range(boost::shared_ptr<Container> const& container) {
@@ -57,6 +58,12 @@
make_shared_container_iterator(container->end(),container));
}
+} // namespace iterators
+using iterators::shared_container_iterator;
+using iterators::make_shared_container_iterator;
+using iterators::make_shared_container_range;
+
} // namespace boost
+
#endif // SHARED_CONTAINER_ITERATOR_RG08102002_HPP
Modified: trunk/Thirdparty/boost/boost/spirit.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/spirit.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/spirit.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -1,6 +1,6 @@
/*=============================================================================
Copyright (c) 2001-2008 Joel de Guzman
- Copyright (c) 2001-2009 Hartmut Kaiser
+ Copyright (c) 2001-2008 Hartmut Kaiser
http://spirit.sourceforge.net/
Distributed under the Boost Software License, Version 1.0. (See accompanying
Modified: trunk/Thirdparty/boost/boost/swap.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/swap.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/swap.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -1,12 +1,17 @@
-// Copyright (C) 2007 Joseph Gauterin
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ */
#ifndef BOOST_SWAP_HPP
#define BOOST_SWAP_HPP
-#include "boost/utility/swap.hpp"
+// The header file at this path is deprecated;
+// use boost/core/swap.hpp instead.
+#include <boost/core/swap.hpp>
+
#endif
Modified: trunk/Thirdparty/boost/boost/throw_exception.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/throw_exception.hpp 2015-12-10 13:11:27 UTC (rev \
7434)
+++ trunk/Thirdparty/boost/boost/throw_exception.hpp 2015-12-10 13:29:55 UTC (rev \
7435) @@ -1,6 +1,6 @@
#ifndef UUID_AA15E74A856F11E08B8D93F24824019B
#define UUID_AA15E74A856F11E08B8D93F24824019B
-#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
#pragma GCC system_header
#endif
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
@@ -26,7 +26,6 @@
// http://www.boost.org/libs/utility/throw_exception.html
//
-#include <boost/exception/detail/attribute_noreturn.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/config.hpp>
#include <exception>
@@ -41,8 +40,11 @@
#if !defined( BOOST_EXCEPTION_DISABLE )
# include <boost/exception/exception.hpp>
+#if !defined(BOOST_THROW_EXCEPTION_CURRENT_FUNCTION)
# include <boost/current_function.hpp>
-# define BOOST_THROW_EXCEPTION(x) \
::boost::exception_detail::throw_exception_(x,BOOST_CURRENT_FUNCTION,__FILE__,__LINE__)
+# define BOOST_THROW_EXCEPTION_CURRENT_FUNCTION BOOST_CURRENT_FUNCTION
+#endif
+# define BOOST_THROW_EXCEPTION(x) \
::boost::exception_detail::throw_exception_(x,BOOST_THROW_EXCEPTION_CURRENT_FUNCTION,__FILE__,__LINE__)
#else
# define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(x)
#endif
@@ -57,7 +59,7 @@
inline void throw_exception_assert_compatibility( std::exception const & ) { }
-template<class E> BOOST_ATTRIBUTE_NORETURN inline void throw_exception( E const & e \
) +template<class E> BOOST_NORETURN inline void throw_exception( E const & e )
{
//All boost exceptions are required to derive from std::exception,
//to ensure compatibility with BOOST_NO_EXCEPTIONS.
@@ -77,7 +79,7 @@
exception_detail
{
template <class E>
- BOOST_ATTRIBUTE_NORETURN
+ BOOST_NORETURN
void
throw_exception_( E const & x, char const * current_function, char const * \
file, int line ) {
Modified: trunk/Thirdparty/boost/boost/token_functions.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/token_functions.hpp 2015-12-10 13:11:27 UTC (rev \
7434)
+++ trunk/Thirdparty/boost/boost/token_functions.hpp 2015-12-10 13:29:55 UTC (rev \
7435) @@ -40,6 +40,7 @@
#include <boost/assert.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/mpl/if.hpp>
+#include <boost/throw_exception.hpp>
#if !defined(BOOST_NO_CWCTYPE)
#include <cwctype>
#endif
@@ -125,7 +126,7 @@
template <typename iterator, typename Token>
void do_escape(iterator& next,iterator end,Token& tok) {
if (++next == end)
- throw escaped_list_error(std::string("cannot end with escape"));
+ BOOST_THROW_EXCEPTION(escaped_list_error(std::string("cannot end with \
escape"))); if (Traits::eq(*next,'n')) {
tok+='\n';
return;
@@ -143,7 +144,7 @@
return;
}
else
- throw escaped_list_error(std::string("unknown escape sequence"));
+ BOOST_THROW_EXCEPTION(escaped_list_error(std::string("unknown escape \
sequence"))); }
public:
@@ -278,22 +279,7 @@
struct assign_or_plus_equal {
template<class Iterator, class Token>
static void assign(Iterator b, Iterator e, Token &t) {
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) &&\
- BOOST_WORKAROUND(__SGI_STL_PORT, < 0x500) &&\
- defined(_STLP_DEBUG) &&\
- (defined(_STLP_USE_DYNAMIC_LIB) || defined(_DLL))
- // Problem with string::assign for msvc-stlport in debug mode: the
- // linker tries to import the templatized version of this memfun,
- // which is obviously not exported.
- // See http://www.stlport.com/dcforum/DCForumID6/1763.html for details.
-
- t = Token();
- while(b != e) t += *b++;
-#else
t.assign(b, e);
-#endif
-
}
template<class Token, class Value>
Modified: trunk/Thirdparty/boost/boost/token_iterator.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/token_iterator.hpp 2015-12-10 13:11:27 UTC (rev \
7434)
+++ trunk/Thirdparty/boost/boost/token_iterator.hpp 2015-12-10 13:29:55 UTC (rev \
7435) @@ -18,11 +18,11 @@
#ifndef BOOST_TOKENIZER_POLICY_JRB070303_HPP_
#define BOOST_TOKENIZER_POLICY_JRB070303_HPP_
-#include<boost/assert.hpp>
-#include<boost/iterator/iterator_adaptor.hpp>
-#include<boost/iterator/detail/minimum_category.hpp>
-#include<boost/token_functions.hpp>
-#include<utility>
+#include <boost/assert.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/minimum_category.hpp>
+#include <boost/token_functions.hpp>
+#include <utility>
namespace boost
{
@@ -31,10 +31,10 @@
: public iterator_facade<
token_iterator<TokenizerFunc, Iterator, Type>
, Type
- , typename detail::minimum_category<
+ , typename iterators::minimum_category<
forward_traversal_tag
, typename iterator_traversal<Iterator>::type
- >::type
+ >::type
, const Type&
>
{
@@ -88,7 +88,7 @@
Iterator base()const{return begin_;}
- Iterator end()const{return end_;};
+ Iterator end()const{return end_;}
TokenizerFunc tokenizer_function()const{return f_;}
@@ -101,24 +101,24 @@
};
template <
- class TokenizerFunc = char_delimiters_separator<char>,
+ class TokenizerFunc = char_delimiters_separator<char>,
class Iterator = std::string::const_iterator,
class Type = std::string
>
class token_iterator_generator {
- private:
+ private:
public:
typedef token_iterator<TokenizerFunc,Iterator,Type> type;
};
-
-
+
+
// Type has to be first because it needs to be explicitly specified
// because there is no way the function can deduce it.
template<class Type, class Iterator, class TokenizerFunc>
- typename token_iterator_generator<TokenizerFunc,Iterator,Type>::type
+ typename token_iterator_generator<TokenizerFunc,Iterator,Type>::type
make_token_iterator(Iterator begin, Iterator end,const TokenizerFunc& fun){
- typedef typename
+ typedef typename
token_iterator_generator<TokenizerFunc,Iterator,Type>::type ret_type;
return ret_type(fun,begin,end);
}
Copied: trunk/Thirdparty/boost/boost/type_index.hpp (from rev 7307, \
sandbox/v140/Thirdparty/boost/boost/type_index.hpp) \
===================================================================
--- trunk/Thirdparty/boost/boost/type_index.hpp (rev 0)
+++ trunk/Thirdparty/boost/boost/type_index.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -0,0 +1,265 @@
+//
+// Copyright (c) Antony Polukhin, 2012-2014.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_TYPE_INDEX_HPP
+#define BOOST_TYPE_INDEX_HPP
+
+/// \file boost/type_index.hpp
+/// \brief Includes minimal set of headers required to use the Boost.TypeIndex \
library. +///
+/// By inclusion of this file most optimal type index classes will be included and \
used +/// as a boost::typeindex::type_index and boost::typeindex::type_info.
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#if defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
+# include BOOST_TYPE_INDEX_USER_TYPEINDEX
+# ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
+# pragma detect_mismatch( "boost__type_index__abi", "user defined type_index \
class is used: " BOOST_STRINGIZE(BOOST_TYPE_INDEX_USER_TYPEINDEX)) +# endif
+#elif (!defined(BOOST_NO_RTTI) && \
!defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC) +# \
include <boost/type_index/stl_type_index.hpp> +# if defined(BOOST_NO_RTTI) || \
defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY) +# include \
<boost/type_index/detail/stl_register_class.hpp> +# ifdef \
BOOST_HAS_PRAGMA_DETECT_MISMATCH +# pragma detect_mismatch( \
"boost__type_index__abi", "RTTI is off - typeid() is used only for templates") +# \
endif +# else
+# ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
+# pragma detect_mismatch( "boost__type_index__abi", "RTTI is used")
+# endif
+# endif
+#else
+# include <boost/type_index/ctti_type_index.hpp>
+# include <boost/type_index/detail/ctti_register_class.hpp>
+# ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
+# pragma detect_mismatch( "boost__type_index__abi", "RTTI is off - using \
CTTI") +# endif
+#endif
+
+#ifndef BOOST_TYPE_INDEX_REGISTER_CLASS
+#define BOOST_TYPE_INDEX_REGISTER_CLASS
+#endif
+
+namespace boost { namespace typeindex {
+
+#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
+
+/// \def BOOST_TYPE_INDEX_FUNCTION_SIGNATURE
+/// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is used by boost::typeindex::ctti_type_index \
class to +/// deduce the name of a type. If your compiler is not recognized
+/// by the TypeIndex library and you wish to work with \
boost::typeindex::ctti_type_index, you may +/// define this macro by yourself.
+///
+/// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE must be defined to a compiler specific macro
+/// that outputs the \b whole function signature \b including \b template \b \
parameters. +///
+/// If your compiler is not recognised and BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is \
not defined, +/// then a compile-time error will arise at any attempt to use \
boost::typeindex::ctti_type_index classes. +///
+/// See BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS and \
BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING +/// for an information of how to tune the \
implementation to make a nice pretty_name() output. +#define \
BOOST_TYPE_INDEX_FUNCTION_SIGNATURE BOOST_CURRENT_FUNCTION +
+/// \def BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING
+/// This is a helper macro for making correct pretty_names() with RTTI off.
+///
+/// BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING macro may be defined to
+/// '(begin_skip, end_skip, runtime_skip, runtime_skip_until)' with parameters for \
adding a +/// support for compilers, that by default are not recognized by TypeIndex \
library. +///
+/// \b Example:
+///
+/// Imagine the situation when
+/// \code boost::typeindex::ctti_type_index::type_id<int>().pretty_name() \endcode
+/// returns the following string:
+/// \code "static const char *boost::detail::ctti<int>::n() [T = int]" \endcode
+/// and \code boost::typeindex::ctti_type_index::type_id<short>().pretty_name() \
\endcode returns the following: +/// \code "static const char \
*boost::detail::ctti<short>::n() [T = short]" \endcode +///
+/// As we may see first 39 characters are "static const char *boost::detail::ctti<" \
and they do not depend on +/// the type T. After first 39 characters we have a human \
readable type name which is duplicated at the end +/// of a string. String always \
ends on ']', which consumes 1 character. +///
+/// Now if we define `BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING` to
+/// `(39, 1, false, "")` we'll be getting \code "int>::n() [T = int" \endcode
+/// for `boost::typeindex::ctti_type_index::type_id<int>().pretty_name()` and \code \
"short>::n() [T = short" \endcode +/// for \
`boost::typeindex::ctti_type_index::type_id<short>().pretty_name()`. +///
+/// Now we need to take additional care of the characters that go before the last \
mention of our type. We'll +/// do that by telling the macro that we need to cut off \
everything that goes before the "T = " including the "T = " +/// itself:
+///
+/// \code (39, 1, true, "T = ") \endcode
+///
+/// In case of GCC or Clang command line we need to add the following line while \
compiling all the sources: +///
+/// \code
+/// -DBOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING='(39, 1, true, "T = ")'
+/// \endcode
+/// \param begin_skip How many characters must be skipped at the beginning of the \
type holding string. +/// Must be a compile time constant.
+/// \param end_skip How many characters must be skipped at the end of the type \
holding string. +/// Must be a compile time constant.
+/// \param runtime_skip Do we need additional checks at runtime to cut off the more \
characters. +/// Must be `true` or `false`.
+/// \param runtime_skip_until Skip all the characters before the following string \
(including the string itself). +/// Must be a compile time array of characters.
+///
+/// See [RTTI emulation \
limitations](boost_typeindex/rtti_emulation_limitations.html) for more info. +#define \
BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING (0, 0, false, "") +
+
+ /// Depending on a compiler flags, optimal implementation of type_index will be \
used + /// as a default boost::typeindex::type_index.
+ ///
+ /// Could be a boost::typeindex::stl_type_index, \
boost::typeindex::ctti_type_index or + /// user defined type_index class.
+ ///
+ /// \b See boost::typeindex::type_index_facade for a full description of \
type_index functions. + typedef platform_specific type_index;
+#elif defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
+ // Nothing to do
+#elif (!defined(BOOST_NO_RTTI) && \
!defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC) + \
typedef boost::typeindex::stl_type_index type_index; +#else
+ typedef boost::typeindex::ctti_type_index type_index;
+#endif
+
+/// Depending on a compiler flags, optimal implementation of type_info will be used
+/// as a default boost::typeindex::type_info.
+///
+/// Could be a std::type_info, boost::typeindex::detail::ctti_data or
+/// some user defined class.
+///
+/// type_info \b is \b not copyable or default constructible. It is \b not \
assignable too! +typedef type_index::type_info_t type_info;
+
+#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
+
+/// \def BOOST_TYPE_INDEX_USER_TYPEINDEX
+/// BOOST_TYPE_INDEX_USER_TYPEINDEX can be defined to the path to header file
+/// with user provided implementation of type_index.
+///
+/// See [Making a custom \
type_index](boost_typeindex/making_a_custom_type_index.html) section +/// of \
documentation for usage example. +#define BOOST_TYPE_INDEX_USER_TYPEINDEX \
<full/absolute/path/to/header/with/type_index.hpp> +
+
+/// \def BOOST_TYPE_INDEX_REGISTER_CLASS
+/// BOOST_TYPE_INDEX_REGISTER_CLASS is used to help to emulate RTTI.
+/// Put this macro into the public section of polymorphic class to allow runtime \
type detection. +///
+/// Depending on the typeid() availability this macro will expand to nothing or to \
virtual helper function +/// `virtual const type_info& \
boost_type_info_type_id_runtime_() const noexcept`. +///
+/// \b Example:
+/// \code
+/// class A {
+/// public:
+/// BOOST_TYPE_INDEX_REGISTER_CLASS
+/// virtual ~A(){}
+/// };
+///
+/// struct B: public A {
+/// BOOST_TYPE_INDEX_REGISTER_CLASS
+/// };
+///
+/// struct C: public B {
+/// BOOST_TYPE_INDEX_REGISTER_CLASS
+/// };
+///
+/// ...
+///
+/// C c1;
+/// A* pc1 = &c1;
+/// assert(boost::typeindex::type_id<C>() == \
boost::typeindex::type_id_runtime(*pc1)); +/// \endcode
+#define BOOST_TYPE_INDEX_REGISTER_CLASS nothing-or-some-virtual-functions
+
+/// \def BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
+/// BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY is a helper macro that must be \
defined if mixing +/// RTTI on/off modules. See
+/// [Mixing sources with RTTI on and RTTI \
off](boost_typeindex/mixing_sources_with_rtti_on_and_.html) +/// section of \
documentation for more info. +#define BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
+
+#endif // defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
+
+
+/// Function to get boost::typeindex::type_index for a type T.
+/// Removes const, volatile && and & modifiers from T.
+///
+/// \b Example:
+/// \code
+/// type_index ti = type_id<int&>();
+/// std::cout << ti.pretty_name(); // Outputs 'int'
+/// \endcode
+///
+/// \tparam T Type for which type_index must be created.
+/// \throw Nothing.
+/// \return boost::typeindex::type_index with information about the specified type \
T. +template <class T>
+inline type_index type_id() BOOST_NOEXCEPT {
+ return type_index::type_id<T>();
+}
+
+/// Function for constructing boost::typeindex::type_index instance for type T.
+/// Does not remove const, volatile, & and && modifiers from T.
+///
+/// If T has no const, volatile, & and && modifiers, then returns exactly
+/// the same result as in case of calling `type_id<T>()`.
+///
+/// \b Example:
+/// \code
+/// type_index ti = type_id_with_cvr<int&>();
+/// std::cout << ti.pretty_name(); // Outputs 'int&'
+/// \endcode
+///
+/// \tparam T Type for which type_index must be created.
+/// \throw Nothing.
+/// \return boost::typeindex::type_index with information about the specified type \
T. +template <class T>
+inline type_index type_id_with_cvr() BOOST_NOEXCEPT {
+ return type_index::type_id_with_cvr<T>();
+}
+
+/// Function that works exactly like C++ typeid(rtti_val) call, but returns \
boost::type_index. +///
+/// Retunrs runtime information about specified type.
+///
+/// \b Requirements: RTTI available or Base and Derived classes must be marked with \
BOOST_TYPE_INDEX_REGISTER_CLASS. +///
+/// \b Example:
+/// \code
+/// struct Base { virtual ~Base(){} };
+/// struct Derived: public Base {};
+/// ...
+/// Derived d;
+/// Base& b = d;
+/// type_index ti = type_id_runtime(b);
+/// std::cout << ti.pretty_name(); // Outputs 'Derived'
+/// \endcode
+///
+/// \param runtime_val Varaible which runtime type must be returned.
+/// \throw Nothing.
+/// \return boost::typeindex::type_index with information about the specified \
variable. +template <class T>
+inline type_index type_id_runtime(const T& runtime_val) BOOST_NOEXCEPT {
+ return type_index::type_id_runtime(runtime_val);
+}
+
+}} // namespace boost::typeindex
+
+
+
+#endif // BOOST_TYPE_INDEX_HPP
+
Modified: trunk/Thirdparty/boost/boost/type_traits.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/type_traits.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/type_traits.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -50,6 +50,8 @@
#include "boost/type_traits/is_compound.hpp"
#include "boost/type_traits/is_const.hpp"
#include "boost/type_traits/is_convertible.hpp"
+#include "boost/type_traits/is_copy_constructible.hpp"
+#include "boost/type_traits/is_copy_assignable.hpp"
#include "boost/type_traits/is_empty.hpp"
#include "boost/type_traits/is_enum.hpp"
#include "boost/type_traits/is_float.hpp"
Modified: trunk/Thirdparty/boost/boost/unordered_map.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/unordered_map.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/unordered_map.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -9,8 +9,9 @@
#ifndef BOOST_UNORDERED_MAP_HPP_INCLUDED
#define BOOST_UNORDERED_MAP_HPP_INCLUDED
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
#endif
#include <boost/unordered/unordered_map.hpp>
Modified: trunk/Thirdparty/boost/boost/unordered_set.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/unordered_set.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/unordered_set.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -9,8 +9,9 @@
#ifndef BOOST_UNORDERED_SET_HPP_INCLUDED
#define BOOST_UNORDERED_SET_HPP_INCLUDED
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
#endif
#include <boost/unordered/unordered_set.hpp>
Modified: trunk/Thirdparty/boost/boost/version.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/version.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/version.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -10,16 +10,16 @@
#define BOOST_VERSION_HPP
//
-// Caution, this is the only boost header that is guarenteed
-// to change with every boost release, including this header
-// will cause a recompile every time a new boost version is
-// released.
+// Caution: this is the only Boost header that is guaranteed
+// to change with every Boost release. Including this header
+// will cause a recompile every time a new Boost version is
+// used.
//
// BOOST_VERSION % 100 is the patch level
// BOOST_VERSION / 100 % 1000 is the minor version
// BOOST_VERSION / 100000 is the major version
-#define BOOST_VERSION 105400
+#define BOOST_VERSION 105900
//
// BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION
@@ -27,6 +27,6 @@
// 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_54"
+#define BOOST_LIB_VERSION "1_59"
#endif
Modified: trunk/Thirdparty/boost/boost/visit_each.hpp
===================================================================
--- trunk/Thirdparty/boost/boost/visit_each.hpp 2015-12-10 13:11:27 UTC (rev 7434)
+++ trunk/Thirdparty/boost/boost/visit_each.hpp 2015-12-10 13:29:55 UTC (rev 7435)
@@ -10,8 +10,6 @@
#ifndef BOOST_VISIT_EACH_HPP
#define BOOST_VISIT_EACH_HPP
-#include <boost/config.hpp>
-
namespace boost {
template<typename Visitor, typename T>
inline void visit_each(Visitor& visitor, const T& t, long)
[Attachment #3 (text/plain)]
_______________________________________________
fdo-commits mailing list
fdo-commits@lists.osgeo.org
http://lists.osgeo.org/mailman/listinfo/fdo-commits
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic