objectbase.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <tuple>
#include <type_traits>
#include <functional>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/mutex.h>
#include <promeki/util.h>
#include <promeki/logger.h>
#include <promeki/signal.h>
#include <promeki/slot.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Variant;
class VariantList;
class VariantMap;
 
class EventLoop;
class Event;
class TimerEvent;
class Thread;
 
#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);
 
 
class ObjectBase;
 
using ObjectBaseList = ::promeki::List<ObjectBase *>;
 
template <typename T = ObjectBase> class ObjectBasePtr {
                friend class ObjectBase;
                template <typename U> friend class ObjectBasePtr;
 
        public:
                ObjectBasePtr(T *object = nullptr) { linkTo(object); }
 
                ObjectBasePtr(const ObjectBasePtr &other) { linkFromSource(other.p); }
 
                template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U> && !std::is_same_v<T, U>>>
                ObjectBasePtr(const ObjectBasePtr<U> &other) {
                        linkFromSource(other.p);
                }
 
                ~ObjectBasePtr() { unlink(); }
 
                ObjectBasePtr &operator=(const ObjectBasePtr &other) {
                        if (this == &other) return *this;
                        unlink();
                        linkFromSource(other.p);
                        return *this;
                }
 
                bool isValid() const { return p.load(MemoryOrder::Acquire) != nullptr; }
 
                T *data() { return static_cast<T *>(p.load(MemoryOrder::Acquire)); }
 
                const T *data() const { return static_cast<const T *>(p.load(MemoryOrder::Acquire)); }
 
        private:
                using TrackerPtr = promeki::Atomic<ObjectBase *>;
 
                TrackerPtr p{nullptr};
 
                // Atomically (under @ref ObjectBase::objectBasePtrMutex)
                // sets @c p to @p obj and registers @c &p in
                // @c obj->_pointerMap.  Used by every ObjectBasePtr
                // constructor / assignment so the store of @c p and
                // the addition to @c _pointerMap happen as a single
                // critical section — without this fold a concurrent
                // @ref ObjectBase::runCleanup can null every existing
                // tracker, release the mutex, and let a later @c link
                // write to freed memory while leaving the new tracker
                // dangling-but-non-null.
                void linkTo(ObjectBase *obj);
 
                // Like @ref linkTo but reads the source pointer from
                // another ObjectBasePtr's atomic under the same lock,
                // so a concurrent destruction of the tracked object
                // cannot slip between the read and the registration.
                void linkFromSource(const TrackerPtr &source);
 
                void unlink();
};
 
template <typename T> ObjectBasePtr(T *) -> ObjectBasePtr<T>;
 
 
class ObjectBase {
                template <typename U> friend class ObjectBasePtr;
                friend class EventLoop;
 
        public:
                class SignalMeta;
                class SlotMeta;
 
                class MetaInfo {
                                friend class SignalMeta;
                                friend class SlotMeta;
 
                        public:
                                using SignalList = ::promeki::List<SignalMeta *>;
                                using SlotList = ::promeki::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);
 
 
                ObjectBase(ObjectBase *p = nullptr);
 
                ObjectBase(const ObjectBase &) = delete;
                ObjectBase(ObjectBase &&) = delete;
                ObjectBase &operator=(const ObjectBase &) = delete;
                ObjectBase &operator=(ObjectBase &&) = delete;
 
                virtual ~ObjectBase() {
                        aboutToDestroySignal.emit(this);
                        setParent(nullptr);
                        destroyChildren();
                        runCleanup();
                }
 
                ObjectBase *parent() const { return _parent; }
 
                void setParent(ObjectBase *p);
 
                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());
                        return ret;
                }
 
                PROMEKI_SIGNAL(aboutToDestroy, ObjectBase *);
 
                EventLoop *eventLoop() const { return _eventLoop; }
 
                Thread *thread() const { return _thread; }
 
                void moveToThread(Thread *t);
 
                int startTimer(unsigned int intervalMs, bool singleShot = false);
 
                void stopTimer(int timerId);
 
                void deleteLater();
 
                using CleanupHandler = Function<void(ObjectBase *)>;
 
                void registerCleanup(ObjectBase *target, CleanupHandler fn);
 
        protected:
                ObjectBase *signalSender() { return _signalSender; }
 
                virtual void event(Event *e);
 
                virtual void timerEvent(TimerEvent *e);
 
 
        private:
                using CleanupFunc = CleanupHandler;
 
                struct SlotItem {
                                int         id;
                                const char *prototype;
                };
 
                struct Cleanup {
                                ObjectBasePtr<> object;
                                CleanupFunc     func;
                };
 
                ObjectBase    *_parent = nullptr;
                ObjectBase    *_signalSender = nullptr;
                Thread        *_thread = nullptr;
                EventLoop     *_eventLoop = nullptr;
                ObjectBaseList _childList;
                List<SlotItem> _slotList;
 
                using PointerMapKey = promeki::Atomic<ObjectBase *> *;
                using PointerMap    = promeki::Map<PointerMapKey, PointerMapKey>;
                PointerMap _pointerMap; 
                List<Cleanup> _cleanupList;
 
                // A single process-wide mutex serializes every
                // ObjectBasePtr link / unlink (linkTo, linkFromSource,
                // unlink) with ObjectBase::runCleanup.  A per-object
                // mutex is unsafe here because unlink reads the obj
                // pointer via the atomic and *then* needs to take a
                // lock to manipulate the map — if we put that lock on
                // the object itself, the object can be destroyed in
                // between, leaving us with a use-after-free on the
                // mutex member.  Serializing through one global mutex
                // closes that window: an unlink that observes obj
                // != nullptr is guaranteed that runCleanup hasn't run
                // yet (and won't until we release).  The link path
                // folds the source-pointer load and the @c _pointerMap
                // registration into the same critical section so a
                // newly constructed tracker is either fully registered
                // before runCleanup nulls it, or never observes a
                // doomed pointer at all.
                static Mutex &objectBasePtrMutex();
 
                void setOwnerThreadRecursive(Thread *t, 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 global mutex so a concurrent
                        // ObjectBasePtr link / unlink on another thread can't
                        // observe a half-destroyed object.
                        {
                                Mutex::Locker lock(objectBasePtrMutex());
                                for (auto item : _pointerMap) {
                                        item.first->store(nullptr, MemoryOrder::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;
                }
};
 
template <typename T> inline void ObjectBasePtr<T>::linkTo(ObjectBase *obj) {
        // Single critical section: store @c p and add to the tracked
        // object's @c _pointerMap atomically.  An interleaved
        // runCleanup can either run entirely before us (it sees no
        // entry, then we observe the cleared @c _pointerMap and
        // implicitly do nothing meaningful — though @c obj is then a
        // dangling pointer, see note below) or entirely after us (it
        // observes the new entry and nulls @c p).  Either way the
        // invariant "non-null @c p implies registered in the tracked
        // object's @c _pointerMap" holds for the duration of the
        // tracker's life.
        //
        // Note on the dangling-input case: callers of this constructor
        // pass a raw pointer they own.  If the caller's object is
        // destroyed before @c linkTo runs, that's a caller-side
        // lifetime bug, not something this class can plug.  The
        // mutex-protected variant @ref linkFromSource exists for the
        // copy paths where the source is itself an ObjectBasePtr and
        // can be invalidated concurrently — that one re-checks the
        // atomic under the lock.
        Mutex::Locker lock(ObjectBase::objectBasePtrMutex());
        p.store(obj, MemoryOrder::Relaxed);
        if (obj != nullptr) {
                obj->_pointerMap[&p] = &p;
        }
        return;
}
 
template <typename T>
inline void ObjectBasePtr<T>::linkFromSource(const TrackerPtr &source) {
        // Lock first, then load the source: if a concurrent
        // runCleanup is mid-flight on the tracked object it has
        // already nulled the source's atomic before releasing the
        // mutex, so once we hold the lock the source either still
        // points at a live object (which can't be destroyed until we
        // release) or has been nulled (we observe nullptr and link to
        // nothing).  Performing the source load *outside* the lock —
        // as the previous mem-initializer pattern did — leaves a
        // window where @c p is set to a doomed pointer, runCleanup
        // misses us because we're not in @c _pointerMap yet, and the
        // subsequent registration writes through a freed @c obj.
        Mutex::Locker lock(ObjectBase::objectBasePtrMutex());
        ObjectBase   *obj = source.load(MemoryOrder::Relaxed);
        p.store(obj, MemoryOrder::Relaxed);
        if (obj != nullptr) {
                obj->_pointerMap[&p] = &p;
        }
        return;
}
 
template <typename T> inline void ObjectBasePtr<T>::unlink() {
        // Same ordering as the link path: acquire the global mutex
        // first so we can't race ObjectBase::runCleanup, which holds
        // the same lock while it walks _pointerMap and frees the
        // trackers.
        Mutex::Locker lock(ObjectBase::objectBasePtrMutex());
        ObjectBase   *obj = p.exchange(nullptr, MemoryOrder::AcqRel);
        if (obj != nullptr) {
                auto it = obj->_pointerMap.find(&p);
                if (it != obj->_pointerMap.end()) {
                        obj->_pointerMap.remove(it);
                }
        }
}
 
PROMEKI_NAMESPACE_END
 
// The template bodies for ObjectBase::connect and
// Signal<Args...>::connect(Function, ObjectBase *) previously lived at
// the bottom of this file but pulled @c variant.h and @c eventloop.h
// into every TU that includes @c objectbase.h — ~270 of them.  They
// now live in @c objectbase.tpp; TUs that actually call those methods
// must include @c promeki/objectbase.tpp.
 
#endif // PROMEKI_ENABLE_CORE