objectbase.h

Go to the documentation of this file.

 
#pragma once
 
#include <tuple>
#include <functional>
#include <promeki/core/namespace.h>
#include <promeki/core/list.h>
#include <promeki/core/map.h>
#include <promeki/core/mutex.h>
#include <promeki/core/util.h>
#include <promeki/core/logger.h>
#include <promeki/core/signal.h>
#include <promeki/core/slot.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class EventLoop;
class Event;
class TimerEvent;
 
#define PROMEKI_OBJECT(ObjectName, ParentObjectName) \
        public: \
                static const MetaInfo &metaInfo() { \
                        static const MetaInfo __metaInfo( \
                                typeid(ObjectName).name(), \
                                &ParentObjectName::metaInfo() \
                        ); \
                        return __metaInfo; \
                }
               
#define PROMEKI_SIGNAL(SIGNALNAME, ...) \
        static constexpr const char *SIGNALNAME##SignalName = PROMEKI_STRINGIFY(SIGNALNAME) "(" PROMEKI_STRINGIFY_ARGS(__VA_ARGS__) ")"; \
        static inline SignalMeta SIGNALNAME##SignalMeta = SignalMeta(metaInfo(), SIGNALNAME##SignalName); \
        Signal<__VA_ARGS__> SIGNALNAME##Signal = Signal<__VA_ARGS__>(this, SIGNALNAME##SignalName);
 
#define PROMEKI_SLOT(SLOTNAME, ...) \
        static constexpr const char *SLOTNAME##SlotName = PROMEKI_STRINGIFY(SLOTNAME) "(" PROMEKI_STRINGIFY_ARGS(__VA_ARGS__) ")"; \
        static inline SlotMeta SLOTNAME##SlotMeta = SlotMeta(metaInfo(), SLOTNAME##SlotName); \
        void SLOTNAME(__VA_ARGS__); \
        Slot<__VA_ARGS__> SLOTNAME##Slot = Slot<__VA_ARGS__>( \
                [this](auto&&... args) { this->SLOTNAME(std::forward<decltype(args)>(args)...); }, \
                this, SLOTNAME##SlotName \
        ); \
        int SLOTNAME##SlotID = registerSlot(&SLOTNAME##Slot);
 
 
PROMEKI_DEBUG(ObjectBase)
 
class ObjectBase;
 
using ObjectBaseList = List<ObjectBase *>;
 
class ObjectBasePtr {
        friend class ObjectBase;
        public:
                ObjectBasePtr(ObjectBase *object = nullptr) : p(object) { link(); }
 
                ObjectBasePtr(const ObjectBasePtr &object) : p(object.p.load(std::memory_order_relaxed)) { link(); }
 
                ~ObjectBasePtr() { unlink(); }
 
                ObjectBasePtr &operator=(const ObjectBasePtr &object) {
                        unlink();
                        p.store(object.p.load(std::memory_order_relaxed), std::memory_order_relaxed);
                        link();
                        return *this;
                }
 
                bool isValid() const { return p.load(std::memory_order_acquire) != nullptr; }
 
                ObjectBase *data() { return p.load(std::memory_order_acquire); }
 
                const ObjectBase *data() const { return p.load(std::memory_order_acquire); }
 
        private:
                std::atomic<ObjectBase *> p{nullptr};
 
                void link();
                void unlink();
};
 
 
class ObjectBase {
        friend class ObjectBasePtr;
        friend class EventLoop;
        public:
                class SignalMeta;
                class SlotMeta;
 
                class MetaInfo {
                        friend class SignalMeta;
                        friend class SlotMeta;
                        public:
                                using SignalList = List<SignalMeta *>;
                                using SlotList = List<SlotMeta *>;
                                MetaInfo(const char *n, const MetaInfo *p = nullptr) : _parent(p), _name(n) {}
 
                                const MetaInfo *parent() const { return _parent; }
 
                                const char *name() const;
 
                                const SignalList &signalList() const { return _signalList; }
 
                                const SlotList &slotList() const { return _slotList; }
 
                                void dumpToLog() const;
 
                        private:
                                const MetaInfo                  *_parent;
                                const char                      *_name;
                                mutable String                  _demangledName;
                                mutable SignalList              _signalList;
                                mutable SlotList                _slotList;
                };
 
                class SignalMeta {
                        public:
                                SignalMeta(const MetaInfo &m, const char *n) :
                                        _meta(m), _name(n)
                                {
                                        m._signalList += this;
                                }
 
                                const char *name() const { return _name; }
                        private:
                                const MetaInfo  &_meta;
                                const char      *_name;
                };
 
                class SlotMeta {
                        public:
                                SlotMeta(const MetaInfo &m, const char *n) :
                                        _meta(m), _name(n)
                                {
                                        m._slotList += this;
                                }
 
                                const char *name() const { return _name; }
                        private:
                                const MetaInfo  &_meta;
                                const char      *_name;
                };
 
                static const MetaInfo &metaInfo() {
                        static const MetaInfo __metaInfo(
                                typeid(ObjectBase).name());
                        return __metaInfo;
                }
 
                template <typename... Args> static void connect(Signal<Args...> *signal, Slot<Args...> *slot);
 
 
                using SlotVariantFunc = std::function<void(const VariantList &)>;
 
                ObjectBase(ObjectBase *p = nullptr);
 
 
                virtual ~ObjectBase() {
                        aboutToDestroySignal.emit(this);
                        setParent(nullptr);
                        destroyChildren();
                        runCleanup();
                }
 
                ObjectBase *parent() const {
                        return _parent;
                }
 
                void setParent(ObjectBase *p) {
                        if(_parent != nullptr) _parent->removeChild(this);
                        _parent = p;
                        if(_parent != nullptr) _parent->addChild(this);
                        return;
                }
 
                const ObjectBaseList &childList() const {
                        return _childList;
                }
 
                template <typename... Args> int registerSlot(Slot<Args...> *slot) {
                        int ret = _slotList.size();
                        slot->setID(ret);
                        _slotList += SlotItem(
                                ret,
                                slot->prototype(),
                                [slot](const VariantList &args) { slot->exec(args); }
                        );
                        return ret;
                }
 
                PROMEKI_SIGNAL(aboutToDestroy, ObjectBase *);
 
                EventLoop *eventLoop() const { return _eventLoop; }
 
                void moveToThread(EventLoop *loop);
 
                int startTimer(unsigned int intervalMs, bool singleShot = false);
 
                void stopTimer(int timerId);
 
        protected:
                ObjectBase *signalSender() { return _signalSender; }
 
                virtual void event(Event *e);
 
                virtual void timerEvent(TimerEvent *e);
 
 
        private:
                using CleanupFunc = std::function<void(ObjectBase *)>;
 
                struct SlotItem {
                        int                     id;
                        const char              *prototype;
                        SlotVariantFunc         variantFunc;
                };
 
                struct Cleanup {
                        ObjectBasePtr           object;
                        CleanupFunc             func;
                };
 
                ObjectBase                                      *_parent = nullptr;
                ObjectBase                                      *_signalSender = nullptr;
                EventLoop                                       *_eventLoop = nullptr;
                ObjectBaseList                                  _childList;
                List<SlotItem>                                  _slotList;
                mutable Mutex                                   _pointerMapMutex; 
                Map<ObjectBasePtr *, ObjectBasePtr *>           _pointerMap;
                List<Cleanup>                                   _cleanupList;
 
                void setEventLoopRecursive(EventLoop *loop);
 
                void addChild(ObjectBase *c) {
                        _childList += c;
                        return;
                }
 
                void removeChild(ObjectBase *c) {
                        _childList.removeFirst(c);
                        return;
                }
 
                void destroyChildren() {
                        for(auto child : _childList) {
                                child->_parent = nullptr;
                                delete child;
                        }
                        _childList.clear();
                        return;
                }
 
                void runCleanup() {
                        // Null out any ObjectBasePtr's that are currently pointing
                        // to this object.  Hold the mutex so concurrent unlink()
                        // on another thread won't modify _pointerMap mid-iteration.
                        {
                                Mutex::Locker lock(_pointerMapMutex);
                                for(auto item : _pointerMap) {
                                        item.first->p.store(nullptr, std::memory_order_release);
                                }
                                _pointerMap.clear();
                        }
 
                        // Walk down the cleanup list and run any cleanup functions
                        for(auto &item : _cleanupList) {
                                if(!item.object.isValid()) continue;
                                item.func(this);
                        }
                        _cleanupList.clear();
                        return;
                }
};
 
inline void ObjectBasePtr::link() {
        ObjectBase *obj = p.load(std::memory_order_relaxed);
        if(obj != nullptr) {
                Mutex::Locker lock(obj->_pointerMapMutex);
                obj->_pointerMap[this] = this;
        }
        return;
}
 
inline void ObjectBasePtr::unlink() {
        ObjectBase *obj = p.exchange(nullptr, std::memory_order_acq_rel);
        if(obj != nullptr) {
                Mutex::Locker lock(obj->_pointerMapMutex);
                auto it = obj->_pointerMap.find(this);
                if(it != obj->_pointerMap.end()) {
                        obj->_pointerMap.remove(it);
                }
        }
}
 
PROMEKI_NAMESPACE_END
 
// connect() template requires EventLoop to be complete for cross-thread dispatch.
#include <promeki/core/eventloop.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename... Args>
void ObjectBase::connect(Signal<Args...> *signal, Slot<Args...> *slot) {
        if(signal == nullptr || slot == nullptr) return;
 
        signal->connect([signal, slot](Args... args) {
                ObjectBase *signalObject = static_cast<ObjectBase *>(signal->owner());
                ObjectBase *slotObject = static_cast<ObjectBase *>(slot->owner());
 
                EventLoop *slotLoop = slotObject->_eventLoop;
                EventLoop *currentLoop = EventLoop::current();
 
                // Same thread or no event loop: direct call (zero overhead path)
                if(slotLoop == nullptr || slotLoop == currentLoop) {
                        ObjectBase *prevSender = slotObject->_signalSender;
                        slotObject->_signalSender = signalObject;
                        slot->exec(args...);
                        slotObject->_signalSender = prevSender;
                } else {
                        // Cross-thread: marshal via VariantList and post
                        VariantList packed = Signal<Args...>::pack(args...);
                        ObjectBasePtr senderTracker(signalObject);
                        slotLoop->postCallable(
                                [slot, slotObject, packed = std::move(packed),
                                 senderTracker = std::move(senderTracker)]() {
                                        ObjectBase *prevSender = slotObject->_signalSender;
                                        slotObject->_signalSender =
                                                senderTracker.isValid()
                                                ? const_cast<ObjectBase *>(senderTracker.data())
                                                : nullptr;
                                        slot->exec(packed);
                                        slotObject->_signalSender = prevSender;
                                }
                        );
                }
        }, slot->owner());
 
        // Register a cleanup
        ObjectBase *signalObject = static_cast<ObjectBase *>(signal->owner());
        ObjectBase *slotObject = static_cast<ObjectBase *>(slot->owner());
        slotObject->_cleanupList += Cleanup(
                signalObject,
                [signal](ObjectBase *ptr){ signal->disconnectFromObject(ptr); }
        );
}
 
PROMEKI_NAMESPACE_END