Merge pull request #149 from tklab-tud/sradomski

remerge

8 files changed, 1034 insertions, 1132 deletions

diff --git a/contrib/src/boost/core/addressof.hpp b/contrib/src/boost/core/addressof.hpp
index e9ee303..889b582 100644
--- a/contrib/src/boost/core/addressof.hpp
+++ b/contrib/src/boost/core/addressof.hpp
@@ -1,265 +1,162 @@
-/*

-Copyright (C) 2002 Brad King (brad.king@kitware.com)

-                   Douglas Gregor (gregod@cs.rpi.edu)

-

-Copyright (C) 2002, 2008, 2013 Peter Dimov

-

-Copyright (C) 2017 Glen Joseph Fernandes (glenjofe@gmail.com)

-

-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_CORE_ADDRESSOF_HPP

-#define BOOST_CORE_ADDRESSOF_HPP

-

-#include <boost/config.hpp>

-

-#if defined(BOOST_MSVC_FULL_VER) && BOOST_MSVC_FULL_VER >= 190024215

-#define BOOST_CORE_HAS_BUILTIN_ADDRESSOF

-#elif defined(BOOST_GCC) && BOOST_GCC >= 70000

-#define BOOST_CORE_HAS_BUILTIN_ADDRESSOF

-#elif defined(__has_builtin)

-#if __has_builtin(__builtin_addressof)

-#define BOOST_CORE_HAS_BUILTIN_ADDRESSOF

-#endif

-#endif

-

-#if defined(BOOST_CORE_HAS_BUILTIN_ADDRESSOF)

-#if defined(BOOST_NO_CXX11_CONSTEXPR)

-#define BOOST_CORE_NO_CONSTEXPR_ADDRESSOF

-#endif

-

-namespace boost {

-

-template<class T>

-BOOST_CONSTEXPR inline T*

-addressof(T& o) BOOST_NOEXCEPT

-{

-    return __builtin_addressof(o);

-}

-

-} /* boost */

-#else

-#include <boost/detail/workaround.hpp>

-#include <cstddef>

-

-namespace boost {

-namespace detail {

-

-template<class T>

-class addressof_ref {

-public:

-    BOOST_FORCEINLINE addressof_ref(T& o) BOOST_NOEXCEPT

-        : o_(o) { }

-    BOOST_FORCEINLINE operator T&() const BOOST_NOEXCEPT {

-        return o_;

-    }

-private:

-    addressof_ref& operator=(const addressof_ref&);

-    T& o_;

-};

-

-template<class T>

-struct address_of {

-    static BOOST_FORCEINLINE T* get(T& o, long) BOOST_NOEXCEPT {

-        return reinterpret_cast<T*>(&

-            const_cast<char&>(reinterpret_cast<const volatile char&>(o)));

-    }

-    static BOOST_FORCEINLINE T* get(T* p, int) BOOST_NOEXCEPT {

-        return p;

-    }

-};

-

-#if !defined(BOOST_NO_CXX11_NULLPTR)

-#if !defined(BOOST_NO_CXX11_DECLTYPE) && \

-    (defined(__INTEL_COMPILER) || \

-        (defined(__clang__) && !defined(_LIBCPP_VERSION)))

-typedef decltype(nullptr) addressof_null_t;

-#else

-typedef std::nullptr_t addressof_null_t;

-#endif

-

-template<>

-struct address_of<addressof_null_t> {

-    typedef addressof_null_t type;

-    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {

-        return &o;

-    }

-};

-

-template<>

-struct address_of<const addressof_null_t> {

-    typedef const addressof_null_t type;

-    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {

-        return &o;

-    }

-};

-

-template<>

-struct address_of<volatile addressof_null_t> {

-    typedef volatile addressof_null_t type;

-    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {

-        return &o;

-    }

-};

-

-template<>

-struct address_of<const volatile addressof_null_t> {

-    typedef const volatile addressof_null_t type;

-    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {

-        return &o;

-    }

-};

-#endif

-

-} /* detail */

-

-#if defined(BOOST_NO_CXX11_SFINAE_EXPR) || \

-    defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \

-    defined(BOOST_NO_CXX11_CONSTEXPR) || \

-    defined(BOOST_NO_CXX11_DECLTYPE)

-#define BOOST_CORE_NO_CONSTEXPR_ADDRESSOF

-

-template<class T>

-BOOST_FORCEINLINE T*

-addressof(T& o) BOOST_NOEXCEPT

-{

-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) || \

-    BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120)

-    return detail::address_of<T>::get(o, 0);

-#else

-    return detail::address_of<T>::get(detail::addressof_ref<T>(o), 0);

-#endif

-}

-

-#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))

-namespace detail {

-

-template<class T>

-struct addressof_result {

-    typedef T* type;

-};

-

-} /* detail */

-

-template<class T, std::size_t N>

-BOOST_FORCEINLINE typename detail::addressof_result<T[N]>::type

-addressof(T (&o)[N]) BOOST_NOEXCEPT

-{

-    return &o;

-}

-#endif

-

-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

-template<class T, std::size_t N>

-BOOST_FORCEINLINE

-T (*addressof(T (&o)[N]) BOOST_NOEXCEPT)[N]

-{

-   return reinterpret_cast<T(*)[N]>(&o);

-}

-

-template<class T, std::size_t N>

-BOOST_FORCEINLINE

-const T (*addressof(const T (&o)[N]) BOOST_NOEXCEPT)[N]

-{

-   return reinterpret_cast<const T(*)[N]>(&o);

-}

-#endif

-#else

-namespace detail {

-

-template<class T>

-T&& addressof_declval() BOOST_NOEXCEPT;

-

-template<class>

-struct addressof_void {

-    typedef void type;

-};

-

-template<class T, class E = void>

-struct addressof_member_operator {

-    static constexpr bool value = false;

-};

-

-template<class T>

-struct addressof_member_operator<T, typename

-    addressof_void<decltype(addressof_declval<T&>().operator&())>::type> {

-    static constexpr bool value = true;

-};

-

-#if BOOST_WORKAROUND(BOOST_INTEL, < 1600)

-struct addressof_addressable { };

-

-addressof_addressable*

-operator&(addressof_addressable&) BOOST_NOEXCEPT;

-#endif

-

-template<class T, class E = void>

-struct addressof_non_member_operator {

-    static constexpr bool value = false;

-};

-

-template<class T>

-struct addressof_non_member_operator<T, typename

-    addressof_void<decltype(operator&(addressof_declval<T&>()))>::type> {

-    static constexpr bool value = true;

-};

-

-template<class T, class E = void>

-struct addressof_expression {

-    static constexpr bool value = false;

-};

-

-template<class T>

-struct addressof_expression<T,

-    typename addressof_void<decltype(&addressof_declval<T&>())>::type> {

-    static constexpr bool value = true;

-};

-

-template<class T>

-struct addressof_is_constexpr {

-    static constexpr bool value = addressof_expression<T>::value &&

-        !addressof_member_operator<T>::value &&

-        !addressof_non_member_operator<T>::value;

-};

-

-template<bool E, class T>

-struct addressof_if { };

-

-template<class T>

-struct addressof_if<true, T> {

-    typedef T* type;

-};

-

-template<class T>

-BOOST_FORCEINLINE

-typename addressof_if<!addressof_is_constexpr<T>::value, T>::type

-addressof(T& o) BOOST_NOEXCEPT

-{

-    return address_of<T>::get(addressof_ref<T>(o), 0);

-}

-

-template<class T>

-constexpr BOOST_FORCEINLINE

-typename addressof_if<addressof_is_constexpr<T>::value, T>::type

-addressof(T& o) BOOST_NOEXCEPT

-{

-    return &o;

-}

-

-} /* detail */

-

-template<class T>

-constexpr BOOST_FORCEINLINE T*

-addressof(T& o) BOOST_NOEXCEPT

-{

-    return detail::addressof(o);

-}

-#endif

-

-} /* boost */

-#endif

-

-#endif

+// Copyright (C) 2002 Brad King (brad.king@kitware.com)
+//                    Douglas Gregor (gregod@cs.rpi.edu)
+//
+// Copyright (C) 2002, 2008, 2013 Peter Dimov
+//
+// 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)
+
+// For more information, see http://www.boost.org
+
+#ifndef BOOST_CORE_ADDRESSOF_HPP
+#define BOOST_CORE_ADDRESSOF_HPP
+
+# include <boost/config.hpp>
+# include <boost/detail/workaround.hpp>
+# include <cstddef>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template<class T> struct addr_impl_ref
+{
+    T & v_;
+
+    BOOST_FORCEINLINE addr_impl_ref( T & v ): v_( v ) {}
+    BOOST_FORCEINLINE operator T& () const { return v_; }
+
+private:
+    addr_impl_ref & operator=(const addr_impl_ref &);
+};
+
+template<class T> struct addressof_impl
+{
+    static BOOST_FORCEINLINE T * f( T & v, long )
+    {
+        return reinterpret_cast<T*>(
+            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+    }
+
+    static BOOST_FORCEINLINE T * f( T * v, int )
+    {
+        return v;
+    }
+};
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+#if !defined( BOOST_NO_CXX11_DECLTYPE ) && ( ( defined( __clang__ ) && !defined( _LIBCPP_VERSION ) ) || defined( __INTEL_COMPILER ) )
+
+    typedef decltype(nullptr) addr_nullptr_t;
+
+#else
+
+    typedef std::nullptr_t addr_nullptr_t;
+
+#endif
+
+template<> struct addressof_impl< addr_nullptr_t >
+{
+    typedef addr_nullptr_t T;
+
+    static BOOST_FORCEINLINE T * f( T & v, int )
+    {
+        return &v;
+    }
+};
+
+template<> struct addressof_impl< addr_nullptr_t const >
+{
+    typedef addr_nullptr_t const T;
+
+    static BOOST_FORCEINLINE T * f( T & v, int )
+    {
+        return &v;
+    }
+};
+
+template<> struct addressof_impl< addr_nullptr_t volatile >
+{
+    typedef addr_nullptr_t volatile T;
+
+    static BOOST_FORCEINLINE T * f( T & v, int )
+    {
+        return &v;
+    }
+};
+
+template<> struct addressof_impl< addr_nullptr_t const volatile >
+{
+    typedef addr_nullptr_t const volatile T;
+
+    static BOOST_FORCEINLINE T * f( T & v, int )
+    {
+        return &v;
+    }
+};
+
+#endif
+
+} // namespace detail
+
+template<class T>
+BOOST_FORCEINLINE
+T * addressof( T & v )
+{
+#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || (defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120))
+
+    return boost::detail::addressof_impl<T>::f( v, 0 );
+
+#else
+
+    return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
+
+#endif
+}
+
+#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
+
+namespace detail
+{
+
+template<class T> struct addressof_addp
+{
+    typedef T * type;
+};
+
+} // namespace detail
+
+template< class T, std::size_t N >
+BOOST_FORCEINLINE
+typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
+{
+    return &t;
+}
+
+#endif
+
+// Borland doesn't like casting an array reference to a char reference
+// but these overloads work around the problem.
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template<typename T,std::size_t N>
+BOOST_FORCEINLINE
+T (*addressof(T (&t)[N]))[N]
+{
+   return reinterpret_cast<T(*)[N]>(&t);
+}
+
+template<typename T,std::size_t N>
+BOOST_FORCEINLINE
+const T (*addressof(const T (&t)[N]))[N]
+{
+   return reinterpret_cast<const T(*)[N]>(&t);
+}
+#endif
+
+} // namespace boost
+
+#endif // BOOST_CORE_ADDRESSOF_HPP
diff --git a/contrib/src/boost/core/checked_delete.hpp b/contrib/src/boost/core/checked_delete.hpp
index d750f41..b086e03 100644
--- a/contrib/src/boost/core/checked_delete.hpp
+++ b/contrib/src/boost/core/checked_delete.hpp
@@ -1,69 +1,69 @@
-#ifndef BOOST_CORE_CHECKED_DELETE_HPP

-#define BOOST_CORE_CHECKED_DELETE_HPP

-

-// MS compatible compilers support #pragma once

-

-#if defined(_MSC_VER) && (_MSC_VER >= 1020)

-# pragma once

-#endif

-

-//

-//  boost/checked_delete.hpp

-//

-//  Copyright (c) 2002, 2003 Peter Dimov

-//  Copyright (c) 2003 Daniel Frey

-//  Copyright (c) 2003 Howard Hinnant

-//

-//  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/core/doc/html/core/checked_delete.html for documentation.

-//

-

-namespace boost

-{

-

-// verify that types are complete for increased safety

-

-template<class T> inline void checked_delete(T * x)

-{

-    // intentionally complex - simplification causes regressions

-    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];

-    (void) sizeof(type_must_be_complete);

-    delete x;

-}

-

-template<class T> inline void checked_array_delete(T * x)

-{

-    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];

-    (void) sizeof(type_must_be_complete);

-    delete [] x;

-}

-

-template<class T> struct checked_deleter

-{

-    typedef void result_type;

-    typedef T * argument_type;

-

-    void operator()(T * x) const

-    {

-        // boost:: disables ADL

-        boost::checked_delete(x);

-    }

-};

-

-template<class T> struct checked_array_deleter

-{

-    typedef void result_type;

-    typedef T * argument_type;

-

-    void operator()(T * x) const

-    {

-        boost::checked_array_delete(x);

-    }

-};

-

-} // namespace boost

-

-#endif  // #ifndef BOOST_CORE_CHECKED_DELETE_HPP

+#ifndef BOOST_CORE_CHECKED_DELETE_HPP
+#define BOOST_CORE_CHECKED_DELETE_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/checked_delete.hpp
+//
+//  Copyright (c) 2002, 2003 Peter Dimov
+//  Copyright (c) 2003 Daniel Frey
+//  Copyright (c) 2003 Howard Hinnant
+//
+//  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/core/doc/html/core/checked_delete.html for documentation.
+//
+
+namespace boost
+{
+
+// verify that types are complete for increased safety
+
+template<class T> inline void checked_delete(T * x)
+{
+    // intentionally complex - simplification causes regressions
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete x;
+}
+
+template<class T> inline void checked_array_delete(T * x)
+{
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete [] x;
+}
+
+template<class T> struct checked_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+        // boost:: disables ADL
+        boost::checked_delete(x);
+    }
+};
+
+template<class T> struct checked_array_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+        boost::checked_array_delete(x);
+    }
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_CHECKED_DELETE_HPP
diff --git a/contrib/src/boost/core/demangle.hpp b/contrib/src/boost/core/demangle.hpp
index 7631c65..f13c26a 100644
--- a/contrib/src/boost/core/demangle.hpp
+++ b/contrib/src/boost/core/demangle.hpp
@@ -1,126 +1,131 @@
-#ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED

-#define BOOST_CORE_DEMANGLE_HPP_INCLUDED

-

-// core::demangle

-//

-// Copyright 2014 Peter Dimov

-// Copyright 2014 Andrey Semashev

-//

-// 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

-

-#include <boost/config.hpp>

-#include <string>

-

-#if defined(BOOST_HAS_PRAGMA_ONCE)

-# pragma once

-#endif

-

-// __has_include is currently supported by GCC and Clang. However GCC 4.9 may have issues and

-// returns 1 for 'defined( __has_include )', while '__has_include' is actually not supported:

-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63662

-#if defined( __has_include ) && (!defined( BOOST_GCC ) || (__GNUC__ + 0) >= 5)

-# if __has_include(<cxxabi.h>)

-#  define BOOST_CORE_HAS_CXXABI_H

-# endif

-#elif defined( __GLIBCXX__ ) || defined( __GLIBCPP__ )

-# define BOOST_CORE_HAS_CXXABI_H

-#endif

-

-#if defined( BOOST_CORE_HAS_CXXABI_H )

-# include <cxxabi.h>

-// For some archtectures (mips, mips64, x86, x86_64) cxxabi.h in Android NDK is implemented by gabi++ library

-// (https://android.googlesource.com/platform/ndk/+/master/sources/cxx-stl/gabi++/), which does not implement

-// abi::__cxa_demangle(). We detect this implementation by checking the include guard here.

-# if defined( __GABIXX_CXXABI_H__ )

-#  undef BOOST_CORE_HAS_CXXABI_H

-# else

-#  include <cstdlib>

-#  include <cstddef>

-# endif

-#endif

-

-namespace boost

-{

-

-namespace core

-{

-

-inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT;

-inline void demangle_free( char const * name ) BOOST_NOEXCEPT;

-

-class scoped_demangled_name

-{

-private:

-    char const * m_p;

-

-public:

-    explicit scoped_demangled_name( char const * name ) BOOST_NOEXCEPT :

-        m_p( demangle_alloc( name ) )

-    {

-    }

-

-    ~scoped_demangled_name() BOOST_NOEXCEPT

-    {

-        demangle_free( m_p );

-    }

-

-    char const * get() const BOOST_NOEXCEPT

-    {

-        return m_p;

-    }

-

-    BOOST_DELETED_FUNCTION(scoped_demangled_name( scoped_demangled_name const& ))

-    BOOST_DELETED_FUNCTION(scoped_demangled_name& operator= ( scoped_demangled_name const& ))

-};

-

-

-#if defined( BOOST_CORE_HAS_CXXABI_H )

-

-inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT

-{

-    int status = 0;

-    std::size_t size = 0;

-    return abi::__cxa_demangle( name, NULL, &size, &status );

-}

-

-inline void demangle_free( char const * name ) BOOST_NOEXCEPT

-{

-    std::free( const_cast< char* >( name ) );

-}

-

-inline std::string demangle( char const * name )

-{

-    scoped_demangled_name demangled_name( name );

-    char const * p = demangled_name.get();

-    if( !p )

-        p = name;

-    return p;

-}

-

-#else

-

-inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT

-{

-    return name;

-}

-

-inline void demangle_free( char const * ) BOOST_NOEXCEPT

-{

-}

-

-inline std::string demangle( char const * name )

-{

-    return name;

-}

-

-#endif

-

-} // namespace core

-

-} // namespace boost

-

-#undef BOOST_CORE_HAS_CXXABI_H

-

-#endif // #ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED

+#ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED
+#define BOOST_CORE_DEMANGLE_HPP_INCLUDED
+
+// core::demangle
+//
+// Copyright 2014 Peter Dimov
+// Copyright 2014 Andrey Semashev
+//
+// 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
+
+#include <boost/config.hpp>
+#include <string>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+// __has_include is currently supported by GCC and Clang. However GCC 4.9 may have issues and
+// returns 1 for 'defined( __has_include )', while '__has_include' is actually not supported:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63662
+#if defined( __has_include ) && (!defined( BOOST_GCC ) || (__GNUC__ + 0) >= 5)
+# if __has_include(<cxxabi.h>)
+#  define BOOST_CORE_HAS_CXXABI_H
+# endif
+#elif defined( __GLIBCXX__ ) || defined( __GLIBCPP__ )
+# define BOOST_CORE_HAS_CXXABI_H
+#endif
+
+#if defined( BOOST_CORE_HAS_CXXABI_H )
+# include <cxxabi.h>
+// For some archtectures (mips, mips64, x86, x86_64) cxxabi.h in Android NDK is implemented by gabi++ library
+// (https://android.googlesource.com/platform/ndk/+/master/sources/cxx-stl/gabi++/), which does not implement
+// abi::__cxa_demangle(). We detect this implementation by checking the include guard here.
+# if defined( __GABIXX_CXXABI_H__ )
+#  undef BOOST_CORE_HAS_CXXABI_H
+# else
+#  include <cstdlib>
+#  include <cstddef>
+# endif
+#endif
+
+namespace boost
+{
+
+namespace core
+{
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT;
+inline void demangle_free( char const * name ) BOOST_NOEXCEPT;
+
+class scoped_demangled_name
+{
+private:
+    char const * m_p;
+
+public:
+    explicit scoped_demangled_name( char const * name ) BOOST_NOEXCEPT :
+        m_p( demangle_alloc( name ) )
+    {
+    }
+
+    ~scoped_demangled_name() BOOST_NOEXCEPT
+    {
+        demangle_free( m_p );
+    }
+
+    char const * get() const BOOST_NOEXCEPT
+    {
+        return m_p;
+    }
+
+    BOOST_DELETED_FUNCTION(scoped_demangled_name( scoped_demangled_name const& ))
+    BOOST_DELETED_FUNCTION(scoped_demangled_name& operator= ( scoped_demangled_name const& ))
+};
+
+
+#if defined( BOOST_CORE_HAS_CXXABI_H )
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT
+{
+    int status = 0;
+    std::size_t size = 0;
+    return abi::__cxa_demangle( name, NULL, &size, &status );
+}
+
+inline void demangle_free( char const * name ) BOOST_NOEXCEPT
+{
+    std::free( const_cast< char* >( name ) );
+}
+
+inline std::string demangle( char const * name )
+{
+    scoped_demangled_name demangled_name( name );
+    char const * const p = demangled_name.get();
+    if( p )
+    {
+        return p;
+    }
+    else
+    {
+        return name;
+    }
+}
+
+#else
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT
+{
+    return name;
+}
+
+inline void demangle_free( char const * ) BOOST_NOEXCEPT
+{
+}
+
+inline std::string demangle( char const * name )
+{
+    return name;
+}
+
+#endif
+
+} // namespace core
+
+} // namespace boost
+
+#undef BOOST_CORE_HAS_CXXABI_H
+
+#endif // #ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED
diff --git a/contrib/src/boost/core/enable_if.hpp b/contrib/src/boost/core/enable_if.hpp
index 2816bfc..5dcef1e 100644
--- a/contrib/src/boost/core/enable_if.hpp
+++ b/contrib/src/boost/core/enable_if.hpp
@@ -1,128 +1,128 @@
-// Boost enable_if library

-

-// Copyright 2003 (c) The Trustees of Indiana University.

-

-// Use, modification, and distribution is subject to the Boost Software

-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at

-// http://www.boost.org/LICENSE_1_0.txt)

-

-//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)

-//             Jeremiah Willcock (jewillco at osl.iu.edu)

-//             Andrew Lumsdaine (lums at osl.iu.edu)

-

-

-#ifndef BOOST_CORE_ENABLE_IF_HPP

-#define BOOST_CORE_ENABLE_IF_HPP

-

-#include "boost/config.hpp"

-

-// Even the definition of enable_if causes problems on some compilers,

-// so it's macroed out for all compilers that do not support SFINAE

-

-#ifndef BOOST_NO_SFINAE

-

-namespace boost

-{

-  template<typename T, typename R=void>

-  struct enable_if_has_type

-  {

-    typedef R type;

-  };

- 

-  template <bool B, class T = void>

-  struct enable_if_c {

-    typedef T type;

-  };

-

-  template <class T>

-  struct enable_if_c<false, T> {};

-

-  template <class Cond, class T = void> 

-  struct enable_if : public enable_if_c<Cond::value, T> {};

-

-  template <bool B, class T>

-  struct lazy_enable_if_c {

-    typedef typename T::type type;

-  };

-

-  template <class T>

-  struct lazy_enable_if_c<false, T> {};

-

-  template <class Cond, class T> 

-  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};

-

-

-  template <bool B, class T = void>

-  struct disable_if_c {

-    typedef T type;

-  };

-

-  template <class T>

-  struct disable_if_c<true, T> {};

-

-  template <class Cond, class T = void> 

-  struct disable_if : public disable_if_c<Cond::value, T> {};

-

-  template <bool B, class T>

-  struct lazy_disable_if_c {

-    typedef typename T::type type;

-  };

-

-  template <class T>

-  struct lazy_disable_if_c<true, T> {};

-

-  template <class Cond, class T> 

-  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};

-

-} // namespace boost

-

-#else

-

-namespace boost {

-

-  namespace detail { typedef void enable_if_default_T; }

-

-  template <typename T>

-  struct enable_if_does_not_work_on_this_compiler;

-

-  template<typename T, typename R=void>

-  struct enable_if_has_type : enable_if_does_not_work_on_this_compiler<T>

-  { };

-

-  template <bool B, class T = detail::enable_if_default_T>

-  struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>

-  { };

-

-  template <bool B, class T = detail::enable_if_default_T> 

-  struct disable_if_c : enable_if_does_not_work_on_this_compiler<T>

-  { };

-

-  template <bool B, class T = detail::enable_if_default_T> 

-  struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler<T>

-  { };

-

-  template <bool B, class T = detail::enable_if_default_T> 

-  struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler<T>

-  { };

-

-  template <class Cond, class T = detail::enable_if_default_T> 

-  struct enable_if : enable_if_does_not_work_on_this_compiler<T>

-  { };

-

-  template <class Cond, class T = detail::enable_if_default_T> 

-  struct disable_if : enable_if_does_not_work_on_this_compiler<T>

-  { };

-

-  template <class Cond, class T = detail::enable_if_default_T> 

-  struct lazy_enable_if : enable_if_does_not_work_on_this_compiler<T>

-  { };

-

-  template <class Cond, class T = detail::enable_if_default_T> 

-  struct lazy_disable_if : enable_if_does_not_work_on_this_compiler<T>

-  { };

-

-} // namespace boost

-

-#endif // BOOST_NO_SFINAE

-

-#endif

+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
+//             Jeremiah Willcock (jewillco at osl.iu.edu)
+//             Andrew Lumsdaine (lums at osl.iu.edu)
+
+
+#ifndef BOOST_CORE_ENABLE_IF_HPP
+#define BOOST_CORE_ENABLE_IF_HPP
+
+#include "boost/config.hpp"
+
+// Even the definition of enable_if causes problems on some compilers,
+// so it's macroed out for all compilers that do not support SFINAE
+
+#ifndef BOOST_NO_SFINAE
+
+namespace boost
+{
+  template<typename T, typename R=void>
+  struct enable_if_has_type
+  {
+    typedef R type;
+  };
+ 
+  template <bool B, class T = void>
+  struct enable_if_c {
+    typedef T type;
+  };
+
+  template <class T>
+  struct enable_if_c<false, T> {};
+
+  template <class Cond, class T = void> 
+  struct enable_if : public enable_if_c<Cond::value, T> {};
+
+  template <bool B, class T>
+  struct lazy_enable_if_c {
+    typedef typename T::type type;
+  };
+
+  template <class T>
+  struct lazy_enable_if_c<false, T> {};
+
+  template <class Cond, class T> 
+  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
+
+
+  template <bool B, class T = void>
+  struct disable_if_c {
+    typedef T type;
+  };
+
+  template <class T>
+  struct disable_if_c<true, T> {};
+
+  template <class Cond, class T = void> 
+  struct disable_if : public disable_if_c<Cond::value, T> {};
+
+  template <bool B, class T>
+  struct lazy_disable_if_c {
+    typedef typename T::type type;
+  };
+
+  template <class T>
+  struct lazy_disable_if_c<true, T> {};
+
+  template <class Cond, class T> 
+  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
+
+} // namespace boost
+
+#else
+
+namespace boost {
+
+  namespace detail { typedef void enable_if_default_T; }
+
+  template <typename T>
+  struct enable_if_does_not_work_on_this_compiler;
+
+  template<typename T, typename R=void>
+  struct enable_if_has_type : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <bool B, class T = detail::enable_if_default_T>
+  struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <bool B, class T = detail::enable_if_default_T> 
+  struct disable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <bool B, class T = detail::enable_if_default_T> 
+  struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <bool B, class T = detail::enable_if_default_T> 
+  struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct enable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct disable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct lazy_enable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct lazy_disable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+} // namespace boost
+
+#endif // BOOST_NO_SFINAE
+
+#endif
diff --git a/contrib/src/boost/core/no_exceptions_support.hpp b/contrib/src/boost/core/no_exceptions_support.hpp
index 7365d19..a697f01 100644
--- a/contrib/src/boost/core/no_exceptions_support.hpp
+++ b/contrib/src/boost/core/no_exceptions_support.hpp
@@ -1,44 +1,44 @@
-#ifndef BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP

-#define BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP

-

-#if defined(_MSC_VER)

-#  pragma once

-#endif

-

-//----------------------------------------------------------------------

-// (C) Copyright 2004 Pavel Vozenilek.

-// Use, modification and distribution is subject to the Boost Software

-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt

-// or copy at http://www.boost.org/LICENSE_1_0.txt)

-//

-//

-// This file contains helper macros used when exception support may be

-// disabled (as indicated by macro BOOST_NO_EXCEPTIONS).

-//

-// Before picking up these macros you may consider using RAII techniques

-// to deal with exceptions - their syntax can be always the same with 

-// or without exception support enabled.

-//----------------------------------------------------------------------

-

-#include <boost/config.hpp>

-#include <boost/detail/workaround.hpp>

-

-#if !(defined BOOST_NO_EXCEPTIONS)

-#    define BOOST_TRY { try

-#    define BOOST_CATCH(x) catch(x)

-#    define BOOST_RETHROW throw;

-#    define BOOST_CATCH_END }

-#else

-#    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

-#        define BOOST_TRY { if ("")

-#        define BOOST_CATCH(x) else if (!"")

-#    else

-#        define BOOST_TRY { if (true)

-#        define BOOST_CATCH(x) else if (false)

-#    endif

-#    define BOOST_RETHROW

-#    define BOOST_CATCH_END }

-#endif

-

-

-#endif 

+#ifndef BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP
+#define BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP
+
+#if defined(_MSC_VER)
+#  pragma once
+#endif
+
+//----------------------------------------------------------------------
+// (C) Copyright 2004 Pavel Vozenilek.
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//
+// This file contains helper macros used when exception support may be
+// disabled (as indicated by macro BOOST_NO_EXCEPTIONS).
+//
+// Before picking up these macros you may consider using RAII techniques
+// to deal with exceptions - their syntax can be always the same with 
+// or without exception support enabled.
+//----------------------------------------------------------------------
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if !(defined BOOST_NO_EXCEPTIONS)
+#    define BOOST_TRY { try
+#    define BOOST_CATCH(x) catch(x)
+#    define BOOST_RETHROW throw;
+#    define BOOST_CATCH_END }
+#else
+#    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#        define BOOST_TRY { if ("")
+#        define BOOST_CATCH(x) else if (!"")
+#    else
+#        define BOOST_TRY { if (true)
+#        define BOOST_CATCH(x) else if (false)
+#    endif
+#    define BOOST_RETHROW
+#    define BOOST_CATCH_END }
+#endif
+
+
+#endif 
diff --git a/contrib/src/boost/core/noncopyable.hpp b/contrib/src/boost/core/noncopyable.hpp
index a4c2075..6ae8c24 100644
--- a/contrib/src/boost/core/noncopyable.hpp
+++ b/contrib/src/boost/core/noncopyable.hpp
@@ -1,48 +1,48 @@
-//  Boost noncopyable.hpp header file  --------------------------------------//

-

-//  (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)

-

-//  See http://www.boost.org/libs/utility for documentation.

-

-#ifndef BOOST_CORE_NONCOPYABLE_HPP

-#define 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:

-#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)

-      BOOST_CONSTEXPR noncopyable() = default;

-      ~noncopyable() = default;

-#else

-      noncopyable() {}

-      ~noncopyable() {}

-#endif

-#if !defined(BOOST_NO_CXX11_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_CORE_NONCOPYABLE_HPP

+//  Boost noncopyable.hpp header file  --------------------------------------//
+
+//  (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)
+
+//  See http://www.boost.org/libs/utility for documentation.
+
+#ifndef BOOST_CORE_NONCOPYABLE_HPP
+#define 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:
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
+      BOOST_CONSTEXPR noncopyable() = default;
+      ~noncopyable() = default;
+#else
+      noncopyable() {}
+      ~noncopyable() {}
+#endif
+#if !defined(BOOST_NO_CXX11_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_CORE_NONCOPYABLE_HPP
diff --git a/contrib/src/boost/core/ref.hpp b/contrib/src/boost/core/ref.hpp
index 60f01a4..47dc858 100644
--- a/contrib/src/boost/core/ref.hpp
+++ b/contrib/src/boost/core/ref.hpp
@@ -1,301 +1,301 @@
-#ifndef BOOST_CORE_REF_HPP

-#define BOOST_CORE_REF_HPP

-

-// MS compatible compilers support #pragma once

-

-#if defined(_MSC_VER) && (_MSC_VER >= 1020)

-# pragma once

-#endif

-

-#include <boost/config.hpp>

-#include <boost/utility/addressof.hpp>

-#include <boost/detail/workaround.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

-//

-//  Copyright (C) 2014 Glen Joseph Fernandes

-//  glenfe at live dot com

-//  Copyright (C) 2014 Agustin Berge

-//

-// 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/core/doc/html/core/ref.html for documentation.

-//

-

-/**

- @file

-*/

-

-/**

- Boost namespace.

-*/

-namespace boost

-{

-

-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )

-

-    struct ref_workaround_tag {};

-

-#endif

-

-// reference_wrapper

-

-/**

- @brief Contains a reference to an object of type `T`.

-

- `reference_wrapper` is primarily used to "feed" references to

- function templates (algorithms) that take their parameter by

- value. It provides an implicit conversion to `T&`, which

- usually allows the function templates to work on references

- unmodified.

-*/

-template<class T> class reference_wrapper

-{

-public:

-    /**

-     Type `T`.

-    */

-    typedef T type;

-

-    /**

-     Constructs a `reference_wrapper` object that stores a

-     reference to `t`.

-

-     @remark Does not throw.

-    */

-    BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}

-

-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )

-

-    BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( boost::addressof( t ) ) {}

-

-#endif

-

-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

-    /**

-     @remark Construction from a temporary object is disabled.

-    */

-    BOOST_DELETED_FUNCTION(reference_wrapper(T&& t))

-public:

-#endif

-

-    /**

-     @return The stored reference.

-     @remark Does not throw.

-    */

-    BOOST_FORCEINLINE operator T& () const { return *t_; }

-

-    /**

-     @return The stored reference.

-     @remark Does not throw.

-    */

-    BOOST_FORCEINLINE T& get() const { return *t_; }

-

-    /**

-     @return A pointer to the object referenced by the stored

-       reference.

-     @remark Does not throw.

-    */

-    BOOST_FORCEINLINE T* get_pointer() const { return t_; }

-

-private:

-

-    T* t_;

-};

-

-// ref

-

-/**

- @cond

-*/

-#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )

-#  define BOOST_REF_CONST

-#else

-#  define BOOST_REF_CONST const

-#endif

-/**

- @endcond

-*/

-

-/**

- @return `reference_wrapper<T>(t)`

- @remark Does not throw.

-*/

-template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t )

-{

-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )

-

-    return reference_wrapper<T>( t, ref_workaround_tag() );

-

-#else

-

-    return reference_wrapper<T>( t );

-

-#endif

-}

-

-// cref

-

-/**

- @return `reference_wrapper<T const>(t)`

- @remark Does not throw.

-*/

-template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t )

-{

-    return reference_wrapper<T const>(t);

-}

-

-#undef BOOST_REF_CONST

-

-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

-

-/**

- @cond

-*/

-#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)

-#  define BOOST_REF_DELETE

-#else

-#  define BOOST_REF_DELETE = delete

-#endif

-/**

- @endcond

-*/

-

-/**

- @remark Construction from a temporary object is disabled.

-*/

-template<class T> void ref(T const&&) BOOST_REF_DELETE;

-

-/**

- @remark Construction from a temporary object is disabled.

-*/

-template<class T> void cref(T const&&) BOOST_REF_DELETE;

-

-#undef BOOST_REF_DELETE

-

-#endif

-

-// is_reference_wrapper

-

-/**

- @brief Determine if a type `T` is an instantiation of

- `reference_wrapper`.

-

- The value static constant will be true if the type `T` is a

- specialization of `reference_wrapper`.

-*/

-template<typename T> struct is_reference_wrapper

-{

-    BOOST_STATIC_CONSTANT( bool, value = false );

-};

-

-/**

- @cond

-*/

-template<typename T> struct is_reference_wrapper< reference_wrapper<T> >

-{

-    BOOST_STATIC_CONSTANT( bool, value = true );

-};

-

-#if !defined(BOOST_NO_CV_SPECIALIZATIONS)

-

-template<typename T> struct is_reference_wrapper< reference_wrapper<T> const >

-{

-    BOOST_STATIC_CONSTANT( bool, value = true );

-};

-

-template<typename T> struct is_reference_wrapper< reference_wrapper<T> volatile >

-{

-    BOOST_STATIC_CONSTANT( bool, value = true );

-};

-

-template<typename T> struct is_reference_wrapper< reference_wrapper<T> const volatile >

-{

-    BOOST_STATIC_CONSTANT( bool, value = true );

-};

-

-#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)

-

-/**

- @endcond

-*/

-

-

-// unwrap_reference

-

-/**

- @brief Find the type in a `reference_wrapper`.

-

- The `typedef` type is `T::type` if `T` is a

- `reference_wrapper`, `T` otherwise.

-*/

-template<typename T> struct unwrap_reference

-{

-    typedef T type;

-};

-

-/**

- @cond

-*/

-template<typename T> struct unwrap_reference< reference_wrapper<T> >

-{

-    typedef T type;

-};

-

-#if !defined(BOOST_NO_CV_SPECIALIZATIONS)

-

-template<typename T> struct unwrap_reference< reference_wrapper<T> const >

-{

-    typedef T type;

-};

-

-template<typename T> struct unwrap_reference< reference_wrapper<T> volatile >

-{

-    typedef T type;

-};

-

-template<typename T> struct unwrap_reference< reference_wrapper<T> const volatile >

-{

-    typedef T type;

-};

-

-#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)

-

-/**

- @endcond

-*/

-

-// unwrap_ref

-

-/**

- @return `unwrap_reference<T>::type&(t)`

- @remark Does not throw.

-*/

-template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t )

-{

-    return t;

-}

-

-// get_pointer

-

-/**

- @cond

-*/

-template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r )

-{

-    return r.get_pointer();

-}

-/**

- @endcond

-*/

-

-} // namespace boost

-

-#endif // #ifndef BOOST_CORE_REF_HPP

+#ifndef BOOST_CORE_REF_HPP
+#define BOOST_CORE_REF_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/detail/workaround.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
+//
+//  Copyright (C) 2014 Glen Joseph Fernandes
+//  glenfe at live dot com
+//  Copyright (C) 2014 Agustin Berge
+//
+// 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/core/doc/html/core/ref.html for documentation.
+//
+
+/**
+ @file
+*/
+
+/**
+ Boost namespace.
+*/
+namespace boost
+{
+
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
+
+    struct ref_workaround_tag {};
+
+#endif
+
+// reference_wrapper
+
+/**
+ @brief Contains a reference to an object of type `T`.
+
+ `reference_wrapper` is primarily used to "feed" references to
+ function templates (algorithms) that take their parameter by
+ value. It provides an implicit conversion to `T&`, which
+ usually allows the function templates to work on references
+ unmodified.
+*/
+template<class T> class reference_wrapper
+{
+public:
+    /**
+     Type `T`.
+    */
+    typedef T type;
+
+    /**
+     Constructs a `reference_wrapper` object that stores a
+     reference to `t`.
+
+     @remark Does not throw.
+    */
+    BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
+
+    BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( boost::addressof( t ) ) {}
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    /**
+     @remark Construction from a temporary object is disabled.
+    */
+    BOOST_DELETED_FUNCTION(reference_wrapper(T&& t))
+public:
+#endif
+
+    /**
+     @return The stored reference.
+     @remark Does not throw.
+    */
+    BOOST_FORCEINLINE operator T& () const { return *t_; }
+
+    /**
+     @return The stored reference.
+     @remark Does not throw.
+    */
+    BOOST_FORCEINLINE T& get() const { return *t_; }
+
+    /**
+     @return A pointer to the object referenced by the stored
+       reference.
+     @remark Does not throw.
+    */
+    BOOST_FORCEINLINE T* get_pointer() const { return t_; }
+
+private:
+
+    T* t_;
+};
+
+// ref
+
+/**
+ @cond
+*/
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
+#  define BOOST_REF_CONST
+#else
+#  define BOOST_REF_CONST const
+#endif
+/**
+ @endcond
+*/
+
+/**
+ @return `reference_wrapper<T>(t)`
+ @remark Does not throw.
+*/
+template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t )
+{
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
+
+    return reference_wrapper<T>( t, ref_workaround_tag() );
+
+#else
+
+    return reference_wrapper<T>( t );
+
+#endif
+}
+
+// cref
+
+/**
+ @return `reference_wrapper<T const>(t)`
+ @remark Does not throw.
+*/
+template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t )
+{
+    return reference_wrapper<T const>(t);
+}
+
+#undef BOOST_REF_CONST
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+/**
+ @cond
+*/
+#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+#  define BOOST_REF_DELETE
+#else
+#  define BOOST_REF_DELETE = delete
+#endif
+/**
+ @endcond
+*/
+
+/**
+ @remark Construction from a temporary object is disabled.
+*/
+template<class T> void ref(T const&&) BOOST_REF_DELETE;
+
+/**
+ @remark Construction from a temporary object is disabled.
+*/
+template<class T> void cref(T const&&) BOOST_REF_DELETE;
+
+#undef BOOST_REF_DELETE
+
+#endif
+
+// is_reference_wrapper
+
+/**
+ @brief Determine if a type `T` is an instantiation of
+ `reference_wrapper`.
+
+ The value static constant will be true if the type `T` is a
+ specialization of `reference_wrapper`.
+*/
+template<typename T> struct is_reference_wrapper
+{
+    BOOST_STATIC_CONSTANT( bool, value = false );
+};
+
+/**
+ @cond
+*/
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> const >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> volatile >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> const volatile >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+/**
+ @endcond
+*/
+
+
+// unwrap_reference
+
+/**
+ @brief Find the type in a `reference_wrapper`.
+
+ The `typedef` type is `T::type` if `T` is a
+ `reference_wrapper`, `T` otherwise.
+*/
+template<typename T> struct unwrap_reference
+{
+    typedef T type;
+};
+
+/**
+ @cond
+*/
+template<typename T> struct unwrap_reference< reference_wrapper<T> >
+{
+    typedef T type;
+};
+
+#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> const >
+{
+    typedef T type;
+};
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> volatile >
+{
+    typedef T type;
+};
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> const volatile >
+{
+    typedef T type;
+};
+
+#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+/**
+ @endcond
+*/
+
+// unwrap_ref
+
+/**
+ @return `unwrap_reference<T>::type&(t)`
+ @remark Does not throw.
+*/
+template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t )
+{
+    return t;
+}
+
+// get_pointer
+
+/**
+ @cond
+*/
+template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r )
+{
+    return r.get_pointer();
+}
+/**
+ @endcond
+*/
+
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_REF_HPP
diff --git a/contrib/src/boost/core/typeinfo.hpp b/contrib/src/boost/core/typeinfo.hpp
index abd7b41..e67b4a3 100644
--- a/contrib/src/boost/core/typeinfo.hpp
+++ b/contrib/src/boost/core/typeinfo.hpp
@@ -1,151 +1,151 @@
-#ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED

-#define BOOST_CORE_TYPEINFO_HPP_INCLUDED

-

-// MS compatible compilers support #pragma once

-

-#if defined(_MSC_VER) && (_MSC_VER >= 1020)

-# pragma once

-#endif

-

-//  core::typeinfo, BOOST_CORE_TYPEID

-//

-//  Copyright 2007, 2014 Peter Dimov

-//

-//  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)

-

-#include <boost/config.hpp>

-

-#if defined( BOOST_NO_TYPEID )

-

-#include <boost/current_function.hpp>

-#include <functional>

-

-namespace boost

-{

-

-namespace core

-{

-

-class typeinfo

-{

-private:

-

-    typeinfo( typeinfo const& );

-    typeinfo& operator=( typeinfo const& );

-

-    char const * name_;

-

-public:

-

-    explicit typeinfo( char const * name ): name_( name )

-    {

-    }

-

-    bool operator==( typeinfo const& rhs ) const

-    {

-        return this == &rhs;

-    }

-

-    bool operator!=( typeinfo const& rhs ) const

-    {

-        return this != &rhs;

-    }

-

-    bool before( typeinfo const& rhs ) const

-    {

-        return std::less< typeinfo const* >()( this, &rhs );

-    }

-

-    char const* name() const

-    {

-        return name_;

-    }

-};

-

-inline char const * demangled_name( core::typeinfo const & ti )

-{

-    return ti.name();

-}

-

-} // namespace core

-

-namespace detail

-{

-

-template<class T> struct core_typeid_

-{

-    static boost::core::typeinfo ti_;

-

-    static char const * name()

-    {

-        return BOOST_CURRENT_FUNCTION;

-    }

-};

-

-#if defined(__SUNPRO_CC)

-// see #4199, the Sun Studio compiler gets confused about static initialization 

-// constructor arguments. But an assignment works just fine. 

-template<class T> boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name();

-#else

-template<class T> boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name());

-#endif

-

-template<class T> struct core_typeid_< T & >: core_typeid_< T >

-{

-};

-

-template<class T> struct core_typeid_< T const >: core_typeid_< T >

-{

-};

-

-template<class T> struct core_typeid_< T volatile >: core_typeid_< T >

-{

-};

-

-template<class T> struct core_typeid_< T const volatile >: core_typeid_< T >

-{

-};

-

-} // namespace detail

-

-} // namespace boost

-

-#define BOOST_CORE_TYPEID(T) (boost::detail::core_typeid_<T>::ti_)

-

-#else

-

-#include <boost/core/demangle.hpp>

-#include <typeinfo>

-

-namespace boost

-{

-

-namespace core

-{

-

-#if defined( BOOST_NO_STD_TYPEINFO )

-

-typedef ::type_info typeinfo;

-

-#else

-

-typedef std::type_info typeinfo;

-

-#endif

-

-inline std::string demangled_name( core::typeinfo const & ti )

-{

-    return core::demangle( ti.name() );

-}

-

-} // namespace core

-

-} // namespace boost

-

-#define BOOST_CORE_TYPEID(T) typeid(T)

-

-#endif

-

-#endif  // #ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED

+#ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED
+#define BOOST_CORE_TYPEINFO_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  core::typeinfo, BOOST_CORE_TYPEID
+//
+//  Copyright 2007, 2014 Peter Dimov
+//
+//  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)
+
+#include <boost/config.hpp>
+
+#if defined( BOOST_NO_TYPEID )
+
+#include <boost/current_function.hpp>
+#include <functional>
+
+namespace boost
+{
+
+namespace core
+{
+
+class typeinfo
+{
+private:
+
+    typeinfo( typeinfo const& );
+    typeinfo& operator=( typeinfo const& );
+
+    char const * name_;
+
+public:
+
+    explicit typeinfo( char const * name ): name_( name )
+    {
+    }
+
+    bool operator==( typeinfo const& rhs ) const
+    {
+        return this == &rhs;
+    }
+
+    bool operator!=( typeinfo const& rhs ) const
+    {
+        return this != &rhs;
+    }
+
+    bool before( typeinfo const& rhs ) const
+    {
+        return std::less< typeinfo const* >()( this, &rhs );
+    }
+
+    char const* name() const
+    {
+        return name_;
+    }
+};
+
+inline char const * demangled_name( core::typeinfo const & ti )
+{
+    return ti.name();
+}
+
+} // namespace core
+
+namespace detail
+{
+
+template<class T> struct core_typeid_
+{
+    static boost::core::typeinfo ti_;
+
+    static char const * name()
+    {
+        return BOOST_CURRENT_FUNCTION;
+    }
+};
+
+#if defined(__SUNPRO_CC)
+// see #4199, the Sun Studio compiler gets confused about static initialization 
+// constructor arguments. But an assignment works just fine. 
+template<class T> boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name();
+#else
+template<class T> boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name());
+#endif
+
+template<class T> struct core_typeid_< T & >: core_typeid_< T >
+{
+};
+
+template<class T> struct core_typeid_< T const >: core_typeid_< T >
+{
+};
+
+template<class T> struct core_typeid_< T volatile >: core_typeid_< T >
+{
+};
+
+template<class T> struct core_typeid_< T const volatile >: core_typeid_< T >
+{
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_CORE_TYPEID(T) (boost::detail::core_typeid_<T>::ti_)
+
+#else
+
+#include <boost/core/demangle.hpp>
+#include <typeinfo>
+
+namespace boost
+{
+
+namespace core
+{
+
+#if defined( BOOST_NO_STD_TYPEINFO )
+
+typedef ::type_info typeinfo;
+
+#else
+
+typedef std::type_info typeinfo;
+
+#endif
+
+inline std::string demangled_name( core::typeinfo const & ti )
+{
+    return core::demangle( ti.name() );
+}
+
+} // namespace core
+
+} // namespace boost
+
+#define BOOST_CORE_TYPEID(T) typeid(T)
+
+#endif
+
+#endif  // #ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED