Signal.hpp

Go to the documentation of this file.

#ifndef CSIGNAL_HPP
#define CSIGNAL_HPP
/*
This file is part of AlgAudio.

AlgAudio, Copyright (C) 2015 CeTA - Audiovisual Technology Center

AlgAudio is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.

AlgAudio is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with AlgAudio.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <vector>
#include <list>
#include <map>
#include <functional>
#include <iostream>
#include <memory>

namespace AlgAudio{

class SignalBase;

class Subscription{
public:
  Subscription() : id(0), target(nullptr) {}
  Subscription(Subscription&& other);
  Subscription& operator=(Subscription&& other);
  ~Subscription(){ Release(); }
  inline bool IsEmpty() const { return target == nullptr;}
  void Release();
  template <typename...>
  friend class Signal;
  Subscription(const Subscription& other) = delete; // no copy-constructing
  Subscription& operator=(const Subscription& other) = delete; // no copy assignment
  friend class SignalBase;
private:
  Subscription(int id_, SignalBase* parent) : id(id_), target(parent) {}
  int id;
  // This field is used to track who is my parent, and who where should I
  // unsubscribe from when releasing. This cannot be a pointer, because the
  // signal might have been already destroyed and we would be left with an
  // invalid pointer. Therefore we store all signals in a global list, and
  // remove then when they are destroyed.
  // int parent_signal_id;
  SignalBase* target = nullptr;
};

class SignalBase{
protected:
  SignalBase();
  SignalBase(const SignalBase&) = delete;
  virtual ~SignalBase();
  SignalBase& operator=(const SignalBase&) = delete;
  std::list< Subscription* > subscriptions;
  void SubscriptionAddressChanged(Subscription* old, Subscription* n);
  virtual void RemoveSubscriptionByID(int, Subscription*) = 0;
  static int subscription_id_counter;
  friend class Subscription;
};


template <typename... Types>
class Signal : public SignalBase{
private:
    std::list< std::function<void(Types...)> > subscribers_forever;
    std::map< int, std::function<void(Types...)> > subscribers_with_id;
    std::list< std::function<void(Types...)> > subscribers_once;
    void RemoveSubscriptionByID(int id, Subscription* ptr) override{
      auto it = subscribers_with_id.find(id);
      if(it == subscribers_with_id.end()){
        std::cout << "WARNING: removing an unexisting subscription!" << std::endl;
      }else{
        //std::cout << "WARNING: Erasing sub with id " << id << " size = "<< subscribers_with_id.size() << std::endl;
        subscribers_with_id.erase(it);
      }
      subscriptions.remove(ptr);
    }
public:
    Signal<Types...>() {}
    ~Signal(){}
    Signal(const Signal& other) = delete;
    Signal(Signal&& other) = delete;
    Signal& operator=(const Signal& other) = delete;
    Signal& operator=(Signal&& other) = delete;
    Subscription Subscribe( std::function<void(Types...)> f ) __attribute__((warn_unused_result));
    void SubscribeForever( std::function<void(Types...)> f ) { subscribers_forever.push_back(f); }
    void SubscribeOnce( std::function<void(Types...)> f ) { subscribers_once.push_back(f); }
    template<class C>
    Subscription Subscribe( C* class_ptr, void (C::*member_ptr)(Types...) ) __attribute__((warn_unused_result));
    template<class C>
    void SubscribeForever( C* class_ptr, void (C::*member_ptr)(Types...)) { subscribers_forever.push_back( std::bind(member_ptr,class_ptr,std::placeholders::_1) ); }
    template<class C>
    void SubscribeOnce( C* class_ptr, void (C::*member_ptr)(Types...)) { subscribers_once.push_back( std::bind(member_ptr,class_ptr,std::placeholders::_1) ); }
    
    bool Happen(Types... t) {
        // First, gather the list of all stuff to call. It has to be a temporary
        // local list, because the calees may modify some of the lists by
        // inserting new subscriptions.
        std::list< std::function<void(Types...)> > list_to_call;
        for(auto& f : subscribers_forever) list_to_call.push_back(f);
        for(auto& f : subscribers_once) list_to_call.push_back(f);
        for(auto& it : subscribers_with_id) list_to_call.push_back(it.second);
        // Clearing the list before calling calees, so that if they add new
        // one-time-subscriptions, they won't be lost.
        subscribers_once.clear();
        // Call everybody.
        for(auto f : list_to_call) f(t...);
        return !list_to_call.empty();
    }
    friend class Subscription;
    unsigned int Count(){return subscribers_forever.size() + subscribers_once.size() + subscribers_with_id.size();}
};

template <typename... Types>
Subscription __attribute__((warn_unused_result)) Signal<Types...>::Subscribe( std::function<void(Types...)> f ) {
  int sub_id = ++subscription_id_counter;
  subscribers_with_id[sub_id] = f;
  //std::cout << "New SUB registered " << sub_id << std::endl;
  auto p = Subscription(sub_id, this);
  subscriptions.push_back(&p);
  return p;
}
template <typename... Types> template <class C>
Subscription __attribute__((warn_unused_result)) Signal<Types...>::Subscribe( C* class_ptr, void (C::*member_ptr)(Types...)  ) {
  int sub_id = ++subscription_id_counter;
  subscribers_with_id[sub_id] = std::bind(member_ptr,class_ptr,std::placeholders::_1);
  //std::cout << "New SUB registered " << sub_id << std::endl;
  auto p = Subscription(sub_id, this);
  subscriptions.push_back(&p);
  return p;
}

class SubscriptionList{
public:
  SubscriptionList(const SubscriptionList& other) = delete;
  std::list<Subscription> list;
  void ReleaseAll() { list.clear(); }
  SubscriptionList& operator+=(Subscription&& s) {
    list.push_back(std::move(s));
    return *this;
  }
  SubscriptionList() : list(0){}
};
class SubscriptionsManager{
public:
  SubscriptionList subscriptions;
};



} //namespace AlgAudio

#endif //CSIGNAL_HPP