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

#define BOOST_SIGNALS_TRACKABLE_HPP

#include <boost/type_traits.hpp>

#include <boost/signals/connection.hpp>

#include <boost/pending/ct_if.hpp>

#include <boost/ref.hpp>

#include <boost/utility/addressof.hpp>

#include <list>

#include <vector>

#ifdef BOOST_HAS_ABI_HEADERS

#  include BOOST_ABI_PREFIX

#endif

namespace boost {

namespace BOOST_SIGNALS_NAMESPACE {

  // Base class for "trackable" objects that can be tracked when they are

  // bound in slot target functions. When a trackable object is destroyed,

  // the signal/slot connections are disconnected automatically.

  class BOOST_SIGNALS_DECL trackable {

  private:

    static void signal_disconnected(void* obj, void* data);

    friend class detail::signal_base_impl;

    friend class detail::slot_base;

    void signal_connected(connection, BOOST_SIGNALS_NAMESPACE::detail::bound_object&) const;

  protected:

    trackable() : connected_signals(), dying(false) {}

    trackable(const trackable&) : connected_signals(), dying(false) {}

    ~trackable();

    trackable& operator=(const trackable&)

    {

      connected_signals.clear();

      return *this;

    }

  private:

    typedef std::list<connection> connection_list;

    typedef connection_list::iterator connection_iterator;

    // List of connections that this object is part of

    mutable connection_list connected_signals;

    // True when the object is being destroyed

    mutable bool dying;

  };

  namespace detail {

    template<bool Cond> struct truth {};

    // A visitor that adds each trackable object to a vector

    class bound_objects_visitor {

    public:

      bound_objects_visitor(std::vector<const trackable*>& v) :

        bound_objects(v)

      {

      }

      template<typename T>

      void operator()(const T& t) const

      {

        decode(t, 0);

      }

    private:

      // decode() decides between a reference wrapper and anything else

      template<typename T>

      void decode(const reference_wrapper<T>& t, int) const

      {

        add_if_trackable(t.get_pointer());

      }

      template<typename T>

      void decode(const T& t, long) const

      {

        typedef truth<(is_pointer<T>::value)> is_a_pointer;

        maybe_get_pointer(t, is_a_pointer());

      }

      // maybe_get_pointer() decides between a pointer and a non-pointer

      template<typename T>

      void maybe_get_pointer(const T& t, truth<true>) const

      {

        add_if_trackable(t);

      }

      template<typename T>

      void maybe_get_pointer(const T& t, truth<false>) const

      {

        // Take the address of this object, because the object itself may be

        // trackable

        add_if_trackable(boost::addressof(t));

      }

      // add_if_trackable() adds trackable objects to the list of bound objects

      inline void add_if_trackable(const trackable* b) const

      {

        if (b) {

          bound_objects.push_back(b);

        }

      }

      inline void add_if_trackable(const void*) const

      {

      }

      template<typename R>

      inline void add_if_trackable(R (*)()) const

      {

      }

      template<typename R, typename T1>

      inline void add_if_trackable(R (*)(T1)) const

      {

      }

      template<typename R, typename T1, typename T2>

      inline void add_if_trackable(R (*)(T1, T2)) const

      {

      }

      template<typename R, typename T1, typename T2, typename T3>

      inline void add_if_trackable(R (*)(T1, T2, T3)) const

      {

      }

      template<typename R, typename T1, typename T2, typename T3, typename T4>

      inline void add_if_trackable(R (*)(T1, T2, T3, T4)) const

      {

      }

      template<typename R, typename T1, typename T2, typename T3, typename T4,

               typename T5>

      inline void add_if_trackable(R (*)(T1, T2, T3, T4, T5)) const

      {

      }

      template<typename R, typename T1, typename T2, typename T3, typename T4,

               typename T5, typename T6>

      inline void add_if_trackable(R (*)(T1, T2, T3, T4, T5, T6)) const

      {

      }

      template<typename R, typename T1, typename T2, typename T3, typename T4,

               typename T5, typename T6, typename T7>

      inline void add_if_trackable(R (*)(T1, T2, T3, T4, T5, T6, T7)) const

      {

      }

      template<typename R, typename T1, typename T2, typename T3, typename T4,

               typename T5, typename T6, typename T7, typename T8>

      inline void add_if_trackable(R (*)(T1, T2, T3, T4, T5, T6, T7, T8)) const

      {

      }

      template<typename R, typename T1, typename T2, typename T3, typename T4,

               typename T5, typename T6, typename T7, typename T8, typename T9>

      inline void

      add_if_trackable(R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)) const

      {

      }

      template<typename R, typename T1, typename T2, typename T3, typename T4,

               typename T5, typename T6, typename T7, typename T8, typename T9,

               typename T10>

      inline void

      add_if_trackable(R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) const

      {

      }

      std::vector<const trackable*>& bound_objects;

    };

  } // end namespace detail

} // end namespace BOOST_SIGNALS_NAMESPACE

} // end namespace boost

#ifdef BOOST_HAS_ABI_HEADERS

#  include BOOST_ABI_SUFFIX

#endif

#endif // BOOST_SIGNALS_TRACKABLE_HPP