Signals.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include <functional>
#include <vector>

namespace rose {

    template<typename ... Args>
    struct Slot : public std::enable_shared_from_this<Slot<Args...>> {
        using signal_function = std::function<void(Args...)>;

        signal_function receiver{};
    };

    template<typename ... Args>
    class Signal {
    protected:
        std::vector<std::weak_ptr<Slot<Args...>>> callList{};

    public:
        using signal_function = std::function<void(Args...)>;

        explicit operator bool () {
            return !callList.empty();
        }

        void clean() {
            callList.erase(std::remove_if(callList.begin(), callList.end(), [](auto weak) {
                return weak.expired();
            }), callList.end());
        }

        void connect(std::shared_ptr<Slot<Args...>> &slot) {
            if (slot) {
                clean();
                for (auto &weak : callList) {
                    if (auto locked = weak.lock(); locked) {
                        if (locked == slot)
                            return;
                    }
                }

                callList.push_back(slot);
            }
        }

        void disconnect(std::shared_ptr<Slot<Args...>> &slot) {
            callList.erase(std::remove_if(callList.begin(), callList.end(), [&](auto weak) {
                if (weak.expired())
                    return true;
                if (auto strong = weak.lock(); strong)
                    return strong == slot;
                return false;
            }));
        }

        void transmit(Args ... args) {
            bool expired = false;
            for (auto &weak : callList) {
                if (auto slot = weak.lock(); slot) {
                    if (slot->receiver)
                        slot->receiver(args...);
                } else {
                    expired = true;
                }
            }

            if (expired)
                clean();
        }
    };

    template<typename ... Args>
    struct Protocol {
        typedef std::shared_ptr<Slot<Args...>> slot_type;   
        typedef Signal<Args...> signal_type;                

        static slot_type createSlot() {
            return std::make_shared<Slot<Args...>>();
        }
    };

}