utility.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <detail/preprocessor.hpp>
#include <memory/from_allocator.hpp>
 
#include <algorithm>
#include <atomic>
#include <compare>
#include <concepts>
#include <stdexcept>
#include <utility>
 
namespace from {
// Dantelion2 utility
namespace DLUT {
class DLNonCopyable {
public:
    DLNonCopyable() = default;
    LIBERAPI virtual ~DLNonCopyable();
 
    DLNonCopyable(const DLNonCopyable&) = delete;
    DLNonCopyable& operator=(const DLNonCopyable&) = delete;
};
 
class DLReferenceCountObject {
public:
    LIBER_CLASS(DLReferenceCountObject);
 
    virtual void deleter() {
        this->~DLReferenceCountObject();
        get_allocator_of(this).deallocate(this);
    }
 
    virtual ~DLReferenceCountObject() = default;
 
    int count() const noexcept {
        return this->counter.load(std::memory_order_relaxed);
    }
 
    void ref() noexcept {
        ++this->counter;
    }
 
    void unref() {
        int value = this->counter.fetch_add(-1, std::memory_order_seq_cst);
        if (value == 1)
            this->deleter();
        else if (value < 1)
            throw std::runtime_error("bad unref() call");
    }
 
protected:
    DLReferenceCountObject() noexcept = default;
 
private:
    template <typename T, typename... Args>
        requires std::derived_from<T, DLReferenceCountObject>
    friend inline auto make_refcounted();
 
    std::atomic_int counter = 0;
};
 
// A refcounted pointer that models std::shared_ptr
// Use from::make_refcounted<T>(...) to create refcounted objects
// These objects must derive from DLReferenceCountObject
template <typename T>
    requires std::derived_from<T, DLReferenceCountObject>
class DLReferenceCountPtr {
public:
    LIBER_CLASS(DLReferenceCountPtr);
 
    DLReferenceCountPtr() noexcept : raw(nullptr) {}
 
    DLReferenceCountPtr(std::nullptr_t) noexcept : raw(nullptr) {}
 
    template <class U>
        requires std::convertible_to<U*, T*>
    explicit DLReferenceCountPtr(U* raw) noexcept : raw(raw) {
        if (this->get())
            this->counter().ref();
    }
 
    DLReferenceCountPtr(const DLReferenceCountPtr& other) noexcept
        : DLReferenceCountPtr(other.get()) {}
 
    template <class U>
        requires std::convertible_to<U*, T*>
    DLReferenceCountPtr(const DLReferenceCountPtr<U>& other) noexcept
        : DLReferenceCountPtr(other.get()) {}
 
    DLReferenceCountPtr(DLReferenceCountPtr&& other) noexcept {
        this->raw = std::exchange(other.raw, nullptr);
    }
 
    template <class U>
        requires std::convertible_to<U*, T*>
    DLReferenceCountPtr(DLReferenceCountPtr<U>&& other) noexcept {
        this->raw = std::exchange(other.raw, nullptr);
    }
 
    ~DLReferenceCountPtr() {
        if (this->get())
            this->counter().unref();
    }
 
    template <class U>
        requires std::convertible_to<U*, T*>
    DLReferenceCountPtr& operator=(const DLReferenceCountPtr<U>& other) {
        if (this->get())
            this->counter().unref();
        this->raw = other->get();
        if (this->get())
            this->counter().ref();
        return *this;
    }
 
    template <class U>
        requires std::convertible_to<U*, T*>
    DLReferenceCountPtr& operator=(DLReferenceCountPtr<U>&& other) {
        if (this->get())
            this->counter().unref();
        this->raw = std::exchange(other.raw, nullptr);
        return *this;
    }
 
    void reset() {
        if (this->raw)
            this->counter().unref();
        this->raw = nullptr;
    }
 
    template <class U>
        requires std::convertible_to<U*, T*>
    void reset(U* raw) {
        if (this->raw)
            this->counter().unref();
        this->raw = raw;
        if (raw)
            this->counter().ref();
    }
 
    void swap(DLReferenceCountPtr& other) {
        std::swap(this->raw, other.raw);
    }
 
    T* get() const noexcept {
        return this->raw;
    }
 
    T& operator*() const noexcept {
        return *this->get();
    }
 
    T* operator->() const noexcept {
        return this->get();
    }
 
    explicit operator bool() const noexcept {
        return this->get();
    }
 
private:
    DLReferenceCountObject& counter() noexcept {
        return static_cast<DLReferenceCountObject&>(*this->raw);
    }
 
    T* raw;
};
 
template <typename T, typename U>
inline bool operator==(const DLReferenceCountPtr<T>& lhs,
    const DLReferenceCountPtr<U>& rhs) {
    return lhs.get() == rhs.get();
}
 
template <typename T, typename U>
inline std::strong_ordering operator<=>(const DLReferenceCountPtr<T>& lhs,
    const DLReferenceCountPtr<U>& rhs) {
    return lhs.get() <=> rhs.get();
}
 
template <typename T, typename U>
inline bool operator==(const DLReferenceCountPtr<U>& lhs, std::nullptr_t) {
    return lhs.get() == nullptr;
}
 
template <typename T, typename U>
inline std::strong_ordering operator<=>(const DLReferenceCountPtr<T>& lhs,
    std::nullptr_t) {
    return lhs.get() <=> nullptr;
}
 
LIBER_ASSERTS_BEGIN(DLReferenceCountObject);
LIBER_ASSERT_SIZE(0x10);
LIBER_ASSERTS_END;
 
struct dummy_rfco : DLReferenceCountObject {};
LIBER_ASSERTS_TEMPLATE_BEGIN(DLReferenceCountPtr, dummy_rfco);
LIBER_ASSERT_SIZE(0x8);
LIBER_ASSERTS_END;
} // namespace DLUT
 
template <typename T, typename... Args>
    requires std::derived_from<T, DLUT::DLReferenceCountObject>
[[nodiscard]] inline auto make_refcounted(Args&&... args) {
    from::allocator<T> allocator;
    using altraits = std::allocator_traits<decltype(allocator)>;
    T* p = altraits::allocate(allocator, 1);
    if (!p)
        return DLUT::DLReferenceCountPtr<T>(nullptr);
    altraits::construct(allocator, p, std::forward<Args>(args)...);
    return DLUT::DLReferenceCountPtr<T>(p);
}
} // namespace from