SignalSlot.h

Go to the documentation of this file.

/*
 * Copyright 2015-2021 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <cassert>
#include <functional>
#include <vector>
 
namespace mc_rtc
{
 
template<typename... ArgsT>
struct Signal;
 
template<typename... ArgsT>
struct Slot;
 
template<typename... ArgsT>
struct Signal
{
  using SignalT = Signal<ArgsT...>;
  using SlotT = Slot<ArgsT...>;
  friend SlotT;
  using CallbackT = std::function<void(ArgsT...)>;
 
  Signal() = default;
 
  template<typename Callable>
  SlotT connect(Callable && callback)
  {
    SlotT out{this, next_slot_};
    if(next_slot_ < callbacks_.size()) { callbacks_[next_slot_] = callback; }
    else
    {
      callbacks_.push_back(callback);
    }
    next_slot_++;
    while(next_slot_ < callbacks_.size() && callbacks_[next_slot_]) { next_slot_++; }
    return out;
  }
 
  void signal(ArgsT... args)
  {
    for(auto & c : callbacks_)
    {
      if(c) { c(args...); }
    }
  }
 
  struct Proxy
  {
    Proxy(SignalT & self) : self_(self) {}
 
    template<typename Callable>
    SlotT connect(Callable && callback)
    { return self_.connect(std::forward<Callable>(callback)); }
 
  private:
    SignalT & self_;
  };
 
protected:
  void disconnect(size_t idx)
  {
    assert(idx < callbacks_.size());
    callbacks_[idx] = {};
    next_slot_ = std::min(idx, next_slot_);
  }
  std::vector<CallbackT> callbacks_;
  size_t next_slot_ = 0;
};
 
template<typename... ArgsT>
struct Slot
{
  using SignalT = Signal<ArgsT...>;
  friend SignalT;
 
  Slot() = default;
  Slot(const Slot &) = delete;
  Slot(Slot && rhs)
  {
    signal_ = rhs.signal_;
    idx_ = rhs.idx_;
    rhs.signal_ = nullptr;
  }
  Slot & operator=(const Slot &) = delete;
  Slot & operator=(Slot && rhs)
  {
    if(&rhs == this) { return *this; }
    signal_ = rhs.signal_;
    idx_ = rhs.idx_;
    rhs.signal_ = nullptr;
    return *this;
  }
 
  ~Slot() { disconnect(); }
 
  void disconnect()
  {
    if(signal_)
    {
      signal_->disconnect(idx_);
      signal_ = nullptr;
    }
  }
 
protected:
  Slot(SignalT * sig, size_t idx) : signal_(sig), idx_(idx) {}
 
private:
  SignalT * signal_ = nullptr;
  size_t idx_ = 0;
};
 
} // namespace mc_rtc