summaryrefslogtreecommitdiffstats
path: root/contrib/src/boost/intrusive/detail
diff options
context:
space:
mode:
authorStefan Radomski <github@mintwerk.de>2017-06-27 11:11:13 (GMT)
committerGitHub <noreply@github.com>2017-06-27 11:11:13 (GMT)
commite24393f41834f116038faf6c6d5012575a67136a (patch)
treea1e83679e55781bc92849a07c5acda7b5c09908c /contrib/src/boost/intrusive/detail
parentb3a2d91805feb81f79ee52c30a077521912b0bf9 (diff)
parent3a5692f40663282640775f8ff497c4860d265a2a (diff)
downloaduscxml-e24393f41834f116038faf6c6d5012575a67136a.zip
uscxml-e24393f41834f116038faf6c6d5012575a67136a.tar.gz
uscxml-e24393f41834f116038faf6c6d5012575a67136a.tar.bz2
Merge pull request #149 from tklab-tud/sradomski
remerge
Diffstat (limited to 'contrib/src/boost/intrusive/detail')
-rw-r--r--contrib/src/boost/intrusive/detail/algorithm.hpp90
-rw-r--r--contrib/src/boost/intrusive/detail/config_begin.hpp56
-rw-r--r--contrib/src/boost/intrusive/detail/config_end.hpp15
-rw-r--r--contrib/src/boost/intrusive/detail/has_member_function_callable_with.hpp341
-rw-r--r--contrib/src/boost/intrusive/detail/iterator.hpp156
-rw-r--r--contrib/src/boost/intrusive/detail/minimal_less_equal_header.hpp30
-rw-r--r--contrib/src/boost/intrusive/detail/minimal_pair_header.hpp30
-rw-r--r--contrib/src/boost/intrusive/detail/mpl.hpp206
-rw-r--r--contrib/src/boost/intrusive/detail/pointer_element.hpp168
-rw-r--r--contrib/src/boost/intrusive/detail/reverse_iterator.hpp165
-rw-r--r--contrib/src/boost/intrusive/detail/std_fwd.hpp43
-rw-r--r--contrib/src/boost/intrusive/detail/to_raw_pointer.hpp47
-rw-r--r--contrib/src/boost/intrusive/detail/workaround.hpp50
13 files changed, 1397 insertions, 0 deletions
diff --git a/contrib/src/boost/intrusive/detail/algorithm.hpp b/contrib/src/boost/intrusive/detail/algorithm.hpp
new file mode 100644
index 0000000..d2421ff
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/algorithm.hpp
@@ -0,0 +1,90 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-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/intrusive for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_DETAIL_ALGORITHM_HPP
+#define BOOST_INTRUSIVE_DETAIL_ALGORITHM_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+namespace boost {
+namespace intrusive {
+
+struct algo_pred_equal
+{
+ template<class T>
+ bool operator()(const T &x, const T &y) const
+ { return x == y; }
+};
+
+struct algo_pred_less
+{
+ template<class T>
+ bool operator()(const T &x, const T &y) const
+ { return x < y; }
+};
+
+template<class InputIt1, class InputIt2, class BinaryPredicate>
+bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate p)
+{
+ for (; first1 != last1; ++first1, ++first2) {
+ if (!p(*first1, *first2)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+template<class InputIt1, class InputIt2>
+bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2)
+{ return (algo_equal)(first1, last1, first2, algo_pred_equal()); }
+
+template<class InputIt1, class InputIt2, class BinaryPredicate>
+bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate pred)
+{
+ for (; first1 != last1 && first2 != last2; ++first1, ++first2)
+ if (!pred(*first1, *first2))
+ return false;
+ return first1 == last1 && first2 == last2;
+}
+
+template<class InputIt1, class InputIt2>
+bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
+{ return (algo_equal)(first1, last1, first2, last2, algo_pred_equal()); }
+
+template <class InputIterator1, class InputIterator2, class BinaryPredicate>
+ bool algo_lexicographical_compare (InputIterator1 first1, InputIterator1 last1,
+ InputIterator2 first2, InputIterator2 last2,
+ BinaryPredicate pred)
+{
+ while (first1 != last1){
+ if (first2 == last2 || *first2 < *first1) return false;
+ else if (pred(*first1, *first2)) return true;
+ ++first1; ++first2;
+ }
+ return (first2 != last2);
+}
+
+template <class InputIterator1, class InputIterator2>
+ bool algo_lexicographical_compare (InputIterator1 first1, InputIterator1 last1,
+ InputIterator2 first2, InputIterator2 last2)
+{ return (algo_lexicographical_compare)(first1, last1, first2, last2, algo_pred_less()); }
+
+} //namespace intrusive {
+} //namespace boost {
+
+#endif //#ifndef BOOST_INTRUSIVE_DETAIL_ALGORITHM_HPP
diff --git a/contrib/src/boost/intrusive/detail/config_begin.hpp b/contrib/src/boost/intrusive/detail/config_begin.hpp
new file mode 100644
index 0000000..cef8616
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/config_begin.hpp
@@ -0,0 +1,56 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006-2013
+//
+// 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/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+
+#ifdef BOOST_MSVC
+
+ #pragma warning (push)
+ //
+ //'function' : resolved overload was found by argument-dependent lookup
+ //A function found by argument-dependent lookup (Koenig lookup) was eventually
+ //chosen by overload resolution.
+ //
+ //In Visual C++ .NET and earlier compilers, a different function would have
+ //been called. To pick the original function, use an explicitly qualified name.
+ //
+
+ //warning C4275: non dll-interface class 'x' used as base for
+ //dll-interface class 'Y'
+ #pragma warning (disable : 4275)
+ //warning C4251: 'x' : class 'y' needs to have dll-interface to
+ //be used by clients of class 'z'
+ #pragma warning (disable : 4251)
+ #pragma warning (disable : 4675)
+ #pragma warning (disable : 4996)
+ #pragma warning (disable : 4503)
+ #pragma warning (disable : 4284) // odd return type for operator->
+ #pragma warning (disable : 4244) // possible loss of data
+ #pragma warning (disable : 4521) ////Disable "multiple copy constructors specified"
+ #pragma warning (disable : 4127) //conditional expression is constant
+ #pragma warning (disable : 4146)
+ #pragma warning (disable : 4267) //conversion from 'X' to 'Y', possible loss of data
+ #pragma warning (disable : 4541) //'typeid' used on polymorphic type 'boost::exception' with /GR-
+ #pragma warning (disable : 4512) //'typeid' used on polymorphic type 'boost::exception' with /GR-
+ #pragma warning (disable : 4522)
+ #pragma warning (disable : 4706) //assignment within conditional expression
+ #pragma warning (disable : 4710) // function not inlined
+ #pragma warning (disable : 4714) // "function": marked as __forceinline not inlined
+ #pragma warning (disable : 4711) // function selected for automatic inline expansion
+ #pragma warning (disable : 4786) // identifier truncated in debug info
+ #pragma warning (disable : 4996) // "function": was declared deprecated
+#endif
+
+//#define BOOST_INTRUSIVE_USE_ITERATOR_FACADE
+//#define BOOST_INTRUSIVE_USE_ITERATOR_ENABLE_IF_CONVERTIBLE
diff --git a/contrib/src/boost/intrusive/detail/config_end.hpp b/contrib/src/boost/intrusive/detail/config_end.hpp
new file mode 100644
index 0000000..a081443
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/config_end.hpp
@@ -0,0 +1,15 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006-2013
+//
+// 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/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined BOOST_MSVC
+ #pragma warning (pop)
+#endif
diff --git a/contrib/src/boost/intrusive/detail/has_member_function_callable_with.hpp b/contrib/src/boost/intrusive/detail/has_member_function_callable_with.hpp
new file mode 100644
index 0000000..2e73305
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/has_member_function_callable_with.hpp
@@ -0,0 +1,341 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
+
+//Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and
+//wrong SFINAE for GCC 4.2/4.3
+#if defined(__GNUC__) && !defined(__clang__) && ((__GNUC__*100 + __GNUC_MINOR__*10) >= 340) && ((__GNUC__*100 + __GNUC_MINOR__*10) <= 430)
+ #define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
+#elif defined(BOOST_INTEL) && (BOOST_INTEL < 1200 )
+ #define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
+#endif
+#include <cstddef>
+#include <boost/move/utility_core.hpp>
+#include <boost/move/detail/fwd_macros.hpp>
+
+namespace boost_intrusive_hmfcw {
+
+typedef char yes_type;
+struct no_type{ char dummy[2]; };
+
+#if defined(BOOST_NO_CXX11_DECLTYPE)
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+template<class T>
+struct make_dontcare
+{
+ typedef dont_care type;
+};
+
+#endif
+
+struct dont_care
+{
+ dont_care(...);
+};
+
+struct private_type
+{
+ static private_type p;
+ private_type const &operator,(int) const;
+};
+
+template<typename T>
+no_type is_private_type(T const &);
+yes_type is_private_type(private_type const &);
+
+#endif //#if defined(BOOST_NO_CXX11_DECLTYPE)
+
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+template<typename T> struct remove_cv { typedef T type; };
+template<typename T> struct remove_cv<const T> { typedef T type; };
+template<typename T> struct remove_cv<const volatile T> { typedef T type; };
+template<typename T> struct remove_cv<volatile T> { typedef T type; };
+
+#endif
+
+} //namespace boost_intrusive_hmfcw {
+
+#endif //BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
+
+#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
+ #error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME before including this header!"
+#endif
+
+#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
+ #error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN before including this header!"
+#endif
+
+#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX
+ #error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX before including this header!"
+#endif
+
+#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX < BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
+ #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX value MUST be greater or equal than BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN!"
+#endif
+
+#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX == 0
+ #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF
+#else
+ #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF ,
+#endif
+
+#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
+ #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG not defined!"
+#endif
+
+#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
+ #error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END not defined!"
+#endif
+
+BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE)
+ //With decltype and variadic templaes, things are pretty easy
+ template<typename Fun, class ...Args>
+ struct BOOST_MOVE_CAT(has_member_function_callable_with_,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+ {
+ template<class U>
+ static decltype(boost::move_detail::declval<U>().
+ BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(::boost::move_detail::declval<Args>()...)
+ , boost_intrusive_hmfcw::yes_type()) Test(U* f);
+ template<class U>
+ static boost_intrusive_hmfcw::no_type Test(...);
+ static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);
+ };
+
+#else //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_DECLTYPE)
+
+ /////////////////////////////////////////////////////////
+ /////////////////////////////////////////////////////////
+ //
+ // has_member_function_callable_with_impl_XXX
+ // declaration, special case and 0 arg specializaton
+ //
+ /////////////////////////////////////////////////////////
+ /////////////////////////////////////////////////////////
+
+ #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ /////////////////////////////////////////////////////////
+ /////////////////////////////////////////////////////////
+ //
+ // has_member_function_callable_with_impl_XXX for 1 to N arguments
+ //
+ /////////////////////////////////////////////////////////
+ /////////////////////////////////////////////////////////
+
+ //defined(BOOST_NO_CXX11_DECLTYPE) must be true
+ template<class Fun, class ...DontCares>
+ struct FunWrapTmpl : Fun
+ {
+ using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;
+ boost_intrusive_hmfcw::private_type BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(DontCares...) const;
+ };
+
+ template<typename Fun, class ...Args>
+ struct BOOST_MOVE_CAT(has_member_function_callable_with_,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, Args...>
+ {
+ typedef FunWrapTmpl<typename boost_intrusive_hmfcw::make_dontcare<Args>::type...> FunWrap;
+
+ static bool const value = (sizeof(boost_intrusive_hmfcw::no_type) ==
+ sizeof(boost_intrusive_hmfcw::is_private_type
+ ( (::boost::move_detail::declval< FunWrap<Fun> >().
+ BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(::boost::move_detail::declval<Args>()...), 0) )
+ )
+ );
+ };
+ #else //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+ //Preprocessor must be used to generate specializations instead of variadic templates
+
+ template <typename Type>
+ class BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+ {
+ struct BaseMixin
+ {
+ void BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()
+ {} //Some compilers require the definition or linker errors happen
+ };
+
+ struct Base
+ : public boost_intrusive_hmfcw::remove_cv<Type>::type, public BaseMixin
+ { //Declare the unneeded default constructor as some old compilers wrongly require it with is_convertible
+ Base(){}
+ };
+ template <typename T, T t> class Helper{};
+
+ template <typename U>
+ static boost_intrusive_hmfcw::no_type deduce
+ (U*, Helper<void (BaseMixin::*)(), &U::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME>* = 0);
+ static boost_intrusive_hmfcw::yes_type deduce(...);
+
+ public:
+ static const bool value = sizeof(boost_intrusive_hmfcw::yes_type) == sizeof(deduce((Base*)0));
+ };
+
+ /////////////////////////////////////////////////////////
+ /////////////////////////////////////////////////////////
+ //
+ // has_member_function_callable_with_impl_XXX specializations
+ //
+ /////////////////////////////////////////////////////////
+
+ template<typename Fun, bool HasFunc BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASSDFLT,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
+ struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME);
+
+ //No BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME member specialization
+ template<typename Fun BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASS,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
+ struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+ <Fun, false BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_TARG,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
+ {
+ static const bool value = false;
+ };
+
+ #if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
+ //0 arg specialization when BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME is present
+ #if !defined(BOOST_NO_CXX11_DECLTYPE)
+
+ template<typename Fun>
+ struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
+ {
+ template<class U>
+ static decltype(boost::move_detail::declval<U>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()
+ , boost_intrusive_hmfcw::yes_type()) Test(U* f);
+
+ template<class U>
+ static boost_intrusive_hmfcw::no_type Test(...);
+ static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);
+ };
+
+ #else //defined(BOOST_NO_CXX11_DECLTYPE)
+
+ #if !defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
+
+ template<class F, std::size_t N = sizeof(boost::move_detail::declval<F>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(), 0)>
+ struct BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+ { boost_intrusive_hmfcw::yes_type dummy[N ? 1 : 2]; };
+
+ template<typename Fun>
+ struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
+ {
+ template<class U> static BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>
+ Test(BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>*);
+ template<class U> static boost_intrusive_hmfcw::no_type Test(...);
+ static const bool value = sizeof(Test< Fun >(0)) == sizeof(boost_intrusive_hmfcw::yes_type);
+ };
+
+ #else //defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
+
+ template<typename Fun>
+ struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
+ {//GCC [3.4-4.3) gives ICE when instantiating the 0 arg version so it is not supported.
+ static const bool value = true;
+ };
+
+ #endif//!defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
+ #endif //!defined(BOOST_NO_CXX11_DECLTYPE)
+ #endif //#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
+
+ #if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX > 0
+ //1 to N arg specialization when BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME is present
+ //Declare some unneeded default constructor as some old compilers wrongly require it with is_convertible
+ #if defined(BOOST_NO_CXX11_DECLTYPE)
+ #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION(N)\
+ \
+ template<class Fun>\
+ struct BOOST_MOVE_CAT(FunWrap##N, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)\
+ : Fun\
+ {\
+ using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;\
+ BOOST_MOVE_CAT(FunWrap##N, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)();\
+ boost_intrusive_hmfcw::private_type BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME\
+ (BOOST_MOVE_REPEAT##N(boost_intrusive_hmfcw::dont_care)) const;\
+ };\
+ \
+ template<typename Fun, BOOST_MOVE_CLASS##N>\
+ struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true, BOOST_MOVE_TARG##N>\
+ {\
+ static bool const value = (sizeof(boost_intrusive_hmfcw::no_type) == sizeof(boost_intrusive_hmfcw::is_private_type\
+ ( (::boost::move_detail::declval\
+ < BOOST_MOVE_CAT(FunWrap##N, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun> >().\
+ BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(BOOST_MOVE_DECLVAL##N), 0) )\
+ )\
+ );\
+ };\
+ //
+ #else
+ #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION(N)\
+ template<typename Fun, BOOST_MOVE_CLASS##N>\
+ struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)\
+ <Fun, true, BOOST_MOVE_TARG##N>\
+ {\
+ template<class U>\
+ static decltype(boost::move_detail::declval<U>().\
+ BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(BOOST_MOVE_DECLVAL##N)\
+ , boost_intrusive_hmfcw::yes_type()) Test(U* f);\
+ template<class U>\
+ static boost_intrusive_hmfcw::no_type Test(...);\
+ static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);\
+ };\
+ //
+ #endif
+ ////////////////////////////////////
+ // Build and invoke BOOST_MOVE_ITERATE_NTOM macrofunction, note that N has to be at least 1
+ ////////////////////////////////////
+ #if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
+ #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN 1
+ #else
+ #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
+ #endif
+ BOOST_MOVE_CAT
+ (BOOST_MOVE_CAT(BOOST_MOVE_CAT(BOOST_MOVE_ITERATE_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN), TO)
+ ,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)
+ (BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION)
+ #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION
+ #undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN
+ ////////////////////////////////////
+ // End of BOOST_MOVE_ITERATE_NTOM
+ ////////////////////////////////////
+ #endif //BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX > 0
+
+ /////////////////////////////////////////////////////////
+ /////////////////////////////////////////////////////////
+ //
+ // has_member_function_callable_with_FUNC
+ //
+ /////////////////////////////////////////////////////////
+ /////////////////////////////////////////////////////////
+
+ //Otherwise use the preprocessor
+ template<typename Fun BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASSDFLT,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
+ struct BOOST_MOVE_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+ : public BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+ <Fun
+ , BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun>::value
+ BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_TARG,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
+ {};
+ #endif //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#endif
+
+BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
+
+//Undef local macros
+#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF
+
+//Undef user defined macros
+#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
+#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
+#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX
+#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
+#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
diff --git a/contrib/src/boost/intrusive/detail/iterator.hpp b/contrib/src/boost/intrusive/detail/iterator.hpp
new file mode 100644
index 0000000..2ae6abb
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/iterator.hpp
@@ -0,0 +1,156 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-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/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_DETAIL_ITERATOR_HPP
+#define BOOST_INTRUSIVE_DETAIL_ITERATOR_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <cstddef>
+#include <boost/intrusive/detail/std_fwd.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/detail/meta_utils_core.hpp>
+
+namespace boost {
+namespace intrusive {
+
+using boost::movelib::iterator_traits;
+
+////////////////////
+// iterator
+////////////////////
+template<class Category, class T, class Difference, class Pointer, class Reference>
+struct iterator
+{
+ typedef Category iterator_category;
+ typedef T value_type;
+ typedef Difference difference_type;
+ typedef Pointer pointer;
+ typedef Reference reference;
+};
+
+////////////////////////////////////////
+// iterator_[dis|en]able_if_tag
+////////////////////////////////////////
+template<class I, class Tag, class R = void>
+struct iterator_enable_if_tag
+ : ::boost::move_detail::enable_if_c
+ < ::boost::move_detail::is_same
+ < typename boost::intrusive::iterator_traits<I>::iterator_category
+ , Tag
+ >::value
+ , R>
+{};
+
+template<class I, class Tag, class R = void>
+struct iterator_disable_if_tag
+ : ::boost::move_detail::enable_if_c
+ < !::boost::move_detail::is_same
+ < typename boost::intrusive::iterator_traits<I>::iterator_category
+ , Tag
+ >::value
+ , R>
+{};
+
+////////////////////////////////////////
+// iterator_[dis|en]able_if_tag_difference_type
+////////////////////////////////////////
+template<class I, class Tag>
+struct iterator_enable_if_tag_difference_type
+ : iterator_enable_if_tag<I, Tag, typename boost::intrusive::iterator_traits<I>::difference_type>
+{};
+
+template<class I, class Tag>
+struct iterator_disable_if_tag_difference_type
+ : iterator_disable_if_tag<I, Tag, typename boost::intrusive::iterator_traits<I>::difference_type>
+{};
+
+////////////////////
+// advance
+////////////////////
+template<class InputIt, class Distance>
+typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
+ iterator_advance(InputIt& it, Distance n)
+{
+ while(n--)
+ ++it;
+}
+
+template<class InputIt, class Distance>
+typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
+ iterator_advance(InputIt& it, Distance n)
+{
+ while(n--)
+ ++it;
+}
+
+template<class InputIt, class Distance>
+typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
+ iterator_advance(InputIt& it, Distance n)
+{
+ for (; 0 < n; --n)
+ ++it;
+ for (; n < 0; ++n)
+ --it;
+}
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type
+ iterator_advance(InputIt& it, Distance n)
+{
+ it += n;
+}
+
+////////////////////
+// distance
+////////////////////
+template<class InputIt> inline
+typename iterator_disable_if_tag_difference_type
+ <InputIt, std::random_access_iterator_tag>::type
+ iterator_distance(InputIt first, InputIt last)
+{
+ typename iterator_traits<InputIt>::difference_type off = 0;
+ while(first != last){
+ ++off;
+ ++first;
+ }
+ return off;
+}
+
+template<class InputIt>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
+ <InputIt, std::random_access_iterator_tag>::type
+ iterator_distance(InputIt first, InputIt last)
+{
+ typename iterator_traits<InputIt>::difference_type off = last - first;
+ return off;
+}
+
+template<class I>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
+{ return i.operator->(); }
+
+template<class T>
+BOOST_INTRUSIVE_FORCEINLINE T * iterator_arrow_result(T *p)
+{ return p; }
+
+} //namespace intrusive
+} //namespace boost
+
+#endif //BOOST_INTRUSIVE_DETAIL_ITERATOR_HPP
diff --git a/contrib/src/boost/intrusive/detail/minimal_less_equal_header.hpp b/contrib/src/boost/intrusive/detail/minimal_less_equal_header.hpp
new file mode 100644
index 0000000..5e8a19d
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/minimal_less_equal_header.hpp
@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 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/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_INTRUSIVE_DETAIL_MINIMAL_LESS_EQUAL_HEADER_HPP
+#define BOOST_INTRUSIVE_DETAIL_MINIMAL_LESS_EQUAL_HEADER_HPP
+#
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+#
+#//Try to avoid including <functional>, as it's quite big in C++11
+#if defined(BOOST_GNU_STDLIB)
+# include <bits/stl_function.h>
+#else
+# include <functional> //Fallback
+#endif
+#
+#endif //BOOST_INTRUSIVE_DETAIL_MINIMAL_LESS_EQUAL_HEADER_HPP
diff --git a/contrib/src/boost/intrusive/detail/minimal_pair_header.hpp b/contrib/src/boost/intrusive/detail/minimal_pair_header.hpp
new file mode 100644
index 0000000..1358a08
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/minimal_pair_header.hpp
@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 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/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP
+#define BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+#
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#//Try to avoid including <utility>, as it's quite big in C++11
+#if defined(BOOST_GNU_STDLIB)
+# include <bits/stl_pair.h>
+#else
+# include <utility> //Fallback
+#endif
+#
+#endif //BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP
diff --git a/contrib/src/boost/intrusive/detail/mpl.hpp b/contrib/src/boost/intrusive/detail/mpl.hpp
new file mode 100644
index 0000000..8d227a1
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/mpl.hpp
@@ -0,0 +1,206 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006-2014
+// (C) Copyright Microsoft Corporation 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/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_DETAIL_MPL_HPP
+#define BOOST_INTRUSIVE_DETAIL_MPL_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/move/detail/type_traits.hpp>
+#include <cstddef>
+
+namespace boost {
+namespace intrusive {
+namespace detail {
+
+using boost::move_detail::is_same;
+using boost::move_detail::add_const;
+using boost::move_detail::remove_const;
+using boost::move_detail::remove_cv;
+using boost::move_detail::remove_reference;
+using boost::move_detail::add_reference;
+using boost::move_detail::remove_pointer;
+using boost::move_detail::add_pointer;
+using boost::move_detail::true_type;
+using boost::move_detail::false_type;
+using boost::move_detail::enable_if_c;
+using boost::move_detail::enable_if;
+using boost::move_detail::disable_if_c;
+using boost::move_detail::disable_if;
+using boost::move_detail::is_convertible;
+using boost::move_detail::if_c;
+using boost::move_detail::if_;
+using boost::move_detail::is_const;
+using boost::move_detail::identity;
+using boost::move_detail::alignment_of;
+using boost::move_detail::is_empty;
+using boost::move_detail::addressof;
+using boost::move_detail::integral_constant;
+using boost::move_detail::enable_if_convertible;
+using boost::move_detail::disable_if_convertible;
+using boost::move_detail::bool_;
+using boost::move_detail::true_;
+using boost::move_detail::false_;
+using boost::move_detail::yes_type;
+using boost::move_detail::no_type;
+using boost::move_detail::apply;
+using boost::move_detail::eval_if_c;
+using boost::move_detail::eval_if;
+using boost::move_detail::unvoid_ref;
+using boost::move_detail::add_const_if_c;
+
+template<std::size_t S>
+struct ls_zeros
+{
+ static const std::size_t value = (S & std::size_t(1)) ? 0 : (1 + ls_zeros<(S>>1u)>::value);
+};
+
+template<>
+struct ls_zeros<0>
+{
+ static const std::size_t value = 0;
+};
+
+template<>
+struct ls_zeros<1>
+{
+ static const std::size_t value = 0;
+};
+
+// Infrastructure for providing a default type for T::TNAME if absent.
+#define BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(TNAME) \
+ template <typename T, typename DefaultType> \
+ struct boost_intrusive_default_type_ ## TNAME \
+ { \
+ template <typename X> \
+ static char test(int, typename X::TNAME*); \
+ \
+ template <typename X> \
+ static int test(...); \
+ \
+ struct DefaultWrap { typedef DefaultType TNAME; }; \
+ \
+ static const bool value = (1 == sizeof(test<T>(0, 0))); \
+ \
+ typedef typename \
+ ::boost::intrusive::detail::if_c \
+ <value, T, DefaultWrap>::type::TNAME type; \
+ }; \
+ //
+
+#define BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(INSTANTIATION_NS_PREFIX, T, TNAME, TIMPL) \
+ typename INSTANTIATION_NS_PREFIX \
+ boost_intrusive_default_type_ ## TNAME< T, TIMPL >::type \
+//
+
+#define BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(TNAME)\
+ template <typename T, typename DefaultType> \
+ struct boost_intrusive_eval_default_type_ ## TNAME \
+ { \
+ template <typename X> \
+ static char test(int, typename X::TNAME*); \
+ \
+ template <typename X> \
+ static int test(...); \
+ \
+ struct DefaultWrap \
+ { typedef typename DefaultType::type TNAME; }; \
+ \
+ static const bool value = (1 == sizeof(test<T>(0, 0))); \
+ \
+ typedef typename \
+ ::boost::intrusive::detail::eval_if_c \
+ < value \
+ , ::boost::intrusive::detail::identity<T> \
+ , ::boost::intrusive::detail::identity<DefaultWrap> \
+ >::type::TNAME type; \
+ }; \
+//
+
+#define BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(INSTANTIATION_NS_PREFIX, T, TNAME, TIMPL) \
+ typename INSTANTIATION_NS_PREFIX \
+ boost_intrusive_eval_default_type_ ## TNAME< T, TIMPL >::type \
+//
+
+#define BOOST_INTRUSIVE_INTERNAL_STATIC_BOOL_IS_TRUE(TRAITS_PREFIX, TYPEDEF_TO_FIND) \
+template <class T>\
+struct TRAITS_PREFIX##_bool\
+{\
+ template<bool Add>\
+ struct two_or_three {yes_type _[2 + Add];};\
+ template <class U> static yes_type test(...);\
+ template <class U> static two_or_three<U::TYPEDEF_TO_FIND> test (int);\
+ static const std::size_t value = sizeof(test<T>(0));\
+};\
+\
+template <class T>\
+struct TRAITS_PREFIX##_bool_is_true\
+{\
+ static const bool value = TRAITS_PREFIX##_bool<T>::value > sizeof(yes_type)*2;\
+};\
+//
+
+#define BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(TRAITS_NAME, FUNC_NAME) \
+ template <typename U, typename Signature> \
+ class TRAITS_NAME \
+ { \
+ private: \
+ template<Signature> struct helper;\
+ template<typename T> \
+ static ::boost::intrusive::detail::yes_type test(helper<&T::FUNC_NAME>*); \
+ template<typename T> static ::boost::intrusive::detail::no_type test(...); \
+ public: \
+ static const bool value = sizeof(test<U>(0)) == sizeof(::boost::intrusive::detail::yes_type); \
+ }; \
+//
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED(TRAITS_NAME, FUNC_NAME) \
+template <typename Type> \
+struct TRAITS_NAME \
+{ \
+ struct BaseMixin \
+ { \
+ void FUNC_NAME(); \
+ }; \
+ struct Base : public Type, public BaseMixin { Base(); }; \
+ template <typename T, T t> class Helper{}; \
+ template <typename U> \
+ static ::boost::intrusive::detail::no_type test(U*, Helper<void (BaseMixin::*)(), &U::FUNC_NAME>* = 0); \
+ static ::boost::intrusive::detail::yes_type test(...); \
+ static const bool value = sizeof(::boost::intrusive::detail::yes_type) == sizeof(test((Base*)(0))); \
+};\
+//
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(TRAITS_NAME, FUNC_NAME) \
+BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED(TRAITS_NAME##_ignore_signature, FUNC_NAME) \
+\
+template <typename Type, class> \
+struct TRAITS_NAME \
+ : public TRAITS_NAME##_ignore_signature<Type> \
+{};\
+//
+
+} //namespace detail
+} //namespace intrusive
+} //namespace boost
+
+#include <boost/intrusive/detail/config_end.hpp>
+
+#endif //BOOST_INTRUSIVE_DETAIL_MPL_HPP
diff --git a/contrib/src/boost/intrusive/detail/pointer_element.hpp b/contrib/src/boost/intrusive/detail/pointer_element.hpp
new file mode 100644
index 0000000..dd26e3c
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/pointer_element.hpp
@@ -0,0 +1,168 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-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/intrusive for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_DETAIL_POINTER_ELEMENT_HPP
+#define BOOST_INTRUSIVE_DETAIL_POINTER_ELEMENT_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
+#include <boost/intrusive/detail/workaround.hpp>
+#endif //BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
+
+namespace boost {
+namespace intrusive {
+namespace detail{
+
+//////////////////////
+//struct first_param
+//////////////////////
+
+template <typename T> struct first_param
+{ typedef void type; };
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+ template <template <typename, typename...> class TemplateClass, typename T, typename... Args>
+ struct first_param< TemplateClass<T, Args...> >
+ {
+ typedef T type;
+ };
+
+#else //C++03 compilers
+
+ template < template //0arg
+ <class
+ > class TemplateClass, class T
+ >
+ struct first_param
+ < TemplateClass<T> >
+ { typedef T type; };
+
+ template < template //1arg
+ <class,class
+ > class TemplateClass, class T
+ , class P0>
+ struct first_param
+ < TemplateClass<T, P0> >
+ { typedef T type; };
+
+ template < template //2arg
+ <class,class,class
+ > class TemplateClass, class T
+ , class P0, class P1>
+ struct first_param
+ < TemplateClass<T, P0, P1> >
+ { typedef T type; };
+
+ template < template //3arg
+ <class,class,class,class
+ > class TemplateClass, class T
+ , class P0, class P1, class P2>
+ struct first_param
+ < TemplateClass<T, P0, P1, P2> >
+ { typedef T type; };
+
+ template < template //4arg
+ <class,class,class,class,class
+ > class TemplateClass, class T
+ , class P0, class P1, class P2, class P3>
+ struct first_param
+ < TemplateClass<T, P0, P1, P2, P3> >
+ { typedef T type; };
+
+ template < template //5arg
+ <class,class,class,class,class,class
+ > class TemplateClass, class T
+ , class P0, class P1, class P2, class P3, class P4>
+ struct first_param
+ < TemplateClass<T, P0, P1, P2, P3, P4> >
+ { typedef T type; };
+
+ template < template //6arg
+ <class,class,class,class,class,class,class
+ > class TemplateClass, class T
+ , class P0, class P1, class P2, class P3, class P4, class P5>
+ struct first_param
+ < TemplateClass<T, P0, P1, P2, P3, P4, P5> >
+ { typedef T type; };
+
+ template < template //7arg
+ <class,class,class,class,class,class,class,class
+ > class TemplateClass, class T
+ , class P0, class P1, class P2, class P3, class P4, class P5, class P6>
+ struct first_param
+ < TemplateClass<T, P0, P1, P2, P3, P4, P5, P6> >
+ { typedef T type; };
+
+ template < template //8arg
+ <class,class,class,class,class,class,class,class,class
+ > class TemplateClass, class T
+ , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
+ struct first_param
+ < TemplateClass<T, P0, P1, P2, P3, P4, P5, P6, P7> >
+ { typedef T type; };
+
+ template < template //9arg
+ <class,class,class,class,class,class,class,class,class,class
+ > class TemplateClass, class T
+ , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
+ struct first_param
+ < TemplateClass<T, P0, P1, P2, P3, P4, P5, P6, P7, P8> >
+ { typedef T type; };
+
+#endif //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+template <typename T>
+struct has_internal_pointer_element
+{
+ template <typename X>
+ static char test(int, typename X::element_type*);
+
+ template <typename X>
+ static int test(...);
+
+ static const bool value = (1 == sizeof(test<T>(0, 0)));
+};
+
+template<class Ptr, bool = has_internal_pointer_element<Ptr>::value>
+struct pointer_element_impl
+{
+ typedef typename Ptr::element_type type;
+};
+
+template<class Ptr>
+struct pointer_element_impl<Ptr, false>
+{
+ typedef typename boost::intrusive::detail::first_param<Ptr>::type type;
+};
+
+} //namespace detail{
+
+template <typename Ptr>
+struct pointer_element
+{
+ typedef typename ::boost::intrusive::detail::pointer_element_impl<Ptr>::type type;
+};
+
+template <typename T>
+struct pointer_element<T*>
+{ typedef T type; };
+
+} //namespace container {
+} //namespace boost {
+
+#endif // defined(BOOST_INTRUSIVE_DETAIL_POINTER_ELEMENT_HPP)
diff --git a/contrib/src/boost/intrusive/detail/reverse_iterator.hpp b/contrib/src/boost/intrusive/detail/reverse_iterator.hpp
new file mode 100644
index 0000000..57631fe
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/reverse_iterator.hpp
@@ -0,0 +1,165 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-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/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
+#define BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/iterator.hpp>
+#include <boost/intrusive/detail/mpl.hpp>
+
+namespace boost {
+namespace intrusive {
+
+template<class It>
+class reverse_iterator
+{
+ public:
+ typedef typename boost::intrusive::iterator_traits<It>::pointer pointer;
+ typedef typename boost::intrusive::iterator_traits<It>::reference reference;
+ typedef typename boost::intrusive::iterator_traits<It>::difference_type difference_type;
+ typedef typename boost::intrusive::iterator_traits<It>::iterator_category iterator_category;
+ typedef typename boost::intrusive::iterator_traits<It>::value_type value_type;
+
+
+ typedef It iterator_type;
+
+ reverse_iterator()
+ : m_current() //Value initialization to achieve "null iterators" (N3644)
+ {}
+
+ explicit reverse_iterator(It r)
+ : m_current(r)
+ {}
+
+ reverse_iterator(const reverse_iterator& r)
+ : m_current(r.base())
+ {}
+
+ template<class OtherIt>
+ reverse_iterator( const reverse_iterator<OtherIt>& r
+ , typename boost::intrusive::detail::enable_if_convertible<OtherIt, It>::type* =0
+ )
+ : m_current(r.base())
+ {}
+
+ reverse_iterator & operator=( const reverse_iterator& r)
+ { m_current = r.base(); return *this; }
+
+ template<class OtherIt>
+ typename boost::intrusive::detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
+ operator=( const reverse_iterator<OtherIt>& r)
+ { m_current = r.base(); return *this; }
+
+ It base() const
+ { return m_current; }
+
+ reference operator*() const
+ {
+ It temp(m_current);
+ --temp;
+ reference r = *temp;
+ return r;
+ }
+
+ pointer operator->() const
+ {
+ It temp(m_current);
+ --temp;
+ return iterator_arrow_result(temp);
+ }
+
+ reference operator[](difference_type off) const
+ {
+ return this->m_current[-off - 1];
+ }
+
+ reverse_iterator& operator++()
+ {
+ --m_current;
+ return *this;
+ }
+
+ reverse_iterator operator++(int)
+ {
+ reverse_iterator temp((*this));
+ --m_current;
+ return temp;
+ }
+
+ reverse_iterator& operator--()
+ {
+ ++m_current;
+ return *this;
+ }
+
+ reverse_iterator operator--(int)
+ {
+ reverse_iterator temp((*this));
+ ++m_current;
+ return temp;
+ }
+
+ friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current == r.m_current; }
+
+ friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current != r.m_current; }
+
+ friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current > r.m_current; }
+
+ friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current >= r.m_current; }
+
+ friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current < r.m_current; }
+
+ friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current <= r.m_current; }
+
+ reverse_iterator& operator+=(difference_type off)
+ { m_current -= off; return *this; }
+
+ reverse_iterator& operator-=(difference_type off)
+ { m_current += off; return *this; }
+
+ friend reverse_iterator operator+(reverse_iterator l, difference_type off)
+ { return (l += off); }
+
+ friend reverse_iterator operator+(difference_type off, reverse_iterator r)
+ { return (r += off); }
+
+ friend reverse_iterator operator-(reverse_iterator l, difference_type off)
+ { return (l-= off); }
+
+ friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
+ { return r.m_current - l.m_current; }
+
+ private:
+ It m_current; // the wrapped iterator
+};
+
+} //namespace intrusive {
+} //namespace boost {
+
+#include <boost/intrusive/detail/config_end.hpp>
+
+#endif //BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
diff --git a/contrib/src/boost/intrusive/detail/std_fwd.hpp b/contrib/src/boost/intrusive/detail/std_fwd.hpp
new file mode 100644
index 0000000..8193ea8
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/std_fwd.hpp
@@ -0,0 +1,43 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_DETAIL_STD_FWD_HPP
+#define BOOST_INTRUSIVE_DETAIL_STD_FWD_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// Standard predeclarations
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/move/detail/std_ns_begin.hpp>
+BOOST_MOVE_STD_NS_BEG
+
+template<class T>
+struct less;
+
+template<class T>
+struct equal_to;
+
+struct input_iterator_tag;
+struct forward_iterator_tag;
+struct bidirectional_iterator_tag;
+struct random_access_iterator_tag;
+
+BOOST_MOVE_STD_NS_END
+#include <boost/move/detail/std_ns_end.hpp>
+
+#endif //#ifndef BOOST_INTRUSIVE_DETAIL_STD_FWD_HPP
diff --git a/contrib/src/boost/intrusive/detail/to_raw_pointer.hpp b/contrib/src/boost/intrusive/detail/to_raw_pointer.hpp
new file mode 100644
index 0000000..8ea8849
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/to_raw_pointer.hpp
@@ -0,0 +1,47 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-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/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_DETAIL_TO_RAW_POINTER_HPP
+#define BOOST_INTRUSIVE_DETAIL_TO_RAW_POINTER_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
+#include <boost/intrusive/detail/pointer_element.hpp>
+
+namespace boost {
+namespace intrusive {
+namespace detail {
+
+template <class T>
+BOOST_INTRUSIVE_FORCEINLINE T* to_raw_pointer(T* p)
+{ return p; }
+
+template <class Pointer>
+BOOST_INTRUSIVE_FORCEINLINE typename boost::intrusive::pointer_element<Pointer>::type*
+to_raw_pointer(const Pointer &p)
+{ return boost::intrusive::detail::to_raw_pointer(p.operator->()); }
+
+} //namespace detail
+} //namespace intrusive
+} //namespace boost
+
+#include <boost/intrusive/detail/config_end.hpp>
+
+#endif //BOOST_INTRUSIVE_DETAIL_UTILITIES_HPP
diff --git a/contrib/src/boost/intrusive/detail/workaround.hpp b/contrib/src/boost/intrusive/detail/workaround.hpp
new file mode 100644
index 0000000..7a9ac48
--- /dev/null
+++ b/contrib/src/boost/intrusive/detail/workaround.hpp
@@ -0,0 +1,50 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2013. 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/interprocess for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
+#define BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#ifndef BOOST_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ #define BOOST_INTRUSIVE_PERFECT_FORWARDING
+#endif
+
+//Macros for documentation purposes. For code, expands to the argument
+#define BOOST_INTRUSIVE_IMPDEF(TYPE) TYPE
+#define BOOST_INTRUSIVE_SEEDOC(TYPE) TYPE
+#define BOOST_INTRUSIVE_DOC1ST(TYPE1, TYPE2) TYPE2
+#define BOOST_INTRUSIVE_I ,
+#define BOOST_INTRUSIVE_DOCIGN(T1) T1
+
+#define BOOST_INTRUSIVE_DISABLE_FORCEINLINE
+
+#if defined(BOOST_INTRUSIVE_DISABLE_FORCEINLINE)
+ #define BOOST_INTRUSIVE_FORCEINLINE inline
+#elif defined(BOOST_INTRUSIVE_FORCEINLINE_IS_BOOST_FORCELINE)
+ #define BOOST_INTRUSIVE_FORCEINLINE BOOST_FORCEINLINE
+#elif defined(BOOST_MSVC) && defined(_DEBUG)
+ //"__forceinline" and MSVC seems to have some bugs in debug mode
+ #define BOOST_INTRUSIVE_FORCEINLINE inline
+#else
+ #define BOOST_INTRUSIVE_FORCEINLINE BOOST_FORCEINLINE
+#endif
+
+#endif //#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP