signalslot.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Std includes
#include <functional>
#include <set>
#include <vector>
#include <memory>
#include <iostream>
 
// Pybind includes
#include "python.h"
 
namespace nap
{
    
    // Forward declarations
    template<typename... Args> class Slot;
    
    template <typename... Args>
    class Signal final
    {
    public:
        using Function = std::function<void(Args... args)>;
 
        // Destruction
        ~Signal();
 
        void connect(Slot<Args...>& slot);
        
        void disconnect(Slot<Args...>& slot);
 
        void connect(const Function& inFunction);
 
        void connect(Signal<Args...>& signal);
        
        void disconnect(Signal<Args...>& signal);
 
#ifdef NAP_ENABLE_PYTHON
 
        void connect(const pybind11::function pythonFunction);
#endif // NAP_ENABLE_PYTHON
 
        template <typename U, typename F>
        void connect(U* object, F memberFunction)                                   { connect(std::bind(memberFunction, object, std::placeholders::_1)); }
 
        inline void operator()(Args... args)                                        { trigger(std::forward<Args>(args)...);  }
 
        void trigger(Args... args);
 
    private:
        // Called by signal when connected
        void addCause(Signal<Args...>& event);
        void removeCause(Signal<Args...>& event);
 
    private:
        struct Data
        {
            union 
            {
                struct
                {
                    Signal<Args...>* mSignal;
                } USignal;
 
                struct
                {
                    Slot<Args...>* mSlot;
                } USlot;
            };
 
            enum class EType : uint8_t
            {
                SignalCause,
                SignalEffect,
                SlotEffect
            };
            EType mType;
        };
 
        // Members
        std::vector<Data>                       mData;                  // Signal/slot effects, Signal causes
        std::unique_ptr<std::vector<Function>>  mFunctionEffects;       // function objects
    };
 
 
    template <typename... Args>
    class Slot final
    {
    public:
        using Function = std::function<void(Args... args)>;
 
    public:
        // Default constructor
        Slot() = default;
 
        Slot(Function inFunction) : 
            mFunction(inFunction) 
        { }
 
        template <typename U, typename F>
        Slot(U* parent, F memberFunction) : 
            mFunction(std::bind(memberFunction, parent, std::placeholders::_1))
        { }
 
        template <typename U, typename F>
        Slot(U* parent, F memberFunction, Signal<Args...>& signal) : 
            mFunction(std::bind(memberFunction, parent, std::placeholders::_1))     { signal.connect(*this); }
 
        // Disconnect slot from signals on destruction
        ~Slot()                                                                     { disconnect(); }
 
        void disconnect();
 
        void setFunction(Function func)                                             { mFunction = func; }
 
        void trigger(Args... args);
 
        void copyCauses(const Slot& rhs);
 
        Slot& operator=(Slot&& other);
 
        Slot& operator=(const Slot& other);
 
    private:
        
        template<typename... Args_> friend class Signal;
        typedef std::vector<Signal<Args...>*> SignalList;
 
        void addCause(Signal<Args...>& event);                  
        void removeCause(Signal<Args...>& event);               
 
        Function mFunction;                                     
        SignalList mCauses;                                     
    };
 
 
    // Template Implementations
 
    template <typename... Args>
    Signal<Args...>::~Signal()
    {
        for (auto& data : mData)
        {
            if (data.mType == Data::EType::SignalCause)
                data.USignal.mSignal->disconnect(*this);
            else if (data.mType == Data::EType::SignalEffect)
                data.USignal.mSignal->removeCause(*this);
            else
                data.USlot.mSlot->removeCause(*this);
        }
    }
 
    template <typename... Args>
    void Signal<Args...>::addCause(Signal<Args...>& signal)
    {
        Data data;
        data.mType = Data::EType::SignalCause;
        data.USignal.mSignal = &signal;
        mData.push_back(data);
    }
 
    template <typename... Args>
    void Signal<Args...>::removeCause(Signal<Args...>& event)
    {
        for (int index = 0; index < mData.size(); ++index)
        {
            Data& value = mData[index];
            if (value.mType == Data::EType::SignalCause && value.USignal.mSignal == &event)
            {
                mData.erase(mData.begin() + index);
                break;
            }
        }
    }
    
    template <typename... Args>
    void Signal<Args...>::connect(Signal<Args...>& signal)
    {
        Data data;
        data.mType = Data::EType::SignalEffect;
        data.USignal.mSignal = &signal;
        mData.push_back(data);
        signal.addCause(*this);
    }
 
    template <typename... Args>
    void Signal<Args...>::disconnect(Signal<Args...>& signal)
    {
        for (int index = 0; index < mData.size(); ++index)
        {
            Data& value = mData[index];
            if (value.mType == Data::EType::SignalEffect && value.USignal.mSignal == &signal)
            {
                value.USignal.mSignal->removeCause(*this);
                mData.erase(mData.begin() + index);
                break;
            }
        }
    }
 
    template <typename... Args>
    void Signal<Args...>::connect(Slot<Args...>& slot)
    {
        Data data;
        data.mType = Data::EType::SlotEffect;
        data.USlot.mSlot = &slot;
        mData.push_back(data);
        slot.addCause(*this);
    }
 
    template <typename... Args>
    void Signal<Args...>::disconnect(Slot<Args...>& slot)
    {
        for (int index = 0; index < mData.size(); ++index)
        {
            Data& data = mData[index];
            if (data.mType == Data::EType::SlotEffect && data.USlot.mSlot == &slot)
            {
                data.USlot.mSlot->removeCause(*this);
                mData.erase(mData.begin() + index);
                break;
            }
        }
    }
    
    
    template <typename... Args>
    void Signal<Args...>::connect(const Function& inFunction)
    {
        if (!mFunctionEffects)
            mFunctionEffects = std::make_unique<std::vector<Function>>();
 
        mFunctionEffects->emplace_back(inFunction);
    }
    
#ifdef NAP_ENABLE_PYTHON   
    template <typename... Args>
    void Signal<Args...>::connect(const pybind11::function pythonFunction)
    {
        Function func = [pythonFunction](Args... args)
        {
            try
            {
                pythonFunction(pybind11::cast(std::forward<Args>(args)..., std::is_lvalue_reference<Args>::value
                                              ? pybind11::return_value_policy::reference : pybind11::return_value_policy::automatic_reference)...);
            }
            catch (const pybind11::error_already_set& err)
            {
                auto message = std::string("Runtime python error while executing signal: ") + std::string(err.what());
                
                // TODO It would be preferable to log python error message using the nap logger.
                // Unfortunately the logger is not accessible in signalslot.h though because it uses Signals itself.
                std::cout << message << std::endl;
            }
        };
        connect(func);
    }
#endif // NAP_ENABLE_PYTHON
    
    template <typename... Args>
    void Signal<Args...>::trigger(Args... args)
    {
        for (auto& data : mData)
        {
            if (data.mType == Data::EType::SignalEffect)
                data.USignal.mSignal->trigger(std::forward<Args>(args)...);
            else if (data.mType == Data::EType::SlotEffect)
                data.USlot.mSlot->trigger(std::forward<Args>(args)...);
        }
 
        if (mFunctionEffects)
            for (auto& effect : *mFunctionEffects)
                effect(std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void nap::Slot<Args...>::copyCauses(const nap::Slot<Args...>& rhs)
    {
        disconnect();
        for (auto cause : rhs.mCauses)
            cause->connect(*this);
    }
 
    template <typename... Args>
    nap::Slot<Args...>& nap::Slot<Args...>::operator=(nap::Slot<Args...>&& other)
    {
        copyCauses(other);
        mFunction = other.mFunction;
        other.disconnect();
        other.mFunction = nullptr;
        return *this;
    }
 
    template <typename... Args>
    nap::Slot<Args...>& nap::Slot<Args...>::operator=(const nap::Slot<Args...>& other)
    {
        copyCauses(other);
        mFunction = other.mFunction;
        return *this;
    }
 
    template <typename... Args>
    void nap::Slot<Args...>::trigger(Args... args)
    {
        if (mFunction)
            mFunction(std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void Slot<Args...>::disconnect()
    {
        for (int index = mCauses.size() - 1; index >= 0; --index)
            mCauses[index]->disconnect(*this);
    }
 
    template <typename... Args>
    void Slot<Args...>::addCause(Signal<Args...>& event)
    {
        mCauses.push_back(&event);
    }
 
    template <typename... Args>
    void Slot<Args...>::removeCause(Signal<Args...>& event)
    {
        for (typename SignalList::iterator pos = mCauses.begin(); pos != mCauses.end(); ++pos)
        {
            if ((*pos) == &event)
            {
                mCauses.erase(pos);
                break;
            }
        }
    }
 
} // End Namespace nap
 
 
// Macros
 
 
// Creates a slot with the given @NAME and @TYPE and binds it to @FUNCTION using a lambda
#define NSLOT(NAME, TYPE, FUNCTION) nap::Slot<TYPE> NAME = {[&](TYPE inValue) -> void { FUNCTION(inValue); }};
 
// Creates a slot with @NAME and @TYPE without binding it to a function
#define CREATE_SLOT(NAME, TYPE) nap::Slot<TYPE> NAME;
 
// Binds the already defined slot with @NAME and @TYPE to @FUNCTION
#define BIND_SLOT(NAME, TYPE, FUNCTION) NAME([&](TYPE inValue) -> void { FUNCTION(inValue); })
 
// SIGNAL MACRO
#define NSIGNAL(NAME, TYPE) nap::Signal<TYPE> NAME;