update boost

linx64/include/boost/log/attributes/attribute_set.hpp

@@ -18,9 +18,11 @@
 #include <cstddef>
 #include <utility>
 #include <iterator>
-#include <boost/mpl/if.hpp>
 #include <boost/move/core.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/conditional.hpp>
 #include <boost/log/detail/config.hpp>
+#include <boost/log/detail/sfinae_tools.hpp>
 #include <boost/log/attributes/attribute_name.hpp>
 #include <boost/log/attributes/attribute.hpp>
 #include <boost/log/detail/header.hpp>
@@ -157,12 +159,12 @@ private:
         //  Standard typedefs
         typedef attribute_set::difference_type difference_type;
         typedef attribute_set::value_type value_type;
-        typedef typename mpl::if_c<
+        typedef typename boost::conditional<
             fConstV,
             attribute_set::const_reference,
             attribute_set::reference
         >::type reference;
-        typedef typename mpl::if_c<
+        typedef typename boost::conditional<
             fConstV,
             attribute_set::const_pointer,
             attribute_set::pointer
@@ -171,23 +173,32 @@ private:
 
     public:
         //  Constructors
-        BOOST_CONSTEXPR iter() : m_pNode(NULL) {}
+        BOOST_CONSTEXPR iter() BOOST_NOEXCEPT : m_pNode(NULL) {}
         explicit iter(node_base* pNode) BOOST_NOEXCEPT : m_pNode(pNode) {}
-        iter(iter< false > const& that) BOOST_NOEXCEPT : m_pNode(that.m_pNode) {}
+#if !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+        template< bool fOtherConstV, typename = typename boost::enable_if_c< !fOtherConstV && fOtherConstV != fConstV >::type >
+        iter(iter< fOtherConstV > const& that) BOOST_NOEXCEPT : m_pNode(that.m_pNode) {}
+#else
+        template< bool fOtherConstV >
+        iter(iter< fOtherConstV > const& that, typename boost::enable_if_c< !fOtherConstV && fOtherConstV != fConstV, boost::log::aux::sfinae_dummy >::type = boost::log::aux::sfinae_dummy()) BOOST_NOEXCEPT :
+            m_pNode(that.m_pNode)
+        {
+        }
+#endif
 
         //! Assignment
-        template< bool f >
-        iter& operator= (iter< f > const& that) BOOST_NOEXCEPT
+        template< bool fOtherConstV >
+        typename boost::enable_if_c< !fOtherConstV && fOtherConstV != fConstV, iter& >::type operator= (iter< fOtherConstV > const& that) BOOST_NOEXCEPT
         {
             m_pNode = that.m_pNode;
             return *this;
         }
 
         //  Comparison
-        template< bool f >
-        bool operator== (iter< f > const& that) const BOOST_NOEXCEPT { return (m_pNode == that.m_pNode); }
-        template< bool f >
-        bool operator!= (iter< f > const& that) const BOOST_NOEXCEPT { return (m_pNode != that.m_pNode); }
+        template< bool fOtherConstV >
+        typename boost::enable_if_c< !fOtherConstV || fOtherConstV == fConstV, bool >::type operator== (iter< fOtherConstV > const& that) const BOOST_NOEXCEPT { return (m_pNode == that.m_pNode); }
+        template< bool fOtherConstV >
+        typename boost::enable_if_c< !fOtherConstV || fOtherConstV == fConstV, bool >::type operator!= (iter< fOtherConstV > const& that) const BOOST_NOEXCEPT { return (m_pNode != that.m_pNode); }
 
         //  Modification
         iter& operator++ () BOOST_NOEXCEPT

linx64/include/boost/log/attributes/attribute_value.hpp

@@ -98,7 +98,7 @@ public:
         /*!
          * \return The attribute value that refers to self implementation.
          */
-        virtual attribute_value get_value() { return attribute_value(this); }
+        attribute_value get_value() BOOST_OVERRIDE { return attribute_value(this); }
 
         /*!
          * \return The attribute value type
@@ -114,7 +114,7 @@ public:
     /*!
      * Default constructor. Creates an empty (absent) attribute value.
      */
-    BOOST_DEFAULTED_FUNCTION(attribute_value(), {})
+    BOOST_DEFAULTED_FUNCTION(attribute_value(), BOOST_NOEXCEPT {})
 
     /*!
      * Copy constructor

linx64/include/boost/log/attributes/attribute_value_impl.hpp

@@ -19,6 +19,7 @@
 #include <boost/move/core.hpp>
 #include <boost/move/utility_core.hpp>
 #include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
 #include <boost/log/detail/config.hpp>
 #include <boost/log/attributes/attribute_value.hpp>
 #include <boost/log/utility/type_dispatch/type_dispatcher.hpp>
@@ -64,7 +65,10 @@ public:
     /*!
      * Constructor with initialization of the stored value
      */
-    explicit attribute_value_impl(BOOST_RV_REF(value_type) v) : m_value(boost::move(v)) {}
+    explicit attribute_value_impl(BOOST_RV_REF(value_type) v) BOOST_NOEXCEPT_IF(boost::is_nothrow_move_constructible< value_type >::value) :
+        m_value(boost::move(v))
+    {
+    }
 
     /*!
      * Attribute value dispatching method.
@@ -73,7 +77,7 @@ public:
      *
      * \return \c true if the value has been dispatched, \c false otherwise
      */
-    virtual bool dispatch(type_dispatcher& dispatcher)
+    bool dispatch(type_dispatcher& dispatcher) BOOST_OVERRIDE
     {
         type_dispatcher::callback< value_type > callback = dispatcher.get_callback< value_type >();
         if (callback)
@@ -88,7 +92,7 @@ public:
     /*!
      * \return The attribute value type
      */
-    typeindex::type_index get_type() const { return typeindex::type_id< value_type >(); }
+    typeindex::type_index get_type() const BOOST_OVERRIDE { return typeindex::type_id< value_type >(); }
 
     /*!
      * \return Reference to the contained value.

linx64/include/boost/log/attributes/constant.hpp

@@ -18,6 +18,7 @@
 #include <boost/move/core.hpp>
 #include <boost/move/utility_core.hpp>
 #include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
 #include <boost/log/detail/config.hpp>
 #include <boost/log/detail/embedded_string_type.hpp>
 #include <boost/log/attributes/attribute.hpp>
@@ -66,7 +67,10 @@ protected:
         /*!
          * Constructor with the stored value initialization
          */
-        explicit impl(BOOST_RV_REF(value_type) value) : base_type(boost::move(value)) {}
+        explicit impl(BOOST_RV_REF(value_type) value) BOOST_NOEXCEPT_IF(boost::is_nothrow_move_constructible< value_type >::value) :
+            base_type(boost::move(value))
+        {
+        }
     };
 
 public:

linx64/include/boost/log/attributes/mutable_constant.hpp

@@ -17,10 +17,10 @@
 
 #include <boost/static_assert.hpp>
 #include <boost/smart_ptr/intrusive_ptr.hpp>
-#include <boost/mpl/if.hpp>
 #include <boost/move/core.hpp>
 #include <boost/move/utility_core.hpp>
 #include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/conditional.hpp>
 #include <boost/log/detail/config.hpp>
 #include <boost/log/detail/locks.hpp>
 #include <boost/log/attributes/attribute.hpp>
@@ -60,7 +60,7 @@ template<
     typename MutexT = void,
     typename ScopedWriteLockT =
 #ifndef BOOST_LOG_NO_THREADS
-        typename mpl::if_c<
+        typename boost::conditional<
             boost::log::aux::is_exclusively_lockable< MutexT >::value,
             boost::log::aux::exclusive_lock_guard< MutexT >,
             void
@@ -70,7 +70,7 @@ template<
 #endif // BOOST_LOG_NO_THREADS
     typename ScopedReadLockT =
 #ifndef BOOST_LOG_NO_THREADS
-        typename mpl::if_c<
+        typename boost::conditional<
             boost::log::aux::is_shared_lockable< MutexT >::value,
             boost::log::aux::shared_lock_guard< MutexT >,
             ScopedWriteLockT

linx64/include/boost/log/attributes/named_scope.hpp

@@ -20,14 +20,15 @@
 #include <memory>
 #include <iterator>
 #include <cstddef>
-#include <boost/log/detail/config.hpp>
 #include <boost/current_function.hpp>
-#include <boost/mpl/if.hpp>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/log/detail/config.hpp>
 #include <boost/log/utility/string_literal.hpp>
 #include <boost/log/utility/unique_identifier_name.hpp>
 #include <boost/log/utility/unused_variable.hpp>
 #include <boost/log/attributes/attribute.hpp>
 #include <boost/log/attributes/attribute_cast.hpp>
+#include <boost/log/detail/allocator_traits.hpp>
 #include <boost/log/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
@@ -124,13 +125,13 @@ public:
     typedef std::allocator< named_scope_entry > allocator_type;
 
     //  Standard types
-    typedef allocator_type::value_type value_type;
-    typedef allocator_type::reference reference;
-    typedef allocator_type::const_reference const_reference;
-    typedef allocator_type::pointer pointer;
-    typedef allocator_type::const_pointer const_pointer;
-    typedef allocator_type::size_type size_type;
-    typedef allocator_type::difference_type difference_type;
+    typedef log::aux::allocator_traits< allocator_type >::value_type value_type;
+    typedef log::aux::allocator_traits< allocator_type >::size_type size_type;
+    typedef log::aux::allocator_traits< allocator_type >::difference_type difference_type;
+    typedef log::aux::allocator_traits< allocator_type >::pointer pointer;
+    typedef log::aux::allocator_traits< allocator_type >::const_pointer const_pointer;
+    typedef value_type& reference;
+    typedef value_type const& const_reference;
 
 #ifndef BOOST_LOG_DOXYGEN_PASS
 
@@ -149,12 +150,12 @@ protected:
         //  Standard typedefs
         typedef named_scope_list::difference_type difference_type;
         typedef named_scope_list::value_type value_type;
-        typedef typename mpl::if_c<
+        typedef typename boost::conditional<
             fConstV,
             named_scope_list::const_reference,
             named_scope_list::reference
         >::type reference;
-        typedef typename mpl::if_c<
+        typedef typename boost::conditional<
             fConstV,
             named_scope_list::const_pointer,
             named_scope_list::pointer
@@ -369,6 +370,7 @@ public:
          * \param sn Scope name.
          * \param fn File name, in which the scope is located.
          * \param ln Line number in the file.
+         * \param t Scope name type.
          */
         sentry(string_literal const& sn, string_literal const& fn, unsigned int ln, scope_entry::scope_name_type t = scope_entry::general) BOOST_NOEXCEPT :
             m_Entry(sn, fn, ln, t)

linx64/include/boost/log/attributes/scoped_attribute.hpp

@@ -15,6 +15,7 @@
 #ifndef BOOST_LOG_ATTRIBUTES_SCOPED_ATTRIBUTE_HPP_INCLUDED_
 #define BOOST_LOG_ATTRIBUTES_SCOPED_ATTRIBUTE_HPP_INCLUDED_
 
+#include <cstddef>
 #include <utility>
 #include <boost/move/core.hpp>
 #include <boost/move/utility_core.hpp>
@@ -81,14 +82,14 @@ public:
         if (res.second)
             m_itAttribute = res.first;
         else
-            m_pLogger = 0; // if there already is a same-named attribute, don't register anything
+            m_pLogger = NULL; // if there already is a same-named attribute, don't register anything
     }
     //! Move constructor
-    scoped_logger_attribute(BOOST_RV_REF(scoped_logger_attribute) that) :
+    scoped_logger_attribute(BOOST_RV_REF(scoped_logger_attribute) that) BOOST_NOEXCEPT :
         m_pLogger(that.m_pLogger),
         m_itAttribute(that.m_itAttribute)
     {
-        that.m_pLogger = 0;
+        that.m_pLogger = NULL;
     }
 
     //! Destructor
@@ -101,9 +102,9 @@ public:
 #ifndef BOOST_LOG_BROKEN_REFERENCE_FROM_RVALUE_INIT
     BOOST_DELETED_FUNCTION(scoped_logger_attribute(scoped_logger_attribute const&))
 #else // BOOST_LOG_BROKEN_REFERENCE_FROM_RVALUE_INIT
-    scoped_logger_attribute(scoped_logger_attribute const& that) : m_pLogger(that.m_pLogger), m_itAttribute(that.m_itAttribute)
+    scoped_logger_attribute(scoped_logger_attribute const& that) BOOST_NOEXCEPT : m_pLogger(that.m_pLogger), m_itAttribute(that.m_itAttribute)
     {
-        const_cast< scoped_logger_attribute& >(that).m_pLogger = 0;
+        const_cast< scoped_logger_attribute& >(that).m_pLogger = NULL;
     }
 #endif // BOOST_LOG_BROKEN_REFERENCE_FROM_RVALUE_INIT