1 files changed, 185 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/signals2/detail/foreign_ptr.hpp b/3rdParty/Boost/src/boost/signals2/detail/foreign_ptr.hpp
new file mode 100644
index 0000000..4349b38
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/foreign_ptr.hpp
@@ -0,0 +1,185 @@
+
+//  helper code for dealing with tracking non-boost shared_ptr/weak_ptr
+
+// Copyright Frank Mori Hess 2009.
+// 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/signals2 for library home page.
+
+#ifndef BOOST_SIGNALS2_FOREIGN_PTR_HPP
+#define BOOST_SIGNALS2_FOREIGN_PTR_HPP
+
+#include <algorithm>
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/smart_ptr/bad_weak_ptr.hpp>
+#include <boost/utility/swap.hpp>
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+#include <memory>
+#endif
+
+namespace boost
+{
+  template<typename T> class shared_ptr;
+  template<typename T> class weak_ptr;
+
+  namespace signals2
+  {
+    template<typename WeakPtr> struct weak_ptr_traits
+    {};
+    template<typename T> struct weak_ptr_traits<boost::weak_ptr<T> >
+    {
+      typedef boost::shared_ptr<T> shared_type;
+    };
+#ifndef BOOST_NO_CXX11_SMART_PTR
+    template<typename T> struct weak_ptr_traits<std::weak_ptr<T> >
+    {
+      typedef std::shared_ptr<T> shared_type;
+    };
+#endif
+
+    template<typename SharedPtr> struct shared_ptr_traits
+    {};
+
+    template<typename T> struct shared_ptr_traits<boost::shared_ptr<T> >
+    {
+      typedef boost::weak_ptr<T> weak_type;
+    };
+#ifndef BOOST_NO_CXX11_SMART_PTR
+    template<typename T> struct shared_ptr_traits<std::shared_ptr<T> >
+    {
+      typedef std::weak_ptr<T> weak_type;
+    };
+#endif
+
+    namespace detail
+    {
+      struct foreign_shared_ptr_impl_base
+      {
+        virtual ~foreign_shared_ptr_impl_base() {}
+        virtual void* get() const = 0;
+        virtual foreign_shared_ptr_impl_base * clone() const = 0;
+      };
+
+      template<typename FSP>
+      class foreign_shared_ptr_impl: public foreign_shared_ptr_impl_base
+      {
+      public:
+        foreign_shared_ptr_impl(const FSP &p): _p(p)
+        {}
+        virtual void * get() const
+        {
+          return _p.get();
+        }
+        virtual foreign_shared_ptr_impl * clone() const
+        {
+          return new foreign_shared_ptr_impl(*this);
+        }
+      private:
+        FSP _p;
+      };
+
+      class foreign_void_shared_ptr
+      {
+      public:
+        foreign_void_shared_ptr():
+          _p(0)
+        {}
+        foreign_void_shared_ptr(const foreign_void_shared_ptr &other):
+          _p(other._p->clone())
+        {}
+        template<typename FSP>
+        explicit foreign_void_shared_ptr(const FSP &fsp):
+          _p(new foreign_shared_ptr_impl<FSP>(fsp))
+        {}
+        ~foreign_void_shared_ptr()
+        {
+          delete _p;
+        }
+        foreign_void_shared_ptr & operator=(const foreign_void_shared_ptr &other)
+        {
+          if(&other == this) return *this;
+          foreign_void_shared_ptr(other).swap(*this);
+          return *this;
+        }
+        void swap(foreign_void_shared_ptr &other)
+        {
+          boost::swap(_p, other._p);
+        }
+      private:
+        foreign_shared_ptr_impl_base *_p;
+      };
+
+      struct foreign_weak_ptr_impl_base
+      {
+        virtual ~foreign_weak_ptr_impl_base() {}
+        virtual foreign_void_shared_ptr lock() const = 0;
+        virtual bool expired() const = 0;
+        virtual foreign_weak_ptr_impl_base * clone() const = 0;
+      };
+
+      template<typename FWP>
+      class foreign_weak_ptr_impl: public foreign_weak_ptr_impl_base
+      {
+      public:
+        foreign_weak_ptr_impl(const FWP &p): _p(p)
+        {}
+        virtual foreign_void_shared_ptr lock() const
+        {
+          return foreign_void_shared_ptr(_p.lock());
+        }
+        virtual bool expired() const
+        {
+          return _p.expired();
+        }
+        virtual foreign_weak_ptr_impl * clone() const
+        {
+          return new foreign_weak_ptr_impl(*this);
+        }
+      private:
+        FWP _p;
+      };
+
+      class foreign_void_weak_ptr
+      {
+      public:
+        foreign_void_weak_ptr()
+        {}
+        foreign_void_weak_ptr(const foreign_void_weak_ptr &other):
+          _p(other._p->clone())
+        {}
+        template<typename FWP>
+        explicit foreign_void_weak_ptr(const FWP &fwp):
+          _p(new foreign_weak_ptr_impl<FWP>(fwp))
+        {}
+        foreign_void_weak_ptr & operator=(const foreign_void_weak_ptr &other)
+        {
+          if(&other == this) return *this;
+          foreign_void_weak_ptr(other).swap(*this);
+          return *this;
+        }
+        void swap(foreign_void_weak_ptr &other)
+        {
+          boost::swap(_p, other._p);
+        }
+        foreign_void_shared_ptr lock() const
+        {
+          return _p->lock();
+        }
+        bool expired() const
+        {
+          return _p->expired();
+        }
+      private:
+        boost::scoped_ptr<foreign_weak_ptr_impl_base> _p;
+      };
+    } // namespace detail
+
+  } // namespace signals2
+} // namespace boost
+
+#endif  // BOOST_SIGNALS2_FOREIGN_PTR_HPP