signal.hpp

Go to the documentation of this file.

#pragma once
/*
**  Copyright (C) 2013 Aldebaran Robotics
**  See COPYING for the license
*/

#ifndef _QI_SIGNAL_HPP_
#define _QI_SIGNAL_HPP_

#include <qi/atomic.hpp>

#include <qi/anyfunction.hpp>
#include <qi/type/typeobject.hpp>

#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/enable_shared_from_this.hpp>

#ifdef _MSC_VER
#  pragma warning( push )
#  pragma warning( disable: 4251 )
#endif

// Macro to be more expressive when emitting a signal. Does nothing, it's normal.
#define QI_EMIT

namespace qi {

  class ManageablePrivate;
  class SignalSubscriber;

  class SignalBasePrivate;

  using SignalLink = qi::uint64_t;

  //Signal are not copyable, they belong to a class.
  class QI_API SignalBase : boost::noncopyable
  {
  public:
    using OnSubscribers = boost::function<void(bool)>;
    explicit SignalBase(const Signature &signature, OnSubscribers onSubscribers = OnSubscribers());
    SignalBase(OnSubscribers onSubscribers=OnSubscribers());
    virtual ~SignalBase();
    virtual qi::Signature signature() const;
    template<typename F>
    SignalSubscriber& connect(boost::function<F> func);
    SignalSubscriber& connect(const SignalSubscriber& s);
    SignalSubscriber& connect(AnyObject object, const unsigned int slot);
    SignalSubscriber& connect(AnyObject object, const std::string& slot);

    bool disconnectAll();
    bool asyncDisconnectAll();

    bool disconnect(const SignalLink& link);

    bool asyncDisconnect(const SignalLink& link);

    virtual void trigger(const GenericFunctionParameters& params, MetaCallType callType = MetaCallType_Auto);
    void setCallType(MetaCallType callType);
    void operator()(
      qi::AutoAnyReference p1 = qi::AutoAnyReference(),
      qi::AutoAnyReference p2 = qi::AutoAnyReference(),
      qi::AutoAnyReference p3 = qi::AutoAnyReference(),
      qi::AutoAnyReference p4 = qi::AutoAnyReference(),
      qi::AutoAnyReference p5 = qi::AutoAnyReference(),
      qi::AutoAnyReference p6 = qi::AutoAnyReference(),
      qi::AutoAnyReference p7 = qi::AutoAnyReference(),
      qi::AutoAnyReference p8 = qi::AutoAnyReference());

    std::vector<SignalSubscriber> subscribers();
    bool hasSubscribers();
    static const SignalLink invalidSignalLink;
  protected:
    using Trigger = boost::function<void(const GenericFunctionParameters& params, MetaCallType callType)>;
    void callSubscribers(const GenericFunctionParameters& params, MetaCallType callType = MetaCallType_Auto);
    void setTriggerOverride(Trigger trigger);
    void setOnSubscribers(OnSubscribers onSubscribers);
    void callOnSubscribe(bool v);
    void createNewTrackLink(int& id, SignalLink*& trackLink);
    void disconnectTrackLink(int id);
  public:
    void _setSignature(const Signature &s);
    // C4251
    boost::shared_ptr<SignalBasePrivate> _p;
    friend class SignalBasePrivate;
  };

  template <typename... P> class Signal;

  template<typename T>
  class SignalF: public SignalBase, public boost::function<T>
  {
  public:
    SignalF(OnSubscribers onSubscribers = OnSubscribers());
    using FunctionType = T;
    virtual qi::Signature signature() const;
    using boost::function<T>::operator();

#ifdef DOXYGEN

    SignalSubscriber& connect(...);
#else
    template <typename F>
    SignalSubscriber& connect(F c);
    SignalSubscriber& connect(AnyFunction func);
    SignalSubscriber& connect(const SignalSubscriber& sub);
    template <typename U>
    SignalSubscriber& connect(SignalF<U>& signal);
    template <typename... P>
    SignalSubscriber& connect(Signal<P...>& signal);

    template <typename F, typename Arg0, typename... Args>
    SignalSubscriber& connect(F&& func, Arg0&& arg0, Args&&... args);

    SignalSubscriber& connect(const AnyObject& obj, unsigned int slot);
    SignalSubscriber& connect(const AnyObject& obj, const std::string& slot);
#endif
  };

  template<typename... P>
  class Signal: public SignalF<void(P...)>
  {
  public:
    typedef void(FunctionType)(P...); // FIXME: VS2013 fails if this is replaced by `using`
    using ParentType = SignalF<FunctionType>;
    using OnSubscribers = typename ParentType::OnSubscribers;
    Signal(OnSubscribers onSubscribers = OnSubscribers())
      : ParentType(onSubscribers) {}
    using boost::function<FunctionType>::operator();
  };

  template <>
  class Signal<void> : public Signal<>
  {};

  class QI_API SignalSubscriber
  : public boost::enable_shared_from_this<SignalSubscriber>
  {
  public:
    SignalSubscriber();

    SignalSubscriber(AnyFunction func, MetaCallType callType = MetaCallType_Auto);
    SignalSubscriber(AnyFunction func, ExecutionContext* ec);
    SignalSubscriber(const AnyObject& target, unsigned int method);

    SignalSubscriber(const SignalSubscriber& b);

    ~SignalSubscriber();

    void operator = (const SignalSubscriber& b);

    void call(const GenericFunctionParameters& args, MetaCallType callType);

    SignalSubscriber& setCallType(MetaCallType ct);

    void waitForInactive();

    void addActive(bool acquireLock, boost::thread::id tid = boost::this_thread::get_id());
    void removeActive(bool acquireLock, boost::thread::id tid = boost::this_thread::get_id());
    operator SignalLink() const
    {
      return linkId;
    }
    Signature signature() const;
  public:
    // Source information
    SignalBase* source;
    SignalLink  linkId;

    // Target information, kept here to be able to introspect a Subscriber
    //   Mode 1: Direct functor call
    AnyFunction       handler;
    MetaCallType      threadingModel;

    //   Mode 2: metaCall
    boost::scoped_ptr<AnyWeakObject> target;
    unsigned int      method;

    boost::mutex      mutex;
    // Fields below are protected by lock

    // If enabled is set to false while lock is acquired,
    // No more callback will trigger (activeThreads will se no push-back)
    bool                         enabled;
    // Number of calls in progress.
    // Each entry there is a subscriber call that can no longuer be aborted
    std::vector<boost::thread::id> activeThreads; // order not preserved

    boost::condition               inactiveThread;

    // ExecutionContext on which to schedule the call
    ExecutionContext* executionContext;
  };
  using SignalSubscriberPtr = boost::shared_ptr<SignalSubscriber>;
}

#ifdef _MSC_VER
#  pragma warning( pop )
#endif

#include <qi/type/detail/signal.hxx>

QI_NO_TYPE(qi::SignalBase)

#endif  // _QITYPE_SIGNAL_HPP_