LinkedObject.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_LINKEDOBJECT_HXX_
#define _UTILS_LINKEDOBJECT_HXX_
 
#include <atomic>
 
#include "utils/Atomic.hxx"
#include "utils/Uninitialized.hxx"
 
class CreateOnlyAtomic
{
public:
    CreateOnlyAtomic()
    {
        // Ensures the object gets created at static initialization time while
        // the program is still single threaded.
        get();
    }
 
    Atomic *get()
    {
        if (isInitialized_.exchange(1) == 0)
        {
            atomic_.emplace();
        }
        return &atomic_.value();
    }
 
private:
    std::atomic_uint_least8_t isInitialized_;
    uninitialized<Atomic> atomic_;
};
 
template <class T> class LinkedObjectHeadMutex
{
public:
    static CreateOnlyAtomic headMu_;
};
 
template <class T> class LinkedObject
{
public:
    T *link_next()
    {
        return static_cast<T *>(link_);
    }
 
    static T *link_head()
    {
        return static_cast<T *>(head_);
    }
 
    static Atomic* head_mu() {
        return LinkedObjectHeadMutex<T>::headMu_.get();
    }
 
protected:
    T *link_this()
    {
        return static_cast<T *>(this);
    }
 
    LinkedObject()
    {
        AtomicHolder h(head_mu());
        link_ = head_;
        head_ = link_this();
    }
 
    ~LinkedObject()
    {
        AtomicHolder h(head_mu());
        T **p = &head_;
        while (*p && *p != this)
        {
            p = &((*p)->LinkedObject<T>::link_);
        }
        if (*p == this)
        {
            *p = this->link_;
        }
        else
        {
            HASSERT(0);
        }
    }
 
    T *link_;
    static T *head_;
};
 
// static
template <class T> T *LinkedObject<T>::head_{nullptr};
template <class T> CreateOnlyAtomic LinkedObjectHeadMutex<T>::headMu_;
 
#endif // _UTILS_LINKEDOBJECT_HXX_