Ptr.h

Go to the documentation of this file.

//-
// =============================================================================
// Copyright 2025 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// =============================================================================
//+
 
 
#ifndef AMINO_PTR_H
#define AMINO_PTR_H
 
#include "PtrFwd.h"
 
//==============================================================================
// EXTERNAL DECLARATIONS
//==============================================================================
 
#include "internal/PtrRep.h"
 
#include <functional>
#include <type_traits>
 
namespace Amino {
 
//==============================================================================
// Forward declarations
//==============================================================================
 
namespace Internal {
struct PtrCast;
} // namespace Internal
 
//==============================================================================
// Traits
//==============================================================================
 
struct PointeeTraits {
    template <typename T>
    struct is_compliant_base
        : public std::integral_constant<
              bool,
              // The pointee must not be a pointer itself.
              (!std::is_pointer<T>::value &&
 
               // The pointee must not be a reference.
               !std::is_reference<T>::value &&
 
               // The type must not include "const" qualifiers.
               // By definition, Ptr<T> points to a const T.
               // By definition, MutablePtr<T> points to a non-const T.
               !std::is_const<T>::value &&
 
               // The type must not include "volatile" qualifiers.
               !std::is_volatile<T>::value &&
 
               // The type must not be an array (e.g. int[]).
               !std::is_array<T>::value)> {};
 
    template <typename T>
    struct is_compliant
        : public std::integral_constant<
              bool,
              (is_compliant_base<T>::value &&
 
               // Must be copy constructible to allow cloning the pointee.
               PointeeManager::is_copy_constructible<T>::value)> {};
 
    template <typename T>
    using is_defaultable = PtrInternal::DefaultPtrTraits::is_defaultable<T>;
};
 
//==============================================================================
// CLASS PtrDefaultFlag
//==============================================================================
 
struct PtrDefaultFlag {};
 
//==============================================================================
// CLASS Ptr
//==============================================================================
 
 
template <class T>
class Ptr : private PtrInternal::PtrRep<T> {
private:
    // NOLINTNEXTLINE(modernize-unary-static-assert)
    static_assert(PointeeTraits::is_compliant_base<T>::value, "");
 
    /*----- types -----*/
    using PtrRep = PtrInternal::PtrRep<T>;
 
    template <class Y>
    using if_convertible_from =
        typename std::enable_if<std::is_convertible<Y*, T*>::value>::type;
 
    template <class Y>
    using if_compliant_and_convertible_from = typename std::enable_if<
        std::is_convertible<Y*, T*>::value &&
        PointeeTraits::is_compliant<Y>::value>::type;
 
public:
    /*----- types -----*/
 
    using element_type = T;
 
    using element_const_reference_type =
        typename std::add_lvalue_reference<const element_type>::type;
 
    using use_count_type = std::intptr_t;
 
    /*----- member functions -----*/
 
 
    constexpr Ptr() noexcept;
    // NOLINTNEXTLINE(google-explicit-constructor)
    constexpr Ptr(std::nullptr_t) noexcept;
 
    explicit Ptr(PtrDefaultFlag);
 
 
    template <class Y, class = if_compliant_and_convertible_from<Y>>
    explicit Ptr(Y* p);
 
    template <class Y, class D, class = if_compliant_and_convertible_from<Y>>
    Ptr(Y* p, D d);
 
 
    template <class D>
    Ptr(std::nullptr_t, D d);
 
 
    Ptr(Ptr const& rhs) noexcept;
 
    template <class Y, class = if_convertible_from<Y>>
    // NOLINTNEXTLINE(google-explicit-constructor)
    Ptr(Ptr<Y> const& rhs) noexcept;
 
 
    Ptr(Ptr&& rhs) noexcept;
 
    template <class Y, class = if_convertible_from<Y>>
    // NOLINTNEXTLINE(google-explicit-constructor)
    Ptr(Ptr<Y>&& rhs) noexcept;
 
    template <class Y, class = if_convertible_from<Y>>
    // NOLINTNEXTLINE(google-explicit-constructor)
    Ptr(MutablePtr<Y> rhs) noexcept;
 
 
    ~Ptr();
 
 
    Ptr& operator=(Ptr const& rhs) noexcept;
 
    template <class Y, class = if_convertible_from<Y>>
    Ptr& operator=(Ptr<Y> const& rhs) noexcept;
 
 
    Ptr& operator=(Ptr&& rhs) noexcept;
 
    template <class Y, class = if_convertible_from<Y>>
    Ptr& operator=(Ptr<Y>&& rhs) noexcept;
 
    template <class Y, class = if_convertible_from<Y>>
    Ptr& operator=(MutablePtr<Y> rhs) noexcept;
 
 
    void swap(Ptr& rhs) noexcept;
 
    void reset() noexcept;
 
    template <class Y, class = if_compliant_and_convertible_from<Y>>
    void reset(Y* p);
 
    template <class Y, class D, class = if_compliant_and_convertible_from<Y>>
    void reset(Y* p, D d);
 
    MutablePtr<element_type> toMutable() noexcept;
 
    template <typename Func>
    void mutate(Func&& func);
 
 
    element_const_reference_type operator*() const noexcept;
 
    element_type const* operator->() const noexcept;
 
    element_type const* get() const noexcept;
 
    bool unique() const noexcept;
 
    use_count_type use_count() const noexcept;
 
    explicit operator bool() const noexcept;
 
    template <class Y>
    bool owner_before(Ptr<Y> const& rhs) const noexcept;
 
protected:
    /*----- member functions -----*/
 
 
    Ptr(T* p, PtrInternal::PtrCntrlBlk* cntrlBlk, bool doIncUseCount);
 
    using PtrRep::getPointee;
 
private:
    template <class Y>
    friend class Ptr;
 
    template <class Y>
    friend class PtrGuard;
 
    friend struct Internal::PtrCast;
};
 
template <typename T>
Ptr(MutablePtr<T>) -> Ptr<T>;
 
//==============================================================================
// CLASS MutablePtr
//==============================================================================
 
template <typename T>
class MutablePtr : private Ptr<T> {
private:
    // NOLINTNEXTLINE(modernize-unary-static-assert)
    static_assert(PointeeTraits::is_compliant_base<T>::value, "");
 
    /*----- types -----*/
 
    using Base = Ptr<T>;
 
    template <class Y>
    using if_convertible_from =
        typename std::enable_if<std::is_convertible<Y*, T*>::value>::type;
 
public:
    /*----- types -----*/
 
    using element_type = typename Base::element_type;
 
    /*----- member functions -----*/
 
 
    constexpr MutablePtr() noexcept = default;
    // NOLINTNEXTLINE(google-explicit-constructor)
    constexpr MutablePtr(std::nullptr_t) noexcept;
 
    // NOLINTNEXTLINE(google-explicit-constructor)
    MutablePtr(T* p);
 
    MutablePtr(MutablePtr&&) noexcept = default;
 
    MutablePtr(MutablePtr const&) noexcept = delete;
 
    template <class Y, class = if_convertible_from<Y>>
    // NOLINTNEXTLINE(google-explicit-constructor)
    MutablePtr(MutablePtr<Y> rhs) noexcept;
 
    ~MutablePtr();
 
    MutablePtr& operator=(MutablePtr&&) noexcept = default;
 
    MutablePtr& operator=(MutablePtr const&) noexcept = delete;
 
    template <class Y, class = if_convertible_from<Y>>
    MutablePtr& operator=(MutablePtr<Y> rhs) noexcept;
 
    // clang-format off
    T const& operator*() const noexcept { assert(get()); return *get(); }
    T&       operator*() noexcept { assert(get()); return *get(); }
 
    T const* operator->() const noexcept { assert(get()); return get(); }
    T*       operator->() noexcept { assert(get()); return get(); }
    // clang-format on
 
    T const* get() const noexcept { return Base::get(); }
    T*       get() noexcept { return Base::getPointee(); }
 
    explicit operator bool() const { return Base::operator bool(); }
 
    void reset() { Base::reset(); }
 
    void swap(MutablePtr& rhs) noexcept;
 
    Ptr<T> toImmutable() noexcept;
 
private:
    MutablePtr(T* p, PtrInternal::PtrCntrlBlk* cntrlBlk)
        : Base(p, cntrlBlk, /*doIncUseCount=*/false) {
        assert(Base::unique());
    }
 
#ifndef NDEBUG
    bool unique_or_null() const { return !*this || Base::unique(); }
#endif
 
    template <typename Y>
    friend class Ptr;
 
    template <typename Y>
    friend class MutablePtr;
 
    template <typename Y>
    friend class PtrGuard;
};
 
//==============================================================================
// CLASS PtrGuardUniqueFlag
//==============================================================================
 
struct PtrGuardUniqueFlag {};
 
//==============================================================================
// CLASS PtrGuard
//==============================================================================
 
template <typename T>
class PtrGuard {
private:
    /*----- types -----*/
 
    template <typename Y>
    using if_convertible_from =
        typename std::enable_if<std::is_convertible<Y*, T*>::value>::type;
 
public:
    explicit PtrGuard(Ptr<T>& src);
    explicit PtrGuard(Ptr<T>& src, PtrGuardUniqueFlag);
 
    template <class Y, class = if_convertible_from<Y>>
    explicit PtrGuard(Ptr<Y>& src);
 
    PtrGuard(PtrGuard&&) noexcept = default;
 
    PtrGuard(PtrGuard const&) noexcept = delete;
 
    PtrGuard& operator=(PtrGuard&&) noexcept = delete;
 
    PtrGuard& operator=(PtrGuard const&) noexcept = delete;
 
    ~PtrGuard();
 
    T& operator*() { return *m_ptr; }
 
    T* operator->() { return m_ptr.operator->(); }
 
    const T& operator*() const { return *m_ptr; }
 
    const T* operator->() const { return m_ptr.operator->(); }
 
private:
    Ptr<T>* m_src = nullptr;
 
    MutablePtr<T> m_ptr;
};
 
template <typename T>
PtrGuard(Ptr<T>&) -> PtrGuard<T>;
template <typename T>
PtrGuard(Ptr<T>&, PtrGuardUniqueFlag) -> PtrGuard<T>;
 
//==============================================================================
// CLASS Ptr
//==============================================================================
 
//------------------------------------------------------------------------------
//
template <class T>
inline constexpr Ptr<T>::Ptr() noexcept : PtrRep(nullptr) {}
 
//------------------------------------------------------------------------------
//
template <class T>
inline constexpr Ptr<T>::Ptr(std::nullptr_t) noexcept : PtrRep(nullptr) {}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class Y, class>
inline Ptr<T>::Ptr(Y* p) : PtrRep(PtrInternal::kUninitialized) {
    // The control block must dispose of the pointer using its
    // original type, i.e Y, not T!!!
    using NonConstY = typename std::remove_cv<Y>::type;
    auto nonConstP  = const_cast<NonConstY*>(p);
    this->template init_dispatch<NonConstY>(nonConstP);
 
    // FIXME: In theory, we have to delete "p" if the previous allocation fails.
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class Y, class D, class>
inline Ptr<T>::Ptr(Y* p, D d) : PtrRep(PtrInternal::kUninitialized) {
    // The control block must dispose of the pointer using its
    // original type, i.e Y, not T!!!
    this->init(p, new PtrInternal::PtrCntrlBlkPtrDel<Y, D>(p, d));
 
    // FIXME: In theory, we have to delete "p" if the previous allocation fails.
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class D>
inline Ptr<T>::Ptr(std::nullptr_t, D d) : PtrRep(PtrInternal::kUninitialized) {
    this->init(nullptr, new PtrInternal::PtrCntrlBlkPtrDel<T, D>(nullptr, d));
 
    // FIXME: In theory, we have to delete "p" if the previous allocation fails.
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline Ptr<T>::Ptr(T* p, PtrInternal::PtrCntrlBlk* cntrlBlk, bool doIncUseCount)
    : PtrRep(p, cntrlBlk) {
    if (doIncUseCount) this->incUseCount();
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline Ptr<T>::Ptr(Ptr const& rhs) noexcept
    : PtrRep(rhs.getPointee(), rhs.getCntrlBlk()) {
    this->incUseCount();
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class Y, class>
inline Ptr<T>::Ptr(Ptr<Y> const& rhs) noexcept
    : PtrRep(rhs.getPointee(), rhs.getCntrlBlk()) {
    this->incUseCount();
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline Ptr<T>::Ptr(Ptr&& rhs) noexcept
    : PtrRep(rhs.getPointee(), rhs.getCntrlBlk()) {
    rhs.init(nullptr, nullptr);
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class Y, class>
inline Ptr<T>::Ptr(Ptr<Y>&& rhs) noexcept
    : PtrRep(rhs.getPointee(), rhs.getCntrlBlk()) {
    rhs.init(nullptr, nullptr);
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class Y, class>
inline Ptr<T>::Ptr(MutablePtr<Y> rhs) noexcept
    : PtrRep(rhs.getPointee(), rhs.getCntrlBlk()) {
    rhs.init(nullptr, nullptr);
    assert(!rhs.getPointee() || unique());
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline Ptr<T>::~Ptr() = default;
 
//------------------------------------------------------------------------------
//
template <class T>
inline Ptr<T>& Ptr<T>::operator=(Ptr const& rhs) noexcept {
    this->PtrRep::operator=(rhs);
    return *this;
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class Y, class>
inline Ptr<T>& Ptr<T>::operator=(Ptr<Y> const& rhs) noexcept {
    this->PtrRep::operator=(Ptr(rhs));
    return *this;
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline Ptr<T>& Ptr<T>::operator=(Ptr&& rhs) noexcept {
    this->PtrRep::operator=(std::move(rhs));
    return *this;
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class Y, class>
inline Ptr<T>& Ptr<T>::operator=(Ptr<Y>&& rhs) noexcept {
    this->PtrRep::operator=(Ptr(std::move(rhs)));
    return *this;
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class Y, class>
inline Ptr<T>& Ptr<T>::operator=(MutablePtr<Y> rhs) noexcept {
    this->PtrRep::operator=(Ptr<T>(std::move(rhs)));
    return *this;
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline void Ptr<T>::swap(Ptr& rhs) noexcept {
    PtrRep::swap(rhs);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline void Ptr<T>::reset() noexcept {
    this->operator=(Ptr());
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class Y, class>
inline void Ptr<T>::reset(Y* p) {
    this->operator=(Ptr(p));
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class Y, class D, class>
inline void Ptr<T>::reset(Y* p, D d) {
    this->operator=(Ptr(p, d));
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline MutablePtr<typename Ptr<T>::element_type> Ptr<T>::toMutable() noexcept {
    auto p = const_cast<element_type*>(this->getPointee());
    if (!p) {
        return MutablePtr<element_type>();
    } else {
        // Move the pointer...
        auto cntrl = this->getCntrlBlk();
        if (unique()) {
            // Simply move-const-cast the pointer...
            this->init(nullptr, nullptr);
            return MutablePtr<element_type>(p, cntrl);
        } else {
            // Non-unique owner, take a copy using the clone operation captured
            // at type erasure time!
            auto cloned = cntrl->clonePointee(p);
            reset();
            return MutablePtr<element_type>(
                static_cast<element_type*>(cloned.m_pointee),
                cloned.getCntrlBlk());
        }
    }
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <typename Func>
void Ptr<T>::mutate(Func&& func) {
    assert(unique());
 
    Ptr<T> o = std::move(*this);
 
    auto ptee =
        o.unique() ? const_cast<element_type*>(o.getPointee()) : nullptr;
    assert(ptee);
    func(ptee);
 
    *this = std::move(o);
    assert(unique());
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline typename Ptr<T>::element_const_reference_type Ptr<T>::operator*()
    const noexcept {
    assert(this->getPointee());
    return *this->getPointee();
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline typename Ptr<T>::element_type const* Ptr<T>::operator->()
    const noexcept {
    assert(this->getPointee());
    return this->getPointee();
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline typename Ptr<T>::element_type const* Ptr<T>::get() const noexcept {
    return this->getPointee();
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline typename Ptr<T>::use_count_type Ptr<T>::use_count() const noexcept {
    auto cblk = this->getCntrlBlk();
    return cblk ? cblk->use_count() : 0;
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool Ptr<T>::unique() const noexcept {
    return use_count() == 1;
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline Ptr<T>::operator bool() const noexcept {
    return this->getPointee() != nullptr;
}
 
//------------------------------------------------------------------------------
//
template <class T>
template <class Y>
inline bool Ptr<T>::owner_before(Ptr<Y> const& rhs) const noexcept {
    return (this->getCntrlBlk() < rhs.getCntrlBlk());
}
 
//==============================================================================
// CLASS MutablePtr
//==============================================================================
 
//------------------------------------------------------------------------------
//
template <typename T>
inline constexpr MutablePtr<T>::MutablePtr(std::nullptr_t) noexcept
    : Base(nullptr) {}
 
//------------------------------------------------------------------------------
//
template <typename T>
inline MutablePtr<T>::MutablePtr(T* p) : Base(p) {
    assert(unique_or_null());
}
 
//------------------------------------------------------------------------------
//
template <typename T>
template <class Y, class>
inline MutablePtr<T>::MutablePtr(MutablePtr<Y> rhs) noexcept
    : Base(std::move(rhs)) {
    assert(unique_or_null());
}
 
//------------------------------------------------------------------------------
//
template <typename T>
inline MutablePtr<T>::~MutablePtr() {
    assert(unique_or_null());
}
 
//------------------------------------------------------------------------------
//
template <typename T>
template <class Y, class>
inline MutablePtr<T>& MutablePtr<T>::operator=(MutablePtr<Y> rhs) noexcept {
    Base::operator=(std::move(rhs));
    assert(unique_or_null());
    return *this;
}
 
//------------------------------------------------------------------------------
//
template <typename T>
void MutablePtr<T>::swap(MutablePtr& rhs) noexcept {
    Base::swap(rhs);
}
 
//------------------------------------------------------------------------------
//
template <typename T>
Amino::Ptr<T> MutablePtr<T>::toImmutable() noexcept {
    Amino::Ptr<T> o;
    o.swap(*this);
    return o;
}
 
//==============================================================================
// CLASS PtrGuard
//==============================================================================
 
template <typename T>
inline PtrGuard<T>::PtrGuard(Ptr<T>& src)
    : m_src(&src), m_ptr(src.toMutable()) {
    assert(!*m_src);
}
template <typename T>
inline PtrGuard<T>::PtrGuard(Ptr<T>& src, PtrGuardUniqueFlag)
    : m_src(&src), m_ptr(src.getPointee(), src.getCntrlBlk()) {
    m_src->init(nullptr, nullptr);
    assert(!*m_src);
    assert(m_ptr.unique_or_null());
}
template <typename T>
template <class Y, class>
inline PtrGuard<T>::PtrGuard(Ptr<Y>& src)
    : m_src(&reinterpret_cast<Ptr<T>&>(src)), m_ptr(src.toMutable()) {
    assert(!*m_src);
}
template <typename T>
inline PtrGuard<T>::~PtrGuard() {
    if (!m_ptr) return;
    assert(!*m_src);
    *m_src = m_ptr.toImmutable();
}
 
//==============================================================================
// GLOBAL FUNCTIONS CLASS Amino::Ptr
//==============================================================================
 
 
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator==(Ptr<T> const& x, Ptr<U> const& y) noexcept {
    return x.get() == y.get();
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator==(const Ptr<T>& x, std::nullptr_t) noexcept {
    return !x;
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator==(std::nullptr_t, const Ptr<T>& y) noexcept {
    return !y;
}
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator!=(Ptr<T> const& x, Ptr<U> const& y) noexcept {
    return !(x == y);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator!=(const Ptr<T>& x, std::nullptr_t) noexcept {
    return static_cast<bool>(x);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator!=(std::nullptr_t, const Ptr<T>& y) noexcept {
    return static_cast<bool>(y);
}
 
 
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator<(Ptr<T> const& x, Ptr<U> const& y) noexcept {
    using VP = typename std::common_type<T*, U*>::type;
    using V  = typename std::remove_pointer<VP>::type;
 
    return std::less<V const*>()(x.get(), y.get());
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator<(const Ptr<T>& x, std::nullptr_t) noexcept {
    return std::less<T const*>()(x.get(), nullptr);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator<(std::nullptr_t, const Ptr<T>& y) noexcept {
    return std::less<T const*>()(nullptr, y.get());
}
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator>(Ptr<T> const& x, Ptr<U> const& y) noexcept {
    return (y < x);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator>(const Ptr<T>& x, std::nullptr_t) noexcept {
    return (nullptr < x);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator>(std::nullptr_t, const Ptr<T>& y) noexcept {
    return (y < nullptr);
}
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator<=(Ptr<T> const& x, Ptr<U> const& y) noexcept {
    return !(y < x);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator<=(const Ptr<T>& x, std::nullptr_t) noexcept {
    return !(nullptr < x);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator<=(std::nullptr_t, const Ptr<T>& y) noexcept {
    return !(y < nullptr);
}
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator>=(Ptr<T> const& x, Ptr<U> const& y) noexcept {
    return !(x < y);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator>=(const Ptr<T>& x, std::nullptr_t) noexcept {
    return !(x < nullptr);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator>=(std::nullptr_t, const Ptr<T>& y) noexcept {
    return !(nullptr < y);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline void swap(Ptr<T>& lhs, Ptr<T>& rhs) noexcept {
    lhs.swap(rhs);
}
 
//==============================================================================
// GLOBAL FUNCTIONS CLASS Amino::MutablePtr
//==============================================================================
 
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator==(
    MutablePtr<T> const& x, MutablePtr<U> const& y) noexcept {
    assert(x.get() != y.get() || &x == &y);
    return x.get() == y.get();
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator==(const MutablePtr<T>& x, std::nullptr_t) noexcept {
    return !x;
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator==(std::nullptr_t, const MutablePtr<T>& y) noexcept {
    return !y;
}
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator!=(
    MutablePtr<T> const& x, MutablePtr<U> const& y) noexcept {
    return !(x == y);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator!=(const MutablePtr<T>& x, std::nullptr_t) noexcept {
    return static_cast<bool>(x);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator!=(std::nullptr_t, const MutablePtr<T>& y) noexcept {
    return static_cast<bool>(y);
}
 
 
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator<(MutablePtr<T> const& x, MutablePtr<U> const& y) noexcept {
    using VP = typename std::common_type<T*, U*>::type;
    using V  = typename std::remove_pointer<VP>::type;
 
    return std::less<V const*>()(x.get(), y.get());
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator<(const MutablePtr<T>& x, std::nullptr_t) noexcept {
    return std::less<T const*>()(x.get(), nullptr);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator<(std::nullptr_t, const MutablePtr<T>& y) noexcept {
    return std::less<T const*>()(nullptr, y.get());
}
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator>(MutablePtr<T> const& x, MutablePtr<U> const& y) noexcept {
    return (y < x);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator>(const MutablePtr<T>& x, std::nullptr_t) noexcept {
    return (nullptr < x);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator>(std::nullptr_t, const MutablePtr<T>& y) noexcept {
    return (y < nullptr);
}
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator<=(
    MutablePtr<T> const& x, MutablePtr<U> const& y) noexcept {
    return !(y < x);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator<=(const MutablePtr<T>& x, std::nullptr_t) noexcept {
    return !(nullptr < x);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator<=(std::nullptr_t, const MutablePtr<T>& y) noexcept {
    return !(y < nullptr);
}
 
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline bool operator>=(
    MutablePtr<T> const& x, MutablePtr<U> const& y) noexcept {
    return !(x < y);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator>=(const MutablePtr<T>& x, std::nullptr_t) noexcept {
    return !(x < nullptr);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline bool operator>=(std::nullptr_t, const MutablePtr<T>& y) noexcept {
    return !(nullptr < y);
}
 
//------------------------------------------------------------------------------
//
template <class T>
inline void swap(MutablePtr<T>& lhs, MutablePtr<T>& rhs) noexcept {
    lhs.swap(rhs);
}
 
 
//==============================================================================
// GLOBAL CASTING FUNCTIONS
//==============================================================================
 
template <class T, class U>
inline Ptr<T> static_pointer_cast(Ptr<U> const& ptr) noexcept;
template <class T, class U>
inline Ptr<T> static_pointer_cast(Ptr<U>&& ptr) noexcept;
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline Ptr<T> dynamic_pointer_cast(Ptr<U> const& ptr) noexcept;
template <class T, class U>
inline Ptr<T> dynamic_pointer_cast(Ptr<U>&& ptr) noexcept;
 
//==============================================================================
// FUNCTION makeDefaultPtr
//==============================================================================
 
template <typename T>
std::enable_if_t<
    PtrInternal::DefaultPtrTraits::has_default_class<T>::value,
    Ptr<T>>
makeDefaultPtr() {
    return Internal::getDefaultClass<T>();
}
template <typename T>
std::enable_if_t<PtrInternal::DefaultPtrTraits::is_array<T>::value, Ptr<T>>
makeDefaultPtr() {
    return Ptr<T>(PointeeManager::newClass<T>());
}
template <typename T>
std::enable_if_t<
    !PtrInternal::DefaultPtrTraits::is_defaultable<T>::value,
    Ptr<T>>
makeDefaultPtr() {
    // This static_assert will always fail when makeDefaultPtr resolves to this
    // overload, indicating what needs to be done to fix the compile error.
    static_assert(
        PtrInternal::DefaultPtrTraits::has_default_class<T>::value,
        "Missing default class getter for class T. See "
        "AMINO_DECLARE_DEFAULT_CLASS in <Amino/Cpp/ClassDeclare.h> and "
        "AMINO_DEFINE_DEFAULT_CLASS in <Amino/Cpp/ClassDefine.h>");
    return nullptr;
}
 
//------------------------------------------------------------------------------
// This ctor has to be defined after makeDefaultPtr() since it uses it.
template <class T>
inline Ptr<T>::Ptr(PtrDefaultFlag) : Ptr(makeDefaultPtr<T>()) {}
 
//==============================================================================
// FUNCTION newClassPtr
//==============================================================================
 
template <class T, class... Args>
inline Ptr<T> newClassPtr(Args&&... args) {
    static_assert(
        PointeeTraits::is_compliant<T>::value,
        "The class of type T cannot be stored in an Amino::Ptr<T>");
    return Ptr<T>(PointeeManager::newClass<T>(std::forward<Args>(args)...));
}
 
template <class T, class E>
inline Ptr<T> newClassPtr(std::initializer_list<E> list) {
    static_assert(
        PointeeTraits::is_compliant<T>::value,
        "The class of type T cannot be stored in an Amino::Ptr<T>");
    return Ptr<T>(PointeeManager::newClass<T>(std::move(list)));
}
 
//==============================================================================
// FUNCTION newMutablePtr
//==============================================================================
 
template <class T, class... Args>
inline MutablePtr<T> newMutablePtr(Args&&... args) {
    static_assert(
        PointeeTraits::is_compliant<T>::value,
        "The class of type T cannot be stored in an Amino::MutablePtr<T>");
    return MutablePtr<T>(
        PointeeManager::newClass<T>(std::forward<Args>(args)...));
}
 
template <class T, class E>
inline MutablePtr<T> newMutablePtr(std::initializer_list<E> list) {
    static_assert(
        PointeeTraits::is_compliant<T>::value,
        "The class of type T cannot be stored in an Amino::MutablePtr<T>");
    return MutablePtr<T>(PointeeManager::newClass<T>(std::move(list)));
}
 
template <typename T>
PtrGuard<T> createPtrGuard(Ptr<T>& src) {
    return PtrGuard{src};
}
template <typename T1, typename T2>
PtrGuard<T1> createPtrGuard(Ptr<T2>& src) {
    return PtrGuard<T1>(src);
}
template <typename T>
PtrGuard<T> createPtrGuard(Ptr<T>& src, PtrGuardUniqueFlag) {
    return PtrGuard{src, PtrGuardUniqueFlag{}};
}
 
//==============================================================================
// PTR CAST IMPLEMENTATIONS
//==============================================================================
 
namespace Internal {
struct PtrCast {
    template <class T, class U>
    static inline Ptr<T> static_pointer_cast(Ptr<U> const& ptr) noexcept {
        T* p = static_cast<T*>(ptr.getPointee());
        return Ptr<T>(p, ptr.getCntrlBlk(), true);
    }
    template <class T, class U>
    static inline Ptr<T> static_pointer_cast(Ptr<U>&& ptr) noexcept {
        T*   p   = static_cast<T*>(ptr.getPointee());
        auto ret = Ptr<T>(p, ptr.getCntrlBlk(), false);
        ptr.init(nullptr, nullptr);
        return ret;
    }
    template <class T, class U>
    static inline Ptr<T> dynamic_pointer_cast(Ptr<U> const& ptr) noexcept {
        T* p = dynamic_cast<T*>(ptr.getPointee());
        if (!p) return Ptr<T>{};
        return Ptr<T>(p, ptr.getCntrlBlk(), true);
    }
    template <class T, class U>
    static inline Ptr<T> dynamic_pointer_cast(Ptr<U>&& ptr) noexcept {
        T* p = dynamic_cast<T*>(ptr.getPointee());
        if (!p) {
            ptr.reset();
            return Ptr<T>{};
        }
        auto ret = Ptr<T>(p, ptr.getCntrlBlk(), false);
        ptr.init(nullptr, nullptr);
        return ret;
    }
};
} // namespace Internal
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline Ptr<T> static_pointer_cast(Ptr<U> const& ptr) noexcept {
    return Internal::PtrCast::static_pointer_cast<T>(ptr);
}
template <class T, class U>
inline Ptr<T> static_pointer_cast(Ptr<U>&& ptr) noexcept {
    return Internal::PtrCast::static_pointer_cast<T>(std::move(ptr));
}
 
//------------------------------------------------------------------------------
//
template <class T, class U>
inline Ptr<T> dynamic_pointer_cast(Ptr<U> const& ptr) noexcept {
    return Internal::PtrCast::dynamic_pointer_cast<T>(ptr);
}
template <class T, class U>
inline Ptr<T> dynamic_pointer_cast(Ptr<U>&& ptr) noexcept {
    return Internal::PtrCast::dynamic_pointer_cast<T>(std::move(ptr));
}
} // namespace Amino
 
//==============================================================================
// std::hash< Amino::Ptr<T> >
//==============================================================================
 
namespace std {
 
template <class T>
struct hash<Amino::Ptr<T>> {
    using argument_type = Amino::Ptr<T>;
    using result_type   = size_t;
 
    result_type operator()(const argument_type& ptr) const noexcept {
        return hash<T const*>()(ptr.get());
    }
};
} // namespace std
 
#endif