signal.h

Go to the documentation of this file.

 
#pragma once
 
#include <tuple>
#include <functional>
#include <promeki/core/namespace.h>
#include <promeki/core/variant.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename... Args> class Signal {
        public:
                using Function = std::function<void(Args...)>;
 
                template <typename T> struct removeConstAndRef {
                        using type = std::remove_const_t<std::remove_reference_t<T>>;
                };
 
                template <typename T> using RemoveConstAndRef = typename removeConstAndRef<T>::type;
 
                static VariantList pack(Args... args) {
                        return { Variant(RemoveConstAndRef<Args>(args))... };
                }
 
                Signal(void *owner = nullptr, const char *prototype = nullptr) :
                        _owner(owner), _prototype(prototype) {}
 
                void *owner() const { return _owner; }
 
                const char *prototype() const { return _prototype; }
 
                size_t connect(Function slot, void *ptr = nullptr) {
                        size_t slotID = _slots.size();
                        _slots += Info(slot, ptr);
                        return slotID;
                }
 
                template <typename T> size_t connect(T *obj, void (T::*memberFunction)(Args...)) {
                        size_t slotID = _slots.size();
                        _slots += Info(
                                ([obj, memberFunction](Args... args) {
                                         (obj->*memberFunction)(args...);
                                }), 
                                obj
                        );
                        return slotID;
                }
 
                void disconnect(size_t slotID) {
                        _slots.remove(slotID);
                        return;
                }
 
                template <typename T> void disconnect(const T *object, void (T::*memberFunction)(Args...)) {
                        _slots.removeIf([object, memberFunction](const Info &info) { 
                                        return static_cast<const T *>(info.object) == object && info.func == memberFunction;
                        });
                        return;
                }
 
                template <typename T> void disconnectFromObject(const T *object) {
                        _slots.removeIf([object](const Info &info) { return static_cast<const T *>(info.object) == object; });
                        return;
                }
 
                void emit(Args... args) const {
                        for (const auto &slot : _slots) slot.func(args...);
                        return;
                }
 
 
        private:
                class Info {
                        public:
                                Function        func;
                                const void      *object = nullptr;
 
                                Info(Function f, const void *obj = nullptr) : func(f), object(obj) {}
                };
 
                void            *_owner = nullptr;
                const char      *_prototype = nullptr;
                List<Info>      _slots;
};
 
PROMEKI_NAMESPACE_END