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