Linkable< T > Class Template Reference

#include <Linkable.hh>

Classes
struct	false_template

Public Member Functions
	Linkable ()
	~Linkable ()
	Linkable (const Linkable< T > &other)
	Linkable (Linkable< T > &other, std::true_type)
	Linkable (const T &other)
template<typename U = T>
std::enable_if_t<!std::is_pointer_v< U >, U * >	operator-> () const
template<typename U = T>
std::enable_if_t< std::is_pointer_v< U >, std::remove_pointer_t< U > * >	operator-> () const
template<typename U = T>
std::enable_if_t<!std::is_pointer_v< U >, U & >	operator* () const
template<typename U = T>
std::enable_if_t< std::is_pointer_v< U >, std::remove_pointer_t< U > & >	operator* () const
const Linkable< T > &	operator= (const Linkable< T > &other) const
Linkable &	operator= (const T &other) const
void	LinkToRaw (T *ptr)
void	Link (Linkable< T > &other)
void	ShareLink (std::shared_ptr< T > other)
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)
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)
	operator bool () const noexcept
T *	get_mutable () const
const T *	get () const
void	make_persistent ()
	operator T* () const

Detailed Description

template<typename T>
class DLG4::VolumeBuilders::_internals_::Linkable< T >

Definition at line 144 of file Linkable.hh.

Constructor & Destructor Documentation

Linkable() [1/4]

template<typename T >

Linkable ( )

inline

Default constructor.

Definition at line 154 of file Linkable.hh.

            : ref_() {
        }

~Linkable()

template<typename T >

~Linkable ( )

inline

Definition at line 159 of file Linkable.hh.

                    {
            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() [2/4]

template<typename T >

Linkable ( const Linkable< T > &  other )

inline

Copy constructor does deep copy, not link This is safest and default.

Definition at line 194 of file Linkable.hh.

                                           :
            ref_(std::make_shared<T>(*other.ref_)) {
        }

Linkable() [3/4]

template<typename T >

Linkable ( Linkable< T > &  other, std::true_type    )

inline

The EXPLICIT linking copy ctor.

Definition at line 199 of file Linkable.hh.

                                                    {
            ref_ = nullptr;
            LinkTreeTo(other);
        }

Linkable() [4/4]

template<typename T >

Linkable ( const T &  other )

inlineexplicit

Copy constructor does deep copy, not link This is safest and default.

Definition at line 206 of file Linkable.hh.

            : ref_(std::make_shared<T>(other)) {
        }

Member Function Documentation

ConstructAndLink()

template<typename T >

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 )

inline

Link and own a T and link to it.

Definition at line 289 of file Linkable.hh.

                                               {
            auto data = std::make_shared<T>(std::forward<Args>(args)...);
            LinkTreeTo(data);
        }

ConstructAndRawLink()

template<typename T >

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 )

inline

Non owning construct and link.

Definition at line 299 of file Linkable.hh.

                                                  {
            auto raw_data = new T(std::forward<Args>(args)...);
            LinkToRaw(raw_data);
        }

get()

template<typename T >

const T * get ( ) const

inline

Definition at line 313 of file Linkable.hh.

                             {
            return ref_.get();
        };

get_mutable()

template<typename T >

T * get_mutable ( ) const

inline

Definition at line 309 of file Linkable.hh.

                               {
            return ref_.get();
        };

Link()

template<typename T >

void Link ( Linkable< T > &  other )

inline

Reset Link to another Linakble:

Definition at line 265 of file Linkable.hh.

                                      {
            LinkTreeTo(other);
        }

LinkToRaw()

template<typename T >

void LinkToRaw ( T *  ptr )

inline

Link to an existing T object via pointer (non-owning)

Definition at line 254 of file Linkable.hh.

                               {
            auto data = std::shared_ptr<T>(ptr, [](T *)
            {
                /* do nothing */
            });
            LinkTreeTo(data);
        }

make_persistent()

template<typename T >

void make_persistent ( )

inline

Definition at line 317 of file Linkable.hh.

                               {
            std::lock_guard<std::mutex> lock(s_registry_mutex);
            black_hole->push_back(ref_);
        }

operator bool()

template<typename T >

operator bool ( ) const

inlineexplicitnoexcept

Definition at line 305 of file Linkable.hh.

                                                {
            return static_cast<bool>(ref_);
        }

operator T*()

template<typename T >

operator T* ( ) const

inline

Definition at line 329 of file Linkable.hh.

                             {
            if (!ref_) {
                throw std::runtime_error("Attempt to convert empty Linkable to T*");
            }
            return ref_.get(); // Return a copy of the contained object
        }

operator*() [1/2]

template<typename T >

template<typename U = T>

std::enable_if_t<!std::is_pointer_v< U >, U & > operator* ( ) const

inline

operator* for non-pointer T: returns reference to T

Definition at line 230 of file Linkable.hh.

                          {
            return *ref_;
        }

operator*() [2/2]

template<typename T >

template<typename U = T>

std::enable_if_t< std::is_pointer_v< U >, std::remove_pointer_t< U > & > operator* ( ) const

inline

operator* for pointer T: returns reference to the pointed-to object

Definition at line 237 of file Linkable.hh.

                          {
            return **ref_;
        }

operator->() [1/2]

template<typename T >

template<typename U = T>

std::enable_if_t<!std::is_pointer_v< U >, U * > operator-> ( ) const

inline

-> foward For non-pointer T

Definition at line 216 of file Linkable.hh.

                           {
            return ref_.get();
        }

operator->() [2/2]

template<typename T >

template<typename U = T>

std::enable_if_t< std::is_pointer_v< U >, std::remove_pointer_t< U > * > operator-> ( ) const

inline

operator-> forward For pointer T

Definition at line 223 of file Linkable.hh.

                           {
            return *ref_;
        }

operator=() [1/2]

template<typename T >

const Linkable< T > & operator= ( const Linkable< T > &  other ) const

inline

Allow CONTENT update (not reference) through assignment This is allowed even for const wrapper.

Definition at line 243 of file Linkable.hh.

                                                                     {
            *ref_ = *(other.ref_);
            return *this; // return const ref to self.
        }

operator=() [2/2]

template<typename T >

Linkable & operator= ( const T &  other ) const

inline

Definition at line 248 of file Linkable.hh.

                                                  {
            *ref_ = other;
            return *this;
        }

ShareLink()

template<typename T >

void ShareLink ( std::shared_ptr< T >  other )

inline

Definition at line 274 of file Linkable.hh.

                                               {
            if (!other) {
                throw std::invalid_argument("\n Error in Linkable::Link: null pointer passed.\n");
            }
            auto data = other;
            LinkTreeTo(data);
        }

---

The documentation for this class was generated from the following file:

• include/Linkable.hh