// 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