Merge pull request #149 from tklab-tud/sradomski

remerge

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