Added boost header

test/external/boost/signals/slot.hpp

@@ -0,0 +1,157 @@
+// Boost.Signals library
+
+// Copyright Douglas Gregor 2001-2004. 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_SIGNALS_SLOT_HEADER
+#define BOOST_SIGNALS_SLOT_HEADER
+
+#include <boost/signals/detail/signals_common.hpp>
+#include <boost/signals/connection.hpp>
+#include <boost/signals/trackable.hpp>
+#include <boost/visit_each.hpp>
+#include <boost/shared_ptr.hpp>
+#include <cassert>
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+namespace boost {
+  namespace BOOST_SIGNALS_NAMESPACE {
+    namespace detail {
+      class BOOST_SIGNALS_DECL slot_base {
+        // We would have to enumerate all of the signalN classes here as
+        // friends to make this private (as it otherwise should be). We can't
+        // name all of them because we don't know how many there are.
+      public:
+        struct data_t {
+          std::vector<const trackable*> bound_objects;
+          connection watch_bound_objects;
+        };
+        shared_ptr<data_t> get_data() const { return data; }
+
+        // Get the set of bound objects
+        std::vector<const trackable*>& get_bound_objects() const
+        { return data->bound_objects; }
+
+        // Determine if this slot is still "active", i.e., all of the bound
+        // objects still exist
+        bool is_active() const 
+        { return data->watch_bound_objects.connected(); }
+
+      protected:
+        // Create a connection for this slot
+        void create_connection();
+
+        shared_ptr<data_t> data;
+
+      private:
+        static void bound_object_destructed(void*, void*) {}
+      };
+    } // end namespace detail
+
+    // Get the slot so that it can be copied
+    template<typename F>
+    reference_wrapper<const F>
+    get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::signal_tag)
+      { return reference_wrapper<const F>(f); }
+
+    template<typename F>
+    const F&
+    get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::reference_tag)
+      { return f; }
+
+    template<typename F>
+    const F&
+    get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag)
+      { return f; }
+
+    // Get the slot so that it can be inspected for trackable objects
+    template<typename F>
+    const F&
+    get_inspectable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::signal_tag)
+      { return f; }
+
+    template<typename F>
+    const F&
+    get_inspectable_slot(const reference_wrapper<F>& f, BOOST_SIGNALS_NAMESPACE::detail::reference_tag)
+      { return f.get(); }
+
+    template<typename F>
+    const F&
+    get_inspectable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag)
+      { return f; }
+
+    // Determines the type of the slot - is it a signal, a reference to a
+    // slot or just a normal slot.
+    template<typename F>
+    typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type
+    tag_type(const F&)
+    {
+      typedef typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type
+        the_tag_type;
+      the_tag_type tag = the_tag_type();
+      return tag;
+    }
+
+  } // end namespace BOOST_SIGNALS_NAMESPACE
+
+  template<typename SlotFunction>
+  class slot : public BOOST_SIGNALS_NAMESPACE::detail::slot_base {
+    typedef BOOST_SIGNALS_NAMESPACE::detail::slot_base inherited;
+    typedef typename inherited::data_t data_t;
+
+  public:
+    template<typename F>
+    slot(const F& f) : slot_function(BOOST_SIGNALS_NAMESPACE::get_invocable_slot(f, BOOST_SIGNALS_NAMESPACE::tag_type(f)))
+    {
+      this->data.reset(new data_t);
+
+      // Visit each of the bound objects and store them for later use
+      // An exception thrown here will allow the basic_connection to be
+      // destroyed when this goes out of scope, and no other connections
+      // have been made.
+      BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor 
+        do_bind(this->data->bound_objects);
+      visit_each(do_bind, 
+                 BOOST_SIGNALS_NAMESPACE::get_inspectable_slot
+                   (f, BOOST_SIGNALS_NAMESPACE::tag_type(f)));
+      create_connection();
+    }
+
+#ifdef __BORLANDC__
+    template<typename F>
+    slot(F* f) : slot_function(f)
+    {
+      this->data.reset(new data_t);
+      create_connection();
+    }
+#endif // __BORLANDC__
+
+    // We would have to enumerate all of the signalN classes here as friends
+    // to make this private (as it otherwise should be). We can't name all of
+    // them because we don't know how many there are.
+  public:
+    // Get the slot function to call the actual slot
+    const SlotFunction& get_slot_function() const { return slot_function; }
+
+    void release() const { data->watch_bound_objects.set_controlling(false); }
+
+  private:
+    slot(); // no default constructor
+    slot& operator=(const slot&); // no assignment operator
+
+    SlotFunction slot_function;
+  };
+} // end namespace boost
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+#endif // BOOST_SIGNALS_SLOT_HEADER