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

// This file intentionally does not have include guards, because it is meant

// to be included multiple times (one for each signalN class). The

// BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED macro merely serves to

// suppress reinclusion of the files that this header depends on.

#ifndef BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED

#define BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED

#  include <boost/config.hpp>

#  include <boost/signals/connection.hpp>

#  include <boost/utility.hpp>

#  include <boost/ref.hpp>

#  include <boost/signals/slot.hpp>

#  include <boost/last_value.hpp>

#  include <boost/signals/detail/signal_base.hpp>

#  include <boost/signals/detail/slot_call_iterator.hpp>

#  include <boost/mpl/bool.hpp>

#  include <boost/type_traits/is_convertible.hpp>

#  include <cassert>

#  include <functional>

#  include <memory>

#endif // !BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED

#ifdef BOOST_HAS_ABI_HEADERS

#  include BOOST_ABI_PREFIX

#endif

// Include the appropriate functionN header

#define BOOST_SIGNAL_FUNCTION_N_HEADER BOOST_JOIN(<boost/function/function,BOOST_SIGNALS_NUM_ARGS.hpp>)

#include BOOST_SIGNAL_FUNCTION_N_HEADER

// Determine if a comma should follow a listing of the arguments/parameters

#if BOOST_SIGNALS_NUM_ARGS == 0

#  define BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

#else

#  define BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS ,

#endif // BOOST_SIGNALS_NUM_ARGS > 0

// Define class names used

#define BOOST_SIGNALS_SIGNAL BOOST_JOIN(signal,BOOST_SIGNALS_NUM_ARGS)

#define BOOST_SIGNALS_FUNCTION BOOST_JOIN(function,BOOST_SIGNALS_NUM_ARGS)

#define BOOST_SIGNALS_ARGS_STRUCT BOOST_JOIN(args,BOOST_SIGNALS_NUM_ARGS)

#define BOOST_SIGNALS_CALL_BOUND BOOST_JOIN(call_bound,BOOST_SIGNALS_NUM_ARGS)

// Define commonly-used instantiations

#define BOOST_SIGNALS_ARGS_STRUCT_INST \

  BOOST_SIGNALS_NAMESPACE::detail::BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS>

namespace boost {

  namespace BOOST_SIGNALS_NAMESPACE {

    namespace detail {

      // Holds the arguments for a bound slot call in a single place

      template<BOOST_SIGNALS_TEMPLATE_PARMS

               BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

               typename Dummy = int>

      struct BOOST_SIGNALS_ARGS_STRUCT {

        BOOST_SIGNALS_ARGS_STRUCT(BOOST_SIGNALS_COPY_PARMS)

          BOOST_SIGNALS_INIT_ARGS

        {

        }

        BOOST_SIGNALS_ARGS_AS_MEMBERS

      };

      // Function object that calls the function object given to it, passing

      // the bound arguments along to that underlying function object

      template<typename R>

      struct BOOST_SIGNALS_CALL_BOUND {

        template<BOOST_SIGNALS_TEMPLATE_PARMS

                 BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

                 typename F>

        struct caller {

          typedef BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS>*

            args_type;

          args_type args;

          typedef R result_type;

          caller() {}

          caller(args_type a) : args(a) {}

          template<typename Pair>

          R operator()(const Pair& slot) const

          {

            F* target = const_cast<F*>(unsafe_any_cast<F>(&slot.second));

            return (*target)(BOOST_SIGNALS_BOUND_ARGS);

          }

        };

      };

      template<>

      struct BOOST_SIGNALS_CALL_BOUND<void> {

        template<BOOST_SIGNALS_TEMPLATE_PARMS

                 BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

                 typename F>

        struct caller {

          typedef BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS>*

            args_type;

          args_type args;

          typedef unusable result_type;

          caller(args_type a) : args(a) {}

          template<typename Pair>

          unusable operator()(const Pair& slot) const

          {

            F* target = const_cast<F*>(unsafe_any_cast<F>(&slot.second));

            (*target)(BOOST_SIGNALS_BOUND_ARGS);

            return unusable();

          }

        };

      };

    } // namespace detail

  } // namespace BOOST_SIGNALS_NAMESPACE

  // The actual signalN class

  template<

    typename R,

    BOOST_SIGNALS_TEMPLATE_PARMS

    BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

    typename Combiner = last_value<R>,

    typename Group = int,

    typename GroupCompare = std::less<Group>,

    typename SlotFunction = BOOST_SIGNALS_FUNCTION<

                              R BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

                              BOOST_SIGNALS_TEMPLATE_ARGS>

  >

  class BOOST_SIGNALS_SIGNAL :

    public BOOST_SIGNALS_NAMESPACE::detail::signal_base, // management of slot list

    public BOOST_SIGNALS_NAMESPACE::trackable // signals are trackable

  {

  public:

    // The slot function type

    typedef SlotFunction slot_function_type;

    // Result type of a slot

    typedef typename BOOST_SIGNALS_NAMESPACE::detail::slot_result_type<R>::type

      slot_result_type;

    // Argument types

    BOOST_SIGNALS_ARG_TYPES

#if BOOST_SIGNALS_NUM_ARGS == 1

    typedef T1 argument_type;

#elif BOOST_SIGNALS_NUM_ARGS == 2

    typedef T1 first_argument_type;

    typedef T2 second_argument_type;

#endif

  private:

    // The real slot name comparison object type

    typedef BOOST_SIGNALS_NAMESPACE::detail::group_bridge_compare<GroupCompare, Group>

      real_group_compare_type;

    // The function object passed to the slot call iterator that will call

    // the underlying slot function with its arguments bound

    typedef BOOST_SIGNALS_NAMESPACE::detail::BOOST_SIGNALS_CALL_BOUND<R>

      outer_bound_slot_caller;

    typedef typename outer_bound_slot_caller::template

              caller<BOOST_SIGNALS_TEMPLATE_ARGS

                     BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

                     slot_function_type>

      call_bound_slot;

  public:

    // Combiner's result type

    typedef typename Combiner::result_type result_type;

    // Combiner type

    typedef Combiner combiner_type;

    // Slot type

    typedef slot<slot_function_type> slot_type;

    // Slot name type and comparison

    typedef Group group_type;

    typedef GroupCompare group_compare_type;

    typedef BOOST_SIGNALS_NAMESPACE::detail::slot_call_iterator<

              call_bound_slot, iterator> slot_call_iterator;

    explicit

    BOOST_SIGNALS_SIGNAL(const Combiner& c = Combiner(),

                         const GroupCompare& comp = GroupCompare()) :

      BOOST_SIGNALS_NAMESPACE::detail::signal_base(real_group_compare_type(comp),

                                                   c)

    {

    }

    // Connect a slot to this signal

    BOOST_SIGNALS_NAMESPACE::connection

    connect(const slot_type&,

            BOOST_SIGNALS_NAMESPACE::connect_position at

              = BOOST_SIGNALS_NAMESPACE::at_back);

    BOOST_SIGNALS_NAMESPACE::connection

    connect(const group_type&, const slot_type&,

            BOOST_SIGNALS_NAMESPACE::connect_position at

              = BOOST_SIGNALS_NAMESPACE::at_back);

#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

    // MSVC 6.0 and 7.0 don't handle the is_convertible test well

    void disconnect(const group_type& group)

    {

      impl->disconnect(group);

    }

#else

    template<typename T>

    void disconnect(const T& t)

    {

      typedef mpl::bool_<(is_convertible<T, group_type>::value)> is_group;

      this->do_disconnect(t, is_group());

    }

  private:

    // Disconnect a named slot

    void do_disconnect(const group_type& group, mpl::bool_<true>)

    {

      impl->disconnect(group);

    }

    template<typename Function>

    void do_disconnect(const Function& f, mpl::bool_<false>)

    {

      // Notify the slot handling code that we are iterating through the slots

      BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl);

      for (iterator i = impl->slots_.begin(); i != impl->slots_.end(); ++i) {

        slot_function_type& s = *unsafe_any_cast<slot_function_type>(&i->second);

        if (s == f) i->first.disconnect();

      }

    }

#endif

  public:

    // Emit the signal

    result_type operator()(BOOST_SIGNALS_PARMS);

    result_type operator()(BOOST_SIGNALS_PARMS) const;

    Combiner& combiner()

    { return *unsafe_any_cast<Combiner>(&impl->combiner_); }

    const Combiner& combiner() const

    { return *unsafe_any_cast<const Combiner>(&impl->combiner_); }

  };

  template<

    typename R,

    BOOST_SIGNALS_TEMPLATE_PARMS

    BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

    typename Combiner,

    typename Group,

    typename GroupCompare,

    typename SlotFunction

  >

  BOOST_SIGNALS_NAMESPACE::connection

  BOOST_SIGNALS_SIGNAL<

    R, BOOST_SIGNALS_TEMPLATE_ARGS

    BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

    Combiner, Group, GroupCompare, SlotFunction

  >::connect(const slot_type& in_slot,

             BOOST_SIGNALS_NAMESPACE::connect_position at)

  {

    using boost::BOOST_SIGNALS_NAMESPACE::detail::stored_group;

    // If the slot has been disconnected, just return a disconnected

    // connection

    if (!in_slot.is_active()) {

      return BOOST_SIGNALS_NAMESPACE::connection();

    }

    return impl->connect_slot(in_slot.get_slot_function(), stored_group(),

                              in_slot.get_data(), at);

  }

  template<

    typename R,

    BOOST_SIGNALS_TEMPLATE_PARMS

    BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

    typename Combiner,

    typename Group,

    typename GroupCompare,

    typename SlotFunction

  >

  BOOST_SIGNALS_NAMESPACE::connection

  BOOST_SIGNALS_SIGNAL<

    R, BOOST_SIGNALS_TEMPLATE_ARGS

    BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

    Combiner, Group, GroupCompare, SlotFunction

  >::connect(const group_type& group,

             const slot_type& in_slot,

             BOOST_SIGNALS_NAMESPACE::connect_position at)

  {

    // If the slot has been disconnected, just return a disconnected

    // connection

    if (!in_slot.is_active()) {

      return BOOST_SIGNALS_NAMESPACE::connection();

    }

    return impl->connect_slot(in_slot.get_slot_function(), group,

                              in_slot.get_data(), at);

  }

  template<

    typename R,

    BOOST_SIGNALS_TEMPLATE_PARMS

    BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

    typename Combiner,

    typename Group,

    typename GroupCompare,

    typename SlotFunction

  >

  typename BOOST_SIGNALS_SIGNAL<

             R, BOOST_SIGNALS_TEMPLATE_ARGS

             BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

             Combiner, Group, GroupCompare, SlotFunction>::result_type

  BOOST_SIGNALS_SIGNAL<

    R, BOOST_SIGNALS_TEMPLATE_ARGS

    BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

    Combiner, Group, GroupCompare, SlotFunction

  >::operator()(BOOST_SIGNALS_PARMS)

  {

    // Notify the slot handling code that we are making a call

    BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl);

    // Construct a function object that will call the underlying slots

    // with the given arguments.

#if BOOST_SIGNALS_NUM_ARGS == 0

    BOOST_SIGNALS_ARGS_STRUCT_INST args;

#else

    BOOST_SIGNALS_ARGS_STRUCT_INST args(BOOST_SIGNALS_ARGS);

#endif // BOOST_SIGNALS_NUM_ARGS > 0

    call_bound_slot f(&args);

    typedef typename call_bound_slot::result_type result_type;

    optional<result_type> cache;

    // Let the combiner call the slots via a pair of input iterators

    return combiner()(slot_call_iterator(notification.impl->slots_.begin(),

                                         impl->slots_.end(), f, cache),

                      slot_call_iterator(notification.impl->slots_.end(),

                                         impl->slots_.end(), f, cache));

  }

  template<

    typename R,

    BOOST_SIGNALS_TEMPLATE_PARMS

    BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

    typename Combiner,

    typename Group,

    typename GroupCompare,

    typename SlotFunction

  >

  typename BOOST_SIGNALS_SIGNAL<

             R, BOOST_SIGNALS_TEMPLATE_ARGS

             BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

             Combiner, Group, GroupCompare, SlotFunction>::result_type

  BOOST_SIGNALS_SIGNAL<

    R, BOOST_SIGNALS_TEMPLATE_ARGS

    BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

    Combiner, Group, GroupCompare, SlotFunction

  >::operator()(BOOST_SIGNALS_PARMS) const

  {

    // Notify the slot handling code that we are making a call

    BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl);

    // Construct a function object that will call the underlying slots

    // with the given arguments.

#if BOOST_SIGNALS_NUM_ARGS == 0

    BOOST_SIGNALS_ARGS_STRUCT_INST args;

#else

    BOOST_SIGNALS_ARGS_STRUCT_INST args(BOOST_SIGNALS_ARGS);

#endif // BOOST_SIGNALS_NUM_ARGS > 0

    call_bound_slot f(&args);

    typedef typename call_bound_slot::result_type result_type;

    optional<result_type> cache;

    // Let the combiner call the slots via a pair of input iterators

    return combiner()(slot_call_iterator(notification.impl->slots_.begin(),

                                         impl->slots_.end(), f, cache),

                      slot_call_iterator(notification.impl->slots_.end(),

                                         impl->slots_.end(), f, cache));

  }

} // namespace boost

#undef BOOST_SIGNAL_FUNCTION_N_HEADER

#undef BOOST_SIGNALS_ARGS_STRUCT_INST

#undef BOOST_SIGNALS_CALL_BOUND

#undef BOOST_SIGNALS_ARGS_STRUCT

#undef BOOST_SIGNALS_FUNCTION

#undef BOOST_SIGNALS_SIGNAL

#undef BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS

#ifdef BOOST_HAS_ABI_HEADERS

#  include BOOST_ABI_SUFFIX

#endif