intrusive-ptr.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <cstdint>
#include <type_traits>
#include <utility>
 
namespace hilti::rt {
 
namespace intrusive_ptr {
 
struct AdoptRef {};
 
struct NewRef {};
 
class ManagedObject {
private:
    template<typename T>
    friend void Ref(const T*);
    template<typename T>
    friend void Unref(const T*);
    mutable uint64_t _references = 1;
};
 
template<typename T>
inline void Ref(const T* m) {
    if ( m )
        ++m->_references;
}
 
template<typename T>
inline void Unref(const T* m) {
    if ( m && --m->_references == 0 )
        delete m;
}
 
} // namespace intrusive_ptr
 
template<class T>
class IntrusivePtr {
public:
    // -- member types
 
    using pointer = T*;
 
    using const_pointer = const T*;
 
    using element_type = T;
 
    using reference = T&;
 
    using const_reference = const T&;
 
    // -- constructors, destructors, and assignment operators
 
    constexpr IntrusivePtr() noexcept = default;
 
    constexpr IntrusivePtr(std::nullptr_t) noexcept : IntrusivePtr() {
        // nop
    }
 
    constexpr IntrusivePtr(intrusive_ptr::AdoptRef, pointer raw_ptr) noexcept : ptr_(raw_ptr) {}
 
    IntrusivePtr(intrusive_ptr::NewRef, pointer raw_ptr) noexcept : ptr_(raw_ptr) {
        if ( ptr_ )
            Ref(ptr_);
    }
 
    IntrusivePtr(IntrusivePtr&& other) noexcept : ptr_(other.release()) {
        // nop
    }
 
    IntrusivePtr(const IntrusivePtr& other) noexcept : IntrusivePtr(intrusive_ptr::NewRef{}, other.get()) {}
 
    template<class U, class = std::enable_if_t<std::is_convertible_v<U*, T*>>>
    IntrusivePtr(IntrusivePtr<U> other) noexcept : ptr_(other.release()) {
        // nop
    }
 
    ~IntrusivePtr() {
        if ( ptr_ )
            Unref(ptr_);
    }
 
    void swap(IntrusivePtr& other) noexcept { std::swap(ptr_, other.ptr_); }
 
    friend void swap(IntrusivePtr& a, IntrusivePtr& b) noexcept {
        using std::swap;
        swap(a.ptr_, b.ptr_);
    }
 
    pointer release() noexcept { return std::exchange(ptr_, nullptr); }
 
    IntrusivePtr& operator=(IntrusivePtr other) noexcept {
        swap(other);
        return *this;
    }
 
    pointer get() const noexcept {
        // Some versions of GCC diagnose a maybe uninitialized variable here.
        // Since we always initialize the field this should not be possible.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wunknown-warning-option"
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
        return ptr_;
#pragma GCC diagnostic pop
    }
 
    pointer operator->() const noexcept { return ptr_; }
 
    reference operator*() const noexcept { return *ptr_; }
 
    bool operator!() const noexcept { return ! ptr_; }
 
    explicit operator bool() const noexcept { return ptr_ != nullptr; }
 
private:
    pointer ptr_ = nullptr;
};
 
template<class T, class... Ts>
IntrusivePtr<T> make_intrusive(Ts&&... args) {
    // Assumes that objects start with a reference count of 1!
    return {intrusive_ptr::AdoptRef{}, new T(std::forward<Ts>(args)...)};
}
 
template<class T, class U>
IntrusivePtr<T> cast_intrusive(IntrusivePtr<U> p) noexcept {
    return {intrusive_ptr::AdoptRef{}, static_cast<T*>(p.release())};
}
 
// -- comparison to nullptr ----------------------------------------------------
 
template<class T>
bool operator==(const IntrusivePtr<T>& x, std::nullptr_t) {
    return ! x;
}
 
template<class T>
bool operator==(std::nullptr_t, const IntrusivePtr<T>& x) {
    return ! x;
}
 
template<class T>
bool operator!=(const IntrusivePtr<T>& x, std::nullptr_t) {
    return static_cast<bool>(x);
}
 
template<class T>
bool operator!=(std::nullptr_t, const IntrusivePtr<T>& x) {
    return static_cast<bool>(x);
}
 
// -- comparison to raw pointer ------------------------------------------------
 
template<class T>
bool operator==(const IntrusivePtr<T>& x, const T* y) {
    return x.get() == y;
}
 
template<class T>
bool operator==(const T* x, const IntrusivePtr<T>& y) {
    return x == y.get();
}
 
template<class T>
bool operator!=(const IntrusivePtr<T>& x, const T* y) {
    return x.get() != y;
}
 
template<class T>
bool operator!=(const T* x, const IntrusivePtr<T>& y) {
    return x != y.get();
}
 
// -- comparison to intrusive pointer ------------------------------------------
 
// Using trailing return type and decltype() here removes this function from
// overload resolution if the two pointers types are not comparable (SFINAE).
 
template<class T, class U>
auto operator==(const IntrusivePtr<T>& x, const IntrusivePtr<U>& y) -> decltype(x.get() == y.get()) {
    return x.get() == y.get();
}
 
template<class T, class U>
auto operator!=(const IntrusivePtr<T>& x, const IntrusivePtr<U>& y) -> decltype(x.get() != y.get()) {
    return x.get() != y.get();
}
 
} // namespace hilti::rt