Signal.hpp

Go to the documentation of this file.

// This file is part of GranOO, a workbench for DEM simulation.
//
// Author(s)    : - Damien Andre       IRCER/UNILIM, Limoges France
//                  <damien.andre@unilim.fr>
//                - Jean-luc Charles   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jean-luc.charles@ensam.eu>
//                - Jeremie Girardot   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jeremie.girardot@ensam.eu>
//                - Cedric Hubert      LAMIH/UPHF, Valenciennes France
//                  <cedric.hubert@uphf.fr>
//                - Ivan Iordanoff     Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <ivan.iordanoff@ensam.eu>
//
// Copyright (C) 2008-2019 D. Andre, JL. Charles, J. Girardot, C. Hubert, I. Iordanoff
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
// File from http://simmesimme.github.io/tutorials/2015/09/20/signal-slot
// No licence was found
 
#ifndef _Core_Signal_hpp_
#define _Core_Signal_hpp_
 
#include <functional>
#include <map>
 
 
namespace GranOO3
{
  namespace Core
  {
 
    // A signal object may call multiple slots with the
    // same signature. You can connect functions to the signal
    // which will be called when the emit_signal() method on the
    // signal object is invoked. Any argument passed to emit_signal()
    // will be passed to the given functions.
 
    template <typename ... Args>
    class Signal
    {
    public:
      Signal() : _current_ID(0) {
      }
 
      // copy creates new signal
      Signal(Signal const& other) : _current_ID(0) {
      }
 
      // connects a member function to this Signal
      template <typename T>
      int connect_member(T* inst, void (T::*func)(Args...)) {
        return connect([ = ](Args... args) {
          (inst->*func)(args ...);
        });
      }
 
      // connects a const member function to this Signal
      template <typename T>
      int connect_member(T* inst, void (T::*func)(Args...) const) {
        return connect([ = ](Args... args) {
          (inst->*func)(args ...);
        });
      }
 
      // connects a std::function to the signal. The returned
      // value can be used to disconnect the function again
      int connect(std::function<void(Args...)> const& slot) const {
        slots_.insert(std::make_pair(++_current_ID, slot));
        return _current_ID;
      }
 
      // disconnects a previously connected function
      void disconnect(int id) const {
        slots_.erase(id);
      }
 
      // disconnects all previously connected functions
      void disconnect_all() const {
        slots_.clear();
      }
 
      // calls all connected functions
      void emit_signal(Args... p) {
        for (auto it : slots_) {
          it.second(p ...);
        }
      }
 
    private:
      mutable std::map<int, std::function<void(Args...)> > slots_;
      mutable int _current_ID;
    };
 
 
 
 
  }
}
 
#endif