weak_ptr.h

 
#ifndef _aspose_system_weak_ptr_h_
#define _aspose_system_weak_ptr_h_
 
#include "smart_ptr.h"
#include "detail.h"
 
namespace System
{
 
template <class T>
class ASPOSECPP_SHARED_CLASS WeakPtr : public SmartPtr<T>
{
public:
    typedef SmartPtr<T> SmartPtr_;
    typedef WeakPtr<T> WeakPtr_;
    using typename SmartPtr_::Pointee_;
 
private:
    using SmartPtr_::m_data;
 
public:
    WeakPtr(std::nullptr_t = nullptr)
        : SmartPtr_(nullptr, SmartPtrMode::Weak)
    {}
    WeakPtr(Pointee_ *object)
        : SmartPtr_(object, SmartPtrMode::Weak)
    {}
    WeakPtr(const SmartPtr_ &ptr)
        : SmartPtr_(ptr, SmartPtrMode::Weak)
    {}
    template<class Q, typename = typename std::enable_if<std::is_convertible<Q*, Pointee_*>::value>::type>
    WeakPtr(const SmartPtr<Q>& x)
        : SmartPtr_(x, SmartPtrMode::Weak)
    {}
    WeakPtr(const WeakPtr_ &ptr)
        : SmartPtr_(ptr, SmartPtrMode::Weak)
    {}
    template<class Q, typename = typename std::enable_if<std::is_convertible<Q*, Pointee_*>::value>::type>
    WeakPtr(const WeakPtr<Q>& x)
        : SmartPtr_(x, SmartPtrMode::Weak)
    {}
    WeakPtr(SmartPtr_&& x)
        : SmartPtr_(x, SmartPtrMode::Weak)
    {}
    template <typename Q>
    WeakPtr& operator = (Q &&value)
    {
        SmartPtr_::operator = (value);
        return *this;
    }
    bool operator == (std::nullptr_t) const
    {
        return SmartPtr_::operator == (nullptr);
    }
    bool expired() const
    {
        CODEPORTING_DEBUG_ASSERT(m_data.GetMode() == SmartPtrMode::Weak);
        return m_data.IsNull();
    }
    Object* get_weak() const
    {
        CODEPORTING_DEBUG_ASSERT(m_data.GetMode() == SmartPtrMode::Weak);
        return m_data.IsNull() ? nullptr : m_data.WeakGetCounter()->GetObject();
    }
};
template <class T>
struct IsWeakPtr : System::detail::is_a<T, System::WeakPtr> {};
 
template <typename T>
struct BasePointerType<WeakPtr<T>>
{
    using type = ::System::SmartPtr<T>;
};
 
template <typename T>
void PrintTo(const WeakPtr<T>& object_ptr, std::ostream* stream)
{
    if (object_ptr == nullptr)
        *stream << "nullptr";
    else
        PrintTo(*object_ptr, stream);
}
 
template <typename T>
std::ostream& operator<<(std::ostream& stream, const WeakPtr<T>& object_ptr)
{
    if (object_ptr != nullptr)
        stream << object_ptr->ToString();
    return stream;
}
 
template <typename T>
std::wostream& operator<<(std::wostream& stream, const WeakPtr<T>& object_ptr)
{
    if (object_ptr != nullptr)
        stream << object_ptr->ToString();
    return stream;
}
 
template< class X > struct RemoveShared { typedef X type; };
 
template< class X > struct RemoveShared<System::SharedPtr<X>> { typedef X type; };
template< class X > struct RemoveShared<System::WeakPtr<X>> { typedef X type; };
 
template <class T>
struct WeakPtrFromTypeParameter : std::conditional<IsSmartPtr<T>::value, WeakPtr<typename RemoveShared<T>::type>, T>{};
 
} // namespace System
 
namespace std
{
    template <class T>
    struct hash<System::WeakPtr<T> >
    {
        using argument_type = System::WeakPtr<T>;
        using result_type = std::size_t;
        std::size_t operator()(System::WeakPtr<T> const& val) const
        {
            return val.GetHashCode();
        }
    };
}
 
#endif // _aspose_system_weak_ptr_h_