smart_ptr.h

 
#ifndef _aspose_system_smart_ptr_h_
#define _aspose_system_smart_ptr_h_
 
 
#include "smart_ptr_counter.h"
#include "detail.h"
#include "select_type.h"
 
#include <system/details/makeobject_leakage_detector.h>
 
#include <utility>
#include <system/diagnostics/debug.h>
#include <type_traits>
#include <ostream>
 
 
namespace System { 
 
class TypeInfo;
class SmartPtrInfo;
template <typename T> class ASPOSECPP_SHARED_CLASS Array;
template <typename T> class SmartPtr;
 
#if defined(__DBG_TOOLS)
namespace DBG {
    struct for_each_member_visitor;
}
#endif
 
namespace Details {
    class ObjectsBag;
 
    template <typename T> struct ArrayTypeResolver
    {
        using type = void;
        using value_type = void;
    };
    template <typename T> struct ArrayTypeResolver<Array<T>>
    {
        using type = Array<T>;
        using value_type = T;
    };
 
    template <typename X, typename IdxType> typename Array<X>::UnderlyingType& GetByIndex(const SmartPtr<Array<X>> *ptr, IdxType idx);
    template <typename T> Array<T>* CreateArray(Array<T>*);
}
enum class SmartPtrMode : char
{
    Shared,
    Weak
};
 
struct EmptyArrayInitializer {};
 
template <class T>
class ASPOSECPP_SHARED_CLASS SmartPtr
{
public:
    typedef T Pointee_;
    typedef SmartPtr<T> SmartPtr_;
    typedef typename System::Details::ArrayTypeResolver<T>::type ArrayType;
    using ValueType = typename System::Details::SelectType<typename System::Details::ArrayTypeResolver<T>::value_type>::type;
    SmartPtr(SmartPtrMode mode)
        : m_data(mode)
    {
        m_data.SetNull();
    }
    SmartPtr(std::nullptr_t = nullptr, SmartPtrMode mode = SmartPtrMode::Shared)
        : m_data(mode)
    {
        m_data.SetNull();
    }
    SmartPtr(Pointee_ *object, SmartPtrMode mode = SmartPtrMode::Shared)
        : m_data(mode)
    {
        Lock(object);
    }
    SmartPtr(const SmartPtr_ &ptr, SmartPtrMode mode = SmartPtrMode::Shared)
        : m_data(mode)
    {
        Lock(ptr);
    }
    template<class Q, typename = typename std::enable_if<System::detail::is_pointer_convertible<Q, Pointee_>::type::value>::type>
    SmartPtr(const SmartPtr<Q>& x, SmartPtrMode mode = SmartPtrMode::Shared)
        : m_data(mode)
    {
        Lock(x);
    }
    SmartPtr(SmartPtr_&& x, SmartPtrMode mode = SmartPtrMode::Shared) noexcept
        : m_data(mode)
    {
        if (m_data.GetMode() == x.m_data.GetMode())
        {
            m_data.SetNull();
            m_data.swapPointers(x.m_data);
        }
        else
        {
            if (m_data.GetMode() == SmartPtrMode::Shared)
                MoveSharedFromWeak(std::move(x));
            else
                MoveWeakFromShared(std::move(x));
        }
    }
    template <typename Y>
    explicit SmartPtr(const SmartPtr<Array<Y>> &src, SmartPtrMode mode = SmartPtrMode::Shared)
        : m_data(mode)
    {
        InitArray(this, src);
    }
    template <typename Y, typename = typename std::enable_if<std::is_same<Y, EmptyArrayInitializer>::value, void>::type>
    explicit SmartPtr(const Y &)
    {
        Lock(Details::CreateArray((Pointee_*)nullptr));
    }
    template <typename P>
    SmartPtr(const SmartPtr<P> &ptr, Pointee_ *p, SmartPtrMode mode = SmartPtrMode::Shared)
        : m_data(mode)
    {
        if (ptr == nullptr || p == nullptr)
            m_data.SetNull();
        else if (m_data.GetMode() == SmartPtrMode::Weak)
        {
            if (ptr.m_data.GetMode() == SmartPtrMode::Weak)
                m_data.WeakSetPointer(
                    p
                    , detail::cast_statically_or_dynamically<Pointee_, Object>::cast(p)
                    , ptr.m_data.WeakGetCounter()->WeakRefAdded()
                );
            else
                m_data.WeakSetPointer(
                    p
                    , detail::cast_statically_or_dynamically<Pointee_, Object>::cast(p)
#ifdef ENABLE_EXTERNAL_REFCOUNT
                    , ptr.m_data.SharedGetCounter()->WeakRefAdded()
#else
                    , ptr.m_data.SharedGetObject()->WeakRefAdded()
#endif
                );
        }
        else
        {
            if (ptr.m_data.GetMode() == SmartPtrMode::Weak)
                m_data.SharedSetPointer(
                    p
                    , detail::cast_statically_or_dynamically<Pointee_, Object>::cast(p)
                    , ptr.m_data.WeakGetCounter()->Lock()
#ifdef ENABLE_EXTERNAL_REFCOUNT
                    , ptr.m_data.WeakGetCounter()
#endif
                );
            else
                m_data.SharedSetPointer(
                    p
                    , detail::cast_statically_or_dynamically<Pointee_, Object>::cast(p)
                    , ptr.m_data.SharedGetOwned()->SharedRefAdded()
#ifdef ENABLE_EXTERNAL_REFCOUNT
                    , ptr.m_data.SharedGetCounter()
#endif
                );
        }
    }
    ~SmartPtr()
    {
        delete ReleaseAndGetObjectToDelete();
    }
    SmartPtr_& operator = (SmartPtr_&& x) noexcept
    {
        Pointee_ *const this_pointee = m_data.GetPointee();
        Pointee_ *const other_pointee = x.m_data.GetPointee();
 
        if (this_pointee == nullptr)
        {
            if (other_pointee == nullptr)
                return *this;
 
            if (x.m_data.GetMode() == SmartPtrMode::Shared)
            {
                if (m_data.GetMode() == SmartPtrMode::Shared)
                    m_data.swapPointers(x.m_data);
                else
                    MoveWeakFromShared(std::move(x));
            }
            else
            {
                if (x.m_data.WeakGetCounter()->GetObject() == nullptr)
                    return *this;
                if (m_data.GetMode() == SmartPtrMode::Weak)
                    m_data.swapPointers(x.m_data);
                else
                    MoveSharedFromWeak(std::move(x));
            }
        }
        else
        {
            if (other_pointee == nullptr)
            {
                if (m_data.GetMode() == SmartPtrMode::Shared)
                    delete ReleaseSharedAndGetObjectToDelete();
                else
                    ReleaseWeak();
                m_data.SetNull();
            }
            else if (x.m_data.GetMode() == SmartPtrMode::Shared)
            {
                if (m_data.GetMode() == SmartPtrMode::Shared)
                {
                    if (this_pointee != other_pointee || m_data.SharedGetOwned() != x.m_data.SharedGetOwned())
                        m_data.swapPointers(x.m_data);
                }
                else
                {
                    System::Detail::SmartPtrCounter *const releaser = m_data.WeakGetCounter();
                    if (this_pointee != other_pointee || releaser->GetObject() != x.m_data.SharedGetOwned())
                    {
                        MoveWeakFromShared(std::move(x));
                        ReleaseWeak(releaser);
                    }
                }
            }
            else
            {
                System::Detail::SmartPtrCounter *const other_counter = x.m_data.WeakGetCounter();
                if (other_counter->GetObject() == nullptr)
                {
                    if (m_data.GetMode() == SmartPtrMode::Shared)
                        delete ReleaseSharedAndGetObjectToDelete();
                    else
                        ReleaseWeak();
                    m_data.SetNull();
                }
                else if (m_data.GetMode() == SmartPtrMode::Weak)
                {
                    if (this_pointee != other_pointee || m_data.WeakGetCounter() != other_counter)
                        m_data.swapPointers(x.m_data);
                }
                else
                {
                    if (this_pointee != other_pointee || m_data.SharedGetOwned() != other_counter->GetObject())
                    {
                        SharedRefReleaser *const releaser = GetSharedReleaser();
                        MoveSharedFromWeak(std::move(x));
                        delete ReleaseSharedAndGetObjectToDelete(releaser);
                    }
                }
            }
        }
 
        return *this;
    }
    SmartPtr_& operator = (const SmartPtr_ &x)
    {
        Assign(x);
        return *this;
    }
    template <typename Q>
    SmartPtr_& operator = (const SmartPtr<Q> &x)
    {
        Assign(x);
        return *this;
    }
    SmartPtr_& operator = (Pointee_ *p)
    {
        if (GetPointer() != p)
        {
            SmartPtr_ temp(p, get_Mode());
            m_data.swapPointers(temp.m_data);
        }
        return *this;
    }
    SmartPtr_& operator = (std::nullptr_t)
    {
        delete ReleaseAndGetObjectToDelete();
        m_data.SetNull();
        return *this;
    }
    Pointee_* operator -> () const
    {
        return GetObjectNotNull();
    }
    bool operator == (std::nullptr_t) const
    {
        return m_data.IsNull();
    }
    Pointee_* get() const
    {
        return m_data.GetPointee();
    }
    Pointee_* get_shared() const
    {
        return m_data.SharedGetPointee();
    }
    void reset(Pointee_ *ptr)
    {
        delete ReleaseAndGetObjectToDelete();
        Lock(ptr);
    }
    void reset()
    {
        delete ReleaseAndGetObjectToDelete();
        m_data.SetNull();
    }
    SmartPtrMode get_Mode() const
    {
        return m_data.GetMode();
    }
    bool IsShared() const
    {
        return m_data.GetMode() == SmartPtrMode::Shared;
    }
    bool IsWeak() const
    {
        return m_data.GetMode() == SmartPtrMode::Weak;
    }
    bool IsAliasingPtr() const
    {
        Object* pointee = nullptr;
        Object* owner = nullptr;
        if (m_data.GetMode() == SmartPtrMode::Shared)
        {
            pointee = m_data.SharedGetObject();
            owner = m_data.SharedGetOwned();
        }
        else
        {
            pointee = m_data.WeakGetObject();
            System::Detail::SmartPtrCounter* counter = m_data.WeakGetCounterOrNull();
            owner = counter == nullptr ? nullptr : counter->GetObject();
        }
        return pointee != owner;
    }
    Object* GetObjectOwner() const
    {
        Object* owner = nullptr;
        if (m_data.GetMode() == SmartPtrMode::Shared)
        {
            owner = m_data.SharedGetOwned();
        }
        else
        {
            System::Detail::SmartPtrCounter* counter = m_data.WeakGetCounterOrNull();
            if (counter) {
                owner = counter->GetObject();
            }
        }
 
        return owner;
    }
 
    SmartPtr_ RemoveAliasing() const
    {
        return SmartPtr_(get());
    }
    void set_Mode(SmartPtrMode mode)
    {
        if (m_data.GetMode() == mode)
            return;
        SmartPtr_ ptr(*this, mode);
        m_data.swap(ptr.m_data);
    }
    Pointee_& operator *() const
    {
        return *GetObjectNotNull();
    }
    explicit operator bool() const noexcept
    {
        return *this != nullptr;
    }
    bool operator !() const noexcept
    {
        return *this == nullptr;
    }
    template<class Y>
    bool operator < (Y* p) const
    {
        return GetObjectOrNull() < p;
    }
    template<class Y>
    bool operator < (SmartPtr<Y> const& x) const
    {
        return GetObjectOrNull() < x.GetObjectOrNull();
    }
    static const System::TypeInfo& Type()
    {
        return Pointee_::Type();
    }
    template<class Y>
    SmartPtr<Y> static_pointer_cast() const
    {
        return m_data.IsNull() ? SmartPtr<Y>() : SmartPtr<Y>(*this, static_cast<Y*>(m_data.GetPointee()));
    }
    template<class Y>
    inline SmartPtr<Y> dynamic_pointer_cast() const
    {
        return m_data.IsNull() ? SmartPtr<Y>() : SmartPtr<Y>(*this, dynamic_cast<Y*>(m_data.GetPointee()));
    }
    template<class Y>
    SmartPtr<Y> const_pointer_cast() const
    {
        return m_data.IsNull() ? SmartPtr<Y>() : SmartPtr<Y>(*this, const_cast<Y*>(m_data.GetPointee()));
    }
    template<class Y, typename Check = std::false_type>
    std::enable_if_t<std::is_same<Y, T>::value, SmartPtr<Y>> Cast() const
    {
        return *this;
    }
    template <class Y, typename Check = std::false_type>
    std::enable_if_t<!std::is_same<Y, T>::value && std::is_base_of<Y, T>::value, SmartPtr<Y>> Cast() const
    {
        return m_data.IsNull() ? SmartPtr<Y>() : SmartPtr<Y>(*this, static_cast<Y*>(m_data.GetPointee()));
    }
    template <class Y, typename Check = std::false_type>
    std::enable_if_t<Check::value && !std::is_same<Y, T>::value && !std::is_base_of<Y, T>::value, SmartPtr<Y>> Cast() const
    {
        auto result = m_data.IsNull() ? SmartPtr<Y>() : SmartPtr<Y>(*this, dynamic_cast<Y*>(m_data.GetPointee()));
        if ((*this) && !result)
            System::Detail::SmartPtrCounter::ThrowInvalidCastException();
 
        return result;
    }
    template <class Y, typename Check = std::false_type>
    std::enable_if_t<!Check::value && !std::is_same<Y, T>::value && !std::is_base_of<Y, T>::value, SmartPtr<Y>> Cast() const
    {
        return m_data.IsNull() ? SmartPtr<Y>() : SmartPtr<Y>(*this, dynamic_cast<Y*>(m_data.GetPointee()));
    }
    bool Is(const System::TypeInfo &target) const;
    Object* GetObjectOrNull() const
    {
        if (m_data.IsNull())
            return nullptr;
        else if (m_data.GetMode() == SmartPtrMode::Shared)
            return m_data.SharedGetObject();
        else
            return m_data.WeakGetObject();
    }
    SmartPtr<Object> ToObjectPtr() const;
    Pointee_* GetPointer() const
    {
        return m_data.GetPointee();
    }
    int get_shared_count() const
    {
        if (m_data.SharedGetPointee() == nullptr) //Asserts we're in shared pointer mode
            return 0;
        else
#ifdef ENABLE_EXTERNAL_REFCOUNT
            return m_data.SharedGetCounter()->SharedCount();
#else
            return m_data.SharedGetOwned()->SharedCount();
#endif
    }
    void SetContainedTemplateWeakPtr(uint32_t argument) const;
    template <typename IdxType>
    decltype(System::Details::GetByIndex(std::declval<const SmartPtr_*>(), std::declval<IdxType>())) operator[] (IdxType idx) const
    {
        return System::Details::GetByIndex(this, idx);
    }
 
    template <typename Q = T> auto begin() -> decltype(std::declval<Q>().begin())
    {
        return GetObjectNotNull()->begin();
    }
 
    template <typename Q = T> auto end() -> decltype(std::declval<Q>().end())
    {
        return GetObjectNotNull()->end();
    }
 
    template <typename Q = T> auto begin() const -> decltype(std::declval<const Q>().begin())
    {
        return GetObjectNotNull()->begin();
    }
 
    template <typename Q = T> auto end() const -> decltype(std::declval<const Q>().end())
    {
        return GetObjectNotNull()->end();
    }
 
    template <typename Q = T> auto cbegin() const -> decltype(std::declval<const Q>().cbegin())
    {
        return GetObjectNotNull()->cbegin();
    }
 
    template <typename Q = T> auto cend() const -> decltype(std::declval<const Q>().cend())
    {
        return GetObjectNotNull()->cend();
    }
 
    int GetHashCode() const
    {
        return GetHashCodeImpl(static_cast<Pointee_*>(nullptr));
    }
 
    T* GetObjectNotNull() const
    {
        if (m_data.IsNull())
            System::Detail::SmartPtrCounter::ThrowNullReferenceException();
        return m_data.GetPointee();
    }
 
protected:
    template <class Q> friend class SmartPtr;
    friend class SmartPtrInfo;
    friend class System::Details::ObjectsBag;
#if defined(__DBG_TOOLS)
    friend struct DBG::for_each_member_visitor;
#endif
    void Lock(Pointee_ *object)
    {
        if (object == nullptr)
            m_data.SetNull();
        else
        {
            if (m_data.GetMode() == SmartPtrMode::Shared)
#ifdef ENABLE_EXTERNAL_REFCOUNT
                m_data.SharedSetPointer(object, object->Object::SharedRefAdded(), object->Object::GetCounter());
#else
                m_data.SharedSetPointer(object, object->Object::SharedRefAdded());
#endif
            else
                m_data.WeakSetPointer(object, detail::cast_statically_or_dynamically<Pointee_, Object>::cast(object), object->Object::WeakRefAdded());
        }
    }
    template <class Q>
    void Lock(const SmartPtr<Q> &ptr)
    {
        if (ptr.m_data.IsNull())
            m_data.SetNull();
        else if (m_data.GetMode() == SmartPtrMode::Weak)
        {
            if (ptr.m_data.GetMode() == SmartPtrMode::Weak)
                LockWeakFromWeak(ptr);
            else
                LockWeakFromShared(ptr);
        }
        else
        {
            if (ptr.m_data.GetMode() == SmartPtrMode::Weak)
                LockSharedFromWeak(ptr);
            else
                LockSharedFromShared(ptr);
        }
    }
    template <typename Q>
    void LockSharedFromShared(const SmartPtr<Q> &ptr)
    {
        m_data.SharedSetPointer(
            ptr.m_data.SharedGetPointee()
            , ptr.m_data.SharedGetObject()
            , ptr.m_data.SharedGetOwned()->SharedRefAdded()
#ifdef ENABLE_EXTERNAL_REFCOUNT
            , ptr.m_data.SharedGetCounter()
#endif
        );
    }
    template <typename Q>
    void LockSharedFromWeak(const SmartPtr<Q> &ptr)
    {
        m_data.SharedSetPointer(
            ptr.m_data.WeakGetPointee()
            , ptr.m_data.WeakGetObject()
            , ptr.m_data.WeakGetCounter()->Lock()
#ifdef ENABLE_EXTERNAL_REFCOUNT
            , ptr.m_data.WeakGetCounter()
#endif
        );
    }
    template <typename Q>
    void LockWeakFromShared(const SmartPtr<Q> &ptr)
    {
        m_data.WeakSetPointer(
            ptr.m_data.SharedGetPointee()
            , ptr.m_data.SharedGetObject()
#ifdef ENABLE_EXTERNAL_REFCOUNT
            ,  ptr.IsAliasingPtr() ? ptr.m_data.SharedGetObject()->WeakRefAdded() : ptr.m_data.SharedGetCounter()->WeakRefAdded()
#else
            , ptr.IsAliasingPtr() ? ptr.m_data.SharedGetObject()->WeakRefAdded() : ptr.m_data.SharedGetOwned()->WeakRefAdded()
#endif
        );
    }
    template <typename Q>
    void LockWeakFromWeak(const SmartPtr<Q> &ptr)
    {
        m_data.WeakSetPointer(
            ptr.m_data.WeakGetPointee()
            , ptr.m_data.WeakGetObject()
            , ptr.m_data.WeakGetCounter()->WeakRefAdded()
        );
    }
    Object* ReleaseAndGetObjectToDelete()
    {
        if (m_data.HoldsReference())
        {
            if (m_data.GetMode() == SmartPtrMode::Shared)
                return ReleaseSharedAndGetObjectToDelete();
            else
                ReleaseWeak();
        }
        return nullptr;
    }
#ifdef ENABLE_EXTERNAL_REFCOUNT
    typedef System::Detail::SmartPtrCounter SharedRefReleaser;
    SharedRefReleaser* GetSharedReleaser() const
    {
        return m_data.SharedGetCounter();
    }
#else
    typedef Object SharedRefReleaser;
    SharedRefReleaser* GetSharedReleaser() const
    {
        return m_data.SharedGetOwned();
    }
#endif
    static Object* ReleaseSharedAndGetObjectToDelete(SharedRefReleaser *releaser);
    Object* ReleaseSharedAndGetObjectToDelete()
    {
        return ReleaseSharedAndGetObjectToDelete(GetSharedReleaser());
    }
    static void ReleaseWeak(System::Detail::SmartPtrCounter *counter)
    {
        counter->WeakRefRemoved();
    }
    void ReleaseWeak()
    {
        m_data.WeakGetCounter()->WeakRefRemoved();
    }
    void MoveSharedFromWeak(SmartPtr &&x)
    {
        if (x.m_data.IsNull())
            m_data.SetNull();
        else
        {
            m_data.SharedSetPointer(
                x.m_data.WeakGetPointee()
                , x.m_data.WeakGetCounter()->Lock()
#ifdef ENABLE_EXTERNAL_REFCOUNT
                , x.m_data.WeakGetCounter()
#endif
            );
            x.ReleaseWeak();
            x.m_data.SetNull();
        }
    }
    void MoveWeakFromShared(SmartPtr &&x)
    {
        if (x.m_data.IsNull())
            m_data.SetNull();
        else
        {
            m_data.WeakSetPointer(
                x.m_data.SharedGetPointee()
                , x.m_data.SharedGetObject()
#ifdef ENABLE_EXTERNAL_REFCOUNT
                , x.m_data.SharedGetCounter()->WeakRefAdded()
#else
                , x.m_data.SharedGetOwned()->WeakRefAdded()
#endif
            );
            delete x.ReleaseSharedAndGetObjectToDelete();
            x.m_data.SetNull();
        }
    }
    template <typename X, typename Y>
    static void InitArray(SmartPtr<Array<X>> *ptr, const SmartPtr<Array<Y>> &src)
    {
        T *const destination = new T(src->get_Length());
        ptr->Lock(destination);
        std::copy(src->data().begin(), src->data().end(), destination->data().begin());
    }
    template <typename Q, typename R = decltype(std::declval<Q*>()->GetHashCode())>
    R GetHashCodeImpl(Q*) const
    {
        if (m_data.IsNull())
            return 0;
        else
            return GetPointer()->GetHashCode();
    }
    int GetHashCodeImpl(void*) const
    {
        if (m_data.IsNull())
            return 0;
        else if (m_data.GetMode() == SmartPtrMode::Shared)
            return m_data.SharedGetObject()->GetHashCode();
        else
            return m_data.WeakGetCounter()->GetObject()->GetHashCode();
    }
    template <typename Q>
    void Assign(const SmartPtr<Q> &x)
    {
        Pointee_ *const this_pointee = m_data.GetPointee();
        Pointee_ *const other_pointee = x.m_data.GetPointee();
 
        if (this_pointee == nullptr)
        {
            if (other_pointee == nullptr)
                return;
            if (x.m_data.GetMode() == SmartPtrMode::Shared)
            {
                if (m_data.GetMode() == SmartPtrMode::Shared)
                    LockSharedFromShared(x);
                else
                    LockWeakFromShared(x);
            }
            else
            {
                if (x.m_data.WeakGetCounter()->GetObject() == nullptr)
                    return;
                if (m_data.GetMode() == SmartPtrMode::Shared)
                    LockSharedFromWeak(x);
                else
                    LockWeakFromWeak(x);
            }
        }
        else if (x.m_data.GetMode() == SmartPtrMode::Shared)
        {
            if (other_pointee == nullptr)
            {
                if (m_data.GetMode() == SmartPtrMode::Shared)
                    delete ReleaseSharedAndGetObjectToDelete();
                else
                    ReleaseWeak();
                m_data.SetNull();
            }
            else if (m_data.GetMode() == SmartPtrMode::Shared)
            {
                if (this_pointee != other_pointee || m_data.SharedGetOwned() != x.m_data.SharedGetOwned())
                {
                    SharedRefReleaser *const releaser = GetSharedReleaser();
                    LockSharedFromShared(x);
                    delete ReleaseSharedAndGetObjectToDelete(releaser);
                }
            }
            else
            {
                if (this_pointee != other_pointee || m_data.WeakGetCounter()->GetObject() != x.m_data.SharedGetOwned())
                {
                    ReleaseWeak();
                    LockWeakFromShared(x);
                }
            }
        }
        else
        {
            if (other_pointee == nullptr)
            {
                if (m_data.GetMode() == SmartPtrMode::Shared)
                    delete ReleaseSharedAndGetObjectToDelete();
                else
                    ReleaseWeak();
                m_data.SetNull();
                return;
            }
 
            Object *const other_owned = x.m_data.WeakGetCounter()->GetObject();
            if (other_owned == nullptr)
            {
                if (m_data.GetMode() == SmartPtrMode::Shared)
                    delete ReleaseSharedAndGetObjectToDelete();
                else
                    ReleaseWeak();
                m_data.SetNull();
            }
            else if (m_data.GetMode() == SmartPtrMode::Shared)
            {
                if (this_pointee != other_pointee || m_data.SharedGetOwned() != other_owned)
                {
                    delete ReleaseSharedAndGetObjectToDelete();
                    LockSharedFromWeak(x);
                }
            }
            else
            {
                if (this_pointee != other_pointee || m_data.WeakGetCounter() != x.m_data.WeakGetCounter())
                {
                    System::Detail::SmartPtrCounter *const releaser = m_data.WeakGetCounter();
                    LockWeakFromWeak(x);
                    ReleaseWeak(releaser);
                }
            }
        }
    }
    class Data {
        SmartPtrMode m_mode;
        Pointee_ *m_pointee;
        Object *m_object;
#ifdef ENABLE_EXTERNAL_REFCOUNT
        Object *m_owned;
        System::Detail::SmartPtrCounter *m_counter;
#else
        union {
            Object *m_owned;
            System::Detail::SmartPtrCounter *m_counter;
        };
#endif
    public:
        Data(SmartPtrMode mode)
            : m_mode(mode) //No initialization for other members - they will be assigned by SmartPtr constructor
        {}
        Data(const Data&) = delete;
        Data(Data&&) = delete;
        Data& operator = (const Data&) = delete;
        Data& operator = (Data&&) = delete;
        SmartPtrMode GetMode() const
        {
            return m_mode;
        }
        void SetMode(SmartPtrMode mode)
        {
            m_mode = mode;
        }
        T* GetPointee() const
        {
            return m_pointee;
        }
        T* GetComparable() const
        {
            if (m_mode == SmartPtrMode::Shared)
                return m_pointee;
            else if (m_pointee == nullptr)
                return nullptr;
            else if (m_counter->GetObject() == nullptr)
                return nullptr;
            else
                return m_pointee;
        }
        bool IsNull() const
        {
            return m_pointee == nullptr || (m_mode == SmartPtrMode::Weak && m_counter->GetObject() == nullptr);
        }
        void SetNull()
        {
            m_pointee = nullptr;
        }
        bool HoldsReference() const
        {
            return m_pointee != nullptr;
        }
        Pointee_* WeakGetPointee() const
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Weak);
            return m_pointee;
        }
        System::Detail::SmartPtrCounter* WeakGetCounter() const
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Weak);
            return m_counter;
        }
        System::Detail::SmartPtrCounter* WeakGetCounterOrNull() const
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Weak);
            return IsNull() ? nullptr : m_counter;
        }
        void WeakSetPointer(Pointee_ *pointee, Object *object, System::Detail::SmartPtrCounter *counter)
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Weak);
            m_pointee = pointee;
            m_object = object;
            m_counter = counter;
        }
        Pointee_* SharedGetPointee() const
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            return m_pointee;
        }
        Object* SharedGetObject() const
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            return m_object;
        }
        Object* WeakGetObject() const
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Weak);
            return m_object;
        }
        Object* SharedGetOwned() const
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            return m_owned;
        }
        Object* SharedGetObjectOrNull() const
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            return IsNull() ? nullptr : m_object;
        }
        Object* SharedGetOwnedOrNull() const
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            return IsNull() ? nullptr : m_owned;
        }
#ifdef ENABLE_EXTERNAL_REFCOUNT
        System::Detail::SmartPtrCounter* SharedGetCounter() const
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            return m_counter;
        }
        System::Detail::SmartPtrCounter** SharedGetCounterPointer()
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            return &m_counter;
        }
        System::Detail::SmartPtrCounter* SharedGetCounterOrNull() const
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            return IsNull() ? nullptr : m_counter;
        }
        void SharedSetPointer(Pointee_ *pointee, Object *object, Object *owned, System::Detail::SmartPtrCounter *counter)
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            m_pointee = pointee;
            m_object = object;
            m_owned = owned;
            m_counter = counter;
        }
        void SharedSetPointer(Pointee_ *pointee, Object *object, System::Detail::SmartPtrCounter *counter)
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            m_pointee = pointee;
            m_object = object;
            m_owned = object;
            m_counter = counter;
        }
#else
        void SharedSetPointer(Pointee_ *pointee, Object *object, Object *owned)
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            m_pointee = pointee;
            m_object = object;
            m_owned = owned;
        }
        void SharedSetPointer(Pointee_ *pointee, Object *object)
        {
            CODEPORTING_DEBUG_ASSERT(m_mode == SmartPtrMode::Shared);
            m_pointee = pointee;
            m_object = object;
            m_owned = object;
        }
#endif
        void swap(Data &data) noexcept
        {
            std::swap(m_mode, data.m_mode);
            swapPointers(data);
        }
        void swapPointers(Data &data) noexcept
        {
            std::swap(m_pointee, data.m_pointee);
            std::swap(m_object, data.m_object);
            std::swap(m_owned, data.m_owned);
#ifdef ENABLE_EXTERNAL_REFCOUNT
            std::swap(m_counter, data.m_counter);
#endif
        }
    }
    m_data;
};
 
 
namespace Detail {
#ifdef ENABLE_EXTERNAL_REFCOUNT
    class OwnNextObject
    {
    public:
        OwnNextObject()
        {
            SmartPtrCounter::NextOwnership() = SmartPtrCounter::BeingConstructed; // Not until constructors succeed
        }
        template <typename T>
        void CreatedSuccessfully(T *object) {
            object->Object::GetCounter()->CreatedSuccessfully(); // No exceptions thrown - should now manage memory by shared pointers
        }
    };
#else
    class OwnNextObject
    {
    public:
        template <typename T>
        void CreatedSuccessfully(T *) {}
    };
#endif
}
template <class T>
struct IsSmartPtr : System::detail::is_a<T, System::SmartPtr> {};
template<class T, class ...Args>
typename std::enable_if<!IsSmartPtr<T>::value, SmartPtr<T> >::type  MakeObject(Args&&... args)
{
    System::Details::MakeObjectLeakageDetector::SignatureBacktraceSentry signature_sentry;
    System::Details::MakeObjectLeakageDetector::SetSignature<T>(std::forward<Args>(args)...);
 
    System::Detail::OwnNextObject ownershipSentry;
 
    T *const object = ::new T(std::forward<Args>(args)...);
 
    ownershipSentry.CreatedSuccessfully(object);
    signature_sentry.CreatedSuccessfully(object);
 
    return SmartPtr<T>(object);
}
template<class T, class ...Args>
typename std::enable_if<IsSmartPtr<T>::value, T>::type MakeObject(Args&&... args)
{
    return MakeObject<typename T::Pointee_>(std::forward<Args>(args)...);
}
template<class X, class Y>
bool operator == (const SmartPtr<X> &x, const SmartPtr<Y> &y)
{
    return x.GetObjectOrNull() == y.GetObjectOrNull();
}
template<class X, class Y>
bool operator != (const SmartPtr<X> &x, const SmartPtr<Y> &y)
{
    return x.GetObjectOrNull() != y.GetObjectOrNull();
}
template<class X>
bool operator == (std::nullptr_t, SmartPtr<X> const& x)
{
    return x == nullptr;
}
template<class X>
bool operator !=(SmartPtr<X> const& x, std::nullptr_t)
{
    return !(x == nullptr);
}
template<class X>
bool operator !=(std::nullptr_t, SmartPtr<X> const& x)
{
    return !(x == nullptr);
}
template<class X, class Y>
typename std::enable_if<std::is_base_of<Object, Y>::value && detail::has_no_operator_equal<X,Y>::value, bool>::type
operator == (const SmartPtr<X>& x, const Y* y)
{
    return x.GetObjectOrNull() == static_cast<const Object*>(y);
}
template<class X, class Y>
typename std::enable_if<std::is_base_of<Object, Y>::value && detail::has_no_operator_equal<X,Y>::value, bool>::type
operator != (const SmartPtr<X>& x, const Y* y)
{
    return x.GetObjectOrNull() != static_cast<const Object*>(y);
}
template<class X, class Y>
typename std::enable_if<std::is_base_of<Object, X>::value && detail::has_no_operator_equal<X,Y>::value, bool>::type
operator == (const X* x, const SmartPtr<Y>& y)
{
    return y.GetObjectOrNull() == static_cast<const Object*>(x);
}
template<class X, class Y>
typename std::enable_if<std::is_base_of<Object, X>::value && detail::has_no_operator_equal<X,Y>::value, bool>::type
operator != (const X* x, const SmartPtr<Y>& y)
{
    return y.GetObjectOrNull() != static_cast<const Object*>(x);
}
template<class T>
typename std::enable_if<!std::is_scalar<T>::value && !std::is_pointer<T>::value && !std::is_array<T>::value && detail::has_method_is_null<T>::value, bool>::type operator ==(T const& x, std::nullptr_t)
{
    return x.IsNull();
}
template<class T>
typename std::enable_if<!std::is_scalar<T>::value && !std::is_pointer<T>::value && !std::is_array<T>::value && detail::has_method_is_null<T>::value, bool>::type operator ==(std::nullptr_t, T const& x)
{
    return x.IsNull();
}
template<class X>
SmartPtr<X> MakeSharedPtr(X* p)
{
    return SmartPtr<X>(p, SmartPtrMode::Shared);
}
template<class X>
SmartPtr<X> MakeSharedPtr(const X* p)
{
    return SmartPtr<X>(const_cast<X*>(p), SmartPtrMode::Shared);
}
template<class Y, class X>
SmartPtr<Y> static_pointer_cast(SmartPtr<X> const& x)
{
    return x.template static_pointer_cast<Y>();
}
template<class Y, class X>
SmartPtr<Y> dynamic_pointer_cast(SmartPtr<X> const& x)
{
    return x.template dynamic_pointer_cast<Y>();
}
 
template<class Y, class X>
SmartPtr<Y> const_pointer_cast(SmartPtr<X> const& x)
{
    return x.template const_pointer_cast<Y>();
}
class SmartPtrInfo
{
public:
    inline SmartPtrInfo()
        : m_object(nullptr)
        , m_owned(nullptr)
        , m_internal_pointer(nullptr)
    {}
    template <typename T>
    explicit inline SmartPtrInfo(const SmartPtr<T> &ptr)
        : m_object(ptr.IsShared() ? ptr.m_data.SharedGetObject() : nullptr)
        , m_owned(ptr.IsShared() ? ptr.m_data.SharedGetOwned() : nullptr)
        , m_internal_pointer(ptr.IsShared() ? ptr.m_data.GetPointee() : nullptr)
    {}
    inline operator bool() const
    {
        return m_internal_pointer != nullptr;
    }
    inline bool operator ! () const
    {
        return m_object == nullptr;
    }
    inline Object* operator -> () const
    {
        return m_object;
    }
    inline bool operator < (const SmartPtrInfo &other) const
    {
        return m_internal_pointer < other.m_internal_pointer;
    }
    inline Object* getObject() const
    {
        return m_object;
    }
    inline Object* getOwned() const
    {
        return m_owned;
    }
    const void* getInternalPtr() const
    {
        return m_internal_pointer;
    }
 
private:
    Object *m_object;
    Object *m_owned;
    void *m_internal_pointer;
};
template<class T>
T* get_pointer(System::SmartPtr<T> const& x)
{
    return x.GetPointer();
}
template <typename T> using ArrayPtr = SmartPtr<Array<T>>;
template <typename T> using SharedPtr = SmartPtr<T>;
template <typename T>
T& Ref(T &value)
{
    return value;
}
 
template <typename T>
struct BasePointerType
{
    using type = T;
};
 
template <typename T>
std::enable_if_t<detail::has_print_to_function<T>::value, void> PrintTo(const SmartPtr<T>& object_ptr, std::ostream* stream)
{
    if (object_ptr == nullptr)
        *stream << "nullptr";
    else
        PrintTo(*object_ptr, stream);
}
 
template <typename T>
std::enable_if_t<!detail::has_print_to_function<T>::value, void> PrintTo(const SmartPtr<T>& object_ptr, std::ostream* stream)
{
    if (object_ptr == nullptr)
        *stream << "nullptr";
    else
        PrintTo(*object_ptr.GetObjectOrNull(), stream);
}
 
template <typename T>
std::ostream& operator<<(std::ostream& stream, const SharedPtr<T>& object_ptr)
{
    if (object_ptr != nullptr)
        stream << object_ptr->ToString();
    return stream;
}
 
template <typename T>
std::wostream& operator<<(std::wostream& stream, const SharedPtr<T>& object_ptr)
{
    if (object_ptr != nullptr)
        stream << object_ptr->ToString();
    return stream;
}
 
} //namespace System
 
#define CODEPORTING_ARGS(...) __VA_ARGS__
 
#define MEMBER_FUNCTION_MAKE_OBJECT(name, args_with_types, args) \
 \
static System::SmartPtr<name> MakeObject(args_with_types) \
{ \
    System::Details::MakeObjectLeakageDetector::SignatureBacktraceSentry signature_sentry; \
    System::Details::MakeObjectLeakageDetector::SetSignature<name>(args); \
\
    System::Detail::OwnNextObject ownershipSentry; \
\
    name *const object = ::new name(args); \
\
    ownershipSentry.CreatedSuccessfully(object); \
    signature_sentry.CreatedSuccessfully(object); \
\
    return System::SmartPtr<name>(object); \
}
#define MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(name, args_with_types) \
static System::SmartPtr<name> MakeObject(args_with_types);
 
#define MEMBER_FUNCTION_MAKE_OBJECT_DEFINITION(name, args_with_types, args) \
System::SmartPtr<name> name::MakeObject(args_with_types) \
{ \
    System::Details::MakeObjectLeakageDetector::SignatureBacktraceSentry signature_sentry; \
    System::Details::MakeObjectLeakageDetector::SetSignature<name>(args); \
\
    System::Detail::OwnNextObject ownershipSentry; \
\
    name *const object = ::new name(args); \
\
    ownershipSentry.CreatedSuccessfully(object); \
    signature_sentry.CreatedSuccessfully(object); \
\
    return System::SmartPtr<name>(object); \
}
 
namespace std
{
    template <class T>
    struct hash<System::SharedPtr<T> >
    {
        using argument_type = System::SharedPtr<T>;
        using result_type = std::size_t;
        std::size_t operator()(System::SharedPtr<T> const& val) const
        {
            return val.GetHashCode();
        }
    };
}
 
#endif //_aspose_system_smart_ptr_h_