Linkable.hh

Go to the documentation of this file.

#pragma once
// Wrap an object in a linkable pointer.
// Link to other reference wrappers.
#ifndef LINKABLE_HH
#define LINKABLE_HH
 
#include <memory>
#include <mutex>
#include <stdexcept>
#include <type_traits>
#include <vector>
#include <sanitizer/lsan_interface.h>
#define SET_LINK_TYPE std::true_type
#define SET_LINK std::true_type{}
 
 
 
 
// Geant things need to not be deleted:
namespace DLG4::VolumeBuilders::_internals_ {
    namespace PersistentObjectRegistry {
        // For Geant, we need things left persistent.
        // Yes, in header this is multiple "registries" but this is a black hole anyway.
        inline auto black_hole = []() {
            auto* bh = new std::vector<std::shared_ptr<void>>();
#ifdef __SANITIZE_ADDRESS__
            __lsan_ignore_object(bh);
#endif
            return bh;
        }();
        inline std::mutex s_registry_mutex;
    }
 
    using namespace PersistentObjectRegistry;
 
    // enable a mocked version that helps code analysis, now incomplete though.
    //#define DEBUG
#ifdef DEBUG
    // a mock version to help with IDE.
    template <typename T>
    class Linkable {
    private:
        T value_; // Store a plain object for simplicity
 
    public:
        Linkable() : value_() {
            std::cout << "Mock Linkable default ctor\n";
        }
 
        Linkable(const Linkable<T> &other) : value_(other.value_) {
            std::cout << "Mock Linkable copy ctor (deep copy)\n";
        }
 
        Linkable(const Linkable<T> &other, SET_LINK_TYPE) : value_(other.value_) {
            std::cout << "Mock Linkable linking ctor\n";
        }
 
        void reset() {
            std::cout << "Mock Linkable reset()\n";
        }
 
        T *get() { return &T; };
 
        explicit Linkable(const T &other) : value_(other) {
            std::cout << "Mock Linkable value ctor\n";
        }
 
        explicit operator bool() const noexcept {
            return true;
        }
 
        T *operator->() {
            return &value_;
        }
 
        T &operator*() {
            return value_;
        }
 
        Linkable<T> &operator=(const Linkable<T> &other) {
            std::cout << "Mock Linkable assignment\n";
            value_ = other.value_;
            return *this;
        }
 
        void Link(const Linkable<T> &other) {
            std::cout << "Mock Linkable Link()\n";
            value_ = other.value_;
        }
    };
#else
 
    template <typename T>
    class Linkable {
    private:
        std::shared_ptr<T> ref_ = nullptr;             // points to the source if any
        mutable std::vector<Linkable<T> *> backlinks_; // points to things that linked to us.
        mutable Linkable<T> *downlink_ = nullptr;      // points to things we linked to.
        mutable Linkable<T> *rootlink_ = nullptr;
        static inline std::recursive_mutex s_link_mutex;
 
    public:
        Linkable()
            : ref_() {
        }
 
        //destructor
        ~Linkable() {
            std::lock_guard<std::recursive_mutex> lock(s_link_mutex);
            // remove ourselves from the backlinks of the downlink
            // this prevents corrupt backlink propagation after we are deleted.
            if (downlink_) {
                auto &parent_backlinks = downlink_->backlinks_;
                auto it = std::remove(parent_backlinks.begin(), parent_backlinks.end(), this);
                if (it != parent_backlinks.end()) {
                    parent_backlinks.erase(it, parent_backlinks.end());
                }
            }
            // remove downlinks from our backlinks
            // Does this orphan chains?:
            //  If we have a ref, link to will error anyway
            //  If we don't have a ref, we just become the root.
            //  No harm.  Nothing linked, nothing lost.
            // But backlinks become detatched from each other, have different views.
            // So relink to the first backlink, making it the root.
            Linkable<T> *first_link = nullptr;
            for (auto *child : backlinks_) {
                if (child->downlink_ == this) {
                    if (bool is_first_link = false; !is_first_link) {
                        first_link = child;
                        child->downlink_ = nullptr;
                    } else {
                        child->downlink_ = first_link;
                    }
                }
            }
            backlinks_.clear();
            //if this matters, something is already very wrong.  But it can help unmask that.
        }
 
        Linkable(const Linkable<T> &other) :
            ref_(std::make_shared<T>(*other.ref_)) {
        }
 
        Linkable(Linkable<T> &other, SET_LINK_TYPE) {
            ref_ = nullptr;
            LinkTreeTo(other);
        }
 
        explicit Linkable(const T &other)
            : ref_(std::make_shared<T>(other)) {
        }
 
        //
        // const Forwarding methods:
 
        template <typename U = T>
        std::enable_if_t<!std::is_pointer_v<U>, U *>
        operator->() const {
            return ref_.get();
        }
 
        template <typename U = T>
        std::enable_if_t<std::is_pointer_v<U>, std::remove_pointer_t<U> *>
        operator->() const {
            return *ref_;
        }
 
        template <typename U = T>
        std::enable_if_t<!std::is_pointer_v<U>, U &>
        operator*() const {
            return *ref_;
        }
 
        template <typename U = T>
        std::enable_if_t<std::is_pointer_v<U>, std::remove_pointer_t<U> &>
        operator*() const {
            return **ref_;
        }
 
        const Linkable<T> &operator=(const Linkable<T> &other) const {
            *ref_ = *(other.ref_);
            return *this; // return const ref to self.
        }
 
        Linkable &operator=(const T &other) const {
            *ref_ = other;
            return *this;
        }
 
        void LinkToRaw(T *ptr) {
            auto data = std::shared_ptr<T>(ptr, [](T *)
            {
                /* do nothing */
            });
            LinkTreeTo(data);
        }
 
        // Non const link reseters:
 
        void Link(Linkable<T> &other) {
            LinkTreeTo(other);
        }
 
        template <typename X>
        struct false_template: std::false_type {
        };
 
        //Accept shared ownership.
        void ShareLink(std::shared_ptr<T> other) {
            if (!other) {
                throw std::invalid_argument("\n Error in Linkable::Link: null pointer passed.\n");
            }
            auto data = other;
            LinkTreeTo(data);
        }
 
        template <typename... Args,
            std::enable_if_t<
                !(std::conjunction_v<std::is_same<std::decay_t<Args>, Linkable<T>>...>),
                int> = 0>
        void ConstructAndLink(Args &&... args) {
            auto data = std::make_shared<T>(std::forward<Args>(args)...);
            LinkTreeTo(data);
        }
 
        template <typename... Args,
            std::enable_if_t<
                !(std::conjunction_v<std::is_same<std::decay_t<Args>, Linkable<T>>...>),
                int> = 0>
        void ConstructAndRawLink(Args &&... args) {
            auto raw_data = new T(std::forward<Args>(args)...);
            LinkToRaw(raw_data);
        }
 
 
        explicit operator bool() const noexcept {
            return static_cast<bool>(ref_);
        }
 
        T *get_mutable() const {
            return ref_.get();
        };
 
        const T *get() const {
            return ref_.get();
        };
 
        void make_persistent() {
            std::lock_guard<std::mutex> lock(s_registry_mutex);
            black_hole->push_back(ref_);
        }
 
        // operator T() const {
        //     if (!ref_) {
        //         throw std::runtime_error("Attempt to convert empty Linkable to T");
        //     }
        //     return *ref_;  // Return a copy of the contained object
        // }
 
        operator T *() const {
            if (!ref_) {
                throw std::runtime_error("Attempt to convert empty Linkable to T*");
            }
            return ref_.get(); // Return a copy of the contained object
        }
 
    private
    :
        // private methods used to update the links network.
 
        // called on a linkable to recrusive update all back-links to its data.
        void updateTreeRefs(const Linkable<T> &target_ref) {
            for (auto backlink : backlinks_) {
                backlink->ref_ = this->ref_;
                if (backlink == &target_ref) {
                    throw std::logic_error("Fatal error: A loop occurred when linking Linkables.");
                }
                backlink->updateTreeRefs(target_ref);
            }
        }
 
        void LinkTreeTo(Linkable<T> &other) {
            std::lock_guard<std::recursive_mutex> lock(s_link_mutex);
            if (!ref_) {
                // if ref is set, root is already linked to a source
                if (!downlink_) {
                    // we are the root, update links, not just data ref:
                    downlink_ = &other;
                    other.backlinks_.emplace_back(this);
                    if (other.ref_) {
                        other.updateTreeRefs(other);
                    }
                } else {
                    // recurse toward root to apply the link there:
                    downlink_->LinkTreeTo(other);
                }
            } else {
                throw std::logic_error(
                    "Linkable::Link() called on object already linked to data.\n");
            }
        }
 
        void LinkTreeTo(std::shared_ptr<T> &other) {
            std::lock_guard<std::recursive_mutex> lock(s_link_mutex);
            if (!other.get()) {
                throw std::logic_error("Attempting to link a Linkable<T> to null data.\n");
            }
            if (!ref_) {
                if (!downlink_) {
                    // we are the root, update OUR data:
                    ref_ = other;
                    rootlink_ = this;
                    if (rootlink_->ref_) {
                        rootlink_->updateTreeRefs(*rootlink_);
                    }
                } else {
                    // recurse toward root to apply the link there:
                    if (std::find(downlink_->backlinks_.begin(), downlink_->backlinks_.end(), this)
                        == downlink_->backlinks_.end()) {
                        downlink_->backlinks_.emplace_back(this);
                    }
                    downlink_->LinkTreeTo(other);
                }
            } else {
                throw std::logic_error(
                    "Linkable::Link() called on object already linked to data.\n");
            }
        }
    };
 
 
#endif //DEBUG
} // DLG4
 
 
#endif //LINKABLE_HPP