1 files changed, 147 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/signals2/detail/slot_call_iterator.hpp b/3rdParty/Boost/src/boost/signals2/detail/slot_call_iterator.hpp
new file mode 100644
index 0000000..99eec1d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/signals2/detail/slot_call_iterator.hpp
@@ -0,0 +1,147 @@
+// Boost.Signals2 library
+
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2007-2008.
+// Use, modification and
+// distribution is subject to the Boost Software License, Version
+// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+#ifndef BOOST_SIGNALS2_SLOT_CALL_ITERATOR_HPP
+#define BOOST_SIGNALS2_SLOT_CALL_ITERATOR_HPP
+
+#include <boost/assert.hpp>
+#include <boost/aligned_storage.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/optional.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/signals2/connection.hpp>
+#include <boost/signals2/slot_base.hpp>
+#include <boost/signals2/detail/auto_buffer.hpp>
+#include <boost/signals2/detail/unique_lock.hpp>
+#include <boost/weak_ptr.hpp>
+
+namespace boost {
+  namespace signals2 {
+    namespace detail {
+      template<typename ResultType, typename Function>
+        class slot_call_iterator_cache
+      {
+      public:
+        slot_call_iterator_cache(const Function &f_arg):
+          f(f_arg),
+          connected_slot_count(0),
+          disconnected_slot_count(0)
+        {}
+        optional<ResultType> result;
+        typedef auto_buffer<void_shared_ptr_variant, store_n_objects<10> > tracked_ptrs_type;
+        tracked_ptrs_type tracked_ptrs;
+        Function f;
+        unsigned connected_slot_count;
+        unsigned disconnected_slot_count;
+      };
+
+      // Generates a slot call iterator. Essentially, this is an iterator that:
+      //   - skips over disconnected slots in the underlying list
+      //   - calls the connected slots when dereferenced
+      //   - caches the result of calling the slots
+      template<typename Function, typename Iterator, typename ConnectionBody>
+      class slot_call_iterator_t
+        : public boost::iterator_facade<slot_call_iterator_t<Function, Iterator, ConnectionBody>,
+        typename Function::result_type,
+        boost::single_pass_traversal_tag,
+        typename Function::result_type const&>
+      {
+        typedef boost::iterator_facade<slot_call_iterator_t<Function, Iterator, ConnectionBody>,
+          typename Function::result_type,
+          boost::single_pass_traversal_tag,
+          typename Function::result_type const&>
+        inherited;
+
+        typedef typename Function::result_type result_type;
+
+        friend class boost::iterator_core_access;
+
+      public:
+        slot_call_iterator_t(Iterator iter_in, Iterator end_in,
+          slot_call_iterator_cache<result_type, Function> &c):
+          iter(iter_in), end(end_in),
+          cache(&c), callable_iter(end_in)
+        {
+          lock_next_callable();
+        }
+
+        typename inherited::reference
+        dereference() const
+        {
+          if (!cache->result) {
+            try
+            {
+              cache->result.reset(cache->f(*iter));
+            }
+            catch(expired_slot &)
+            {
+              (*iter)->disconnect();
+              throw;
+            }
+          }
+          return cache->result.get();
+        }
+
+        void increment()
+        {
+          ++iter;
+          lock_next_callable();
+          cache->result.reset();
+        }
+
+        bool equal(const slot_call_iterator_t& other) const
+        {
+          return iter == other.iter;
+        }
+
+      private:
+        typedef unique_lock<connection_body_base> lock_type;
+
+        void lock_next_callable() const
+        {
+          if(iter == callable_iter)
+          {
+            return;
+          }
+          for(;iter != end; ++iter)
+          {
+            lock_type lock(**iter);
+            cache->tracked_ptrs.clear();
+            (*iter)->nolock_grab_tracked_objects(std::back_inserter(cache->tracked_ptrs));
+            if((*iter)->nolock_nograb_connected())
+            {
+              ++cache->connected_slot_count;
+            }else
+            {
+              ++cache->disconnected_slot_count;
+            }
+            if((*iter)->nolock_nograb_blocked() == false)
+            {
+              callable_iter = iter;
+              break;
+            }
+          }
+          if(iter == end)
+          {
+            callable_iter = end;
+          }
+        }
+
+        mutable Iterator iter;
+        Iterator end;
+        slot_call_iterator_cache<result_type, Function> *cache;
+        mutable Iterator callable_iter;
+      };
+    } // end namespace detail
+  } // end namespace BOOST_SIGNALS_NAMESPACE
+} // end namespace boost
+
+#endif // BOOST_SIGNALS2_SLOT_CALL_ITERATOR_HPP