signal.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <tuple>
#include <functional>
#include <promeki/atomic.h>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/list.h>
#include <promeki/mutex.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class ObjectBase;
class Variant;
class VariantList;
 
template <typename... Args> class Signal {
        public:
                using Function = promeki::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);
 
                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 = nextSlotId();
                        Mutex::Locker lock(_slotsMutex);
                        _slots += Info(slotID, slot, ptr);
                        return slotID;
                }
 
                size_t connect(Function slot, ObjectBase *owner);
 
                template <typename T> size_t connect(T *obj, void (T::*memberFunction)(Args...)) {
                        size_t slotID = nextSlotId();
                        Mutex::Locker lock(_slotsMutex);
                        _slots += Info(slotID,
                                       ([obj, memberFunction](Args... args) { (obj->*memberFunction)(args...); }), obj);
                        return slotID;
                }
 
                void disconnect(size_t slotID) {
                        Mutex::Locker lock(_slotsMutex);
                        _slots.removeIf([slotID](const Info &info) { return info.id == slotID; });
                        return;
                }
 
                template <typename T> void disconnect(const T *object, void (T::*memberFunction)(Args...)) {
                        Mutex::Locker lock(_slotsMutex);
                        _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) {
                        Mutex::Locker lock(_slotsMutex);
                        _slots.removeIf(
                                [object](const Info &info) { return static_cast<const T *>(info.object) == object; });
                        return;
                }
 
                void emit(Args... args) const {
                        // Snapshot under the lock so iteration runs
                        // against a stable copy.  Concurrent
                        // connect / disconnect calls only mutate the
                        // live @c _slots — the snapshot is unaffected,
                        // which keeps reentrant connect / disconnect
                        // from a slot safe and matches Boost.Signals2
                        // semantics.
                        List<Info> snapshot;
                        {
                                Mutex::Locker lock(_slotsMutex);
                                snapshot = _slots;
                        }
                        for (const auto &slot : snapshot) slot.func(args...);
                        return;
                }
 
 
        private:
                struct Info {
                                size_t      id = 0;
                                Function    func;
                                const void *object = nullptr;
 
                                Info(size_t id, Function f, const void *obj = nullptr) : id(id), func(f), object(obj) {}
                };
 
                void         *_owner = nullptr;
                const char   *_prototype = nullptr;
                List<Info>    _slots;
                mutable Mutex _slotsMutex;
 
                // Process-wide monotonic ID source.  Kept as a function-local
                // static (rather than a member) so that adding it does not
                // change Signal's class layout or ABI — important because
                // Signal is embedded in every ObjectBase-derived type via
                // the @c PROMEKI_SIGNAL macro.
                static size_t nextSlotId() {
                        static Atomic<size_t> counter{0};
                        return ++counter;
                }
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE