weak_object_ptr.h

Go to the documentation of this file.

 
#ifndef _ADTF_UCOM_ANT_WEAK_OBJECT_PTR_IMPLEMENTATION_HEADER_
#define _ADTF_UCOM_ANT_WEAK_OBJECT_PTR_IMPLEMENTATION_HEADER_
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
template < typename T >
class weak_object_ptr
{
    template<typename> friend class detail::delegate_object_ptr;
    typedef typename detail::object_reference_counter::size_type    size_type;
 
private:
    template < typename U >
    weak_object_ptr(U* i_pObject, detail::iobject_ptr_ref<size_type>* i_pRefer) :
        m_pObject(ucom_cast<T*>(i_pObject)),
        m_pRefer(i_pRefer)
    {
        IncreaseWeakCount();
    }
public:
    weak_object_ptr() :
        m_pObject(nullptr),
        m_pRefer(nullptr)
    {
    }
 
    ~weak_object_ptr()
    {
        DecreaseWeakCount();
    }
 
    weak_object_ptr(std::nullptr_t) : weak_object_ptr()
    {
    }
 
    weak_object_ptr(const weak_object_ptr& i_oOther) : 
        weak_object_ptr(i_oOther.m_pObject, i_oOther.m_pRefer) //Delegate increases weak count
    {
    }
    weak_object_ptr& operator=(weak_object_ptr oOther)
    {
        Swap(oOther);
        return *this;
    }
 
    weak_object_ptr(weak_object_ptr&& oOther) : weak_object_ptr()
    {
        Swap(oOther); //leave oOther in valid but unspecified state
    }
 
    template<typename U>
    weak_object_ptr(const iobject_ptr<U>& i_pOther) :
        weak_object_ptr(i_pOther.Get(), i_pOther.GetObjPtrRef()) //delegate increases weak count
    {
    }
 
    template<typename U>
    weak_object_ptr& operator=(const iobject_ptr<U>& i_pOther)
    {
        //delegate increases weak count
        *this = weak_object_ptr(i_pOther.Get(), i_pOther.GetObjPtrRef());
        return *this;
    }
 
    template<typename U>
    tResult Reset(const iobject_ptr<U>& i_oOther)
    {
        *this = i_oOther;
        return m_pObject || !i_oOther.Get() ? tResult() : tResult(ERR_NO_INTERFACE);
    }
 
    tResult Reset(const iobject_ptr<T>& i_oOther)
    {
        *this = i_oOther;
        return ERR_NOERROR;
    }
 
    void Reset()
    {
        *this = weak_object_ptr();
    }
 
    void Swap(weak_object_ptr& o_oOther)
    {
        using std::swap;    //ADL for swap()
        swap(o_oOther.m_pRefer, m_pRefer);
        swap(o_oOther.m_pObject, m_pObject);
    }
  
    object_ptr<T> Lock() const
    {
        return object_ptr<T>(*this);
    }
 
private:
    void IncreaseWeakCount()
    {
        if (nullptr != m_pRefer)
        {
            m_pRefer->IncreaseWeakCount();
        }
    }
 
    void DecreaseWeakCount()
    {
        if (nullptr != m_pRefer)
        {
            m_pRefer->DecreaseWeakCount();
            m_pRefer = nullptr;
            m_pObject = nullptr;
        }
    }
 
private:
    T*                                  m_pObject;  
    detail::iobject_ptr_ref<size_type>* m_pRefer;   
};
 
}//ns ant
 
template<class T>
using weak_object_ptr = ant::weak_object_ptr<T>;
 
}//ns ucom
}//ns adtf
 
//specializing the swap function to enable best match for compiler
namespace std
{
    template<typename T>
    inline void swap(adtf::ucom::ant::weak_object_ptr<T>& i_oLHS,
                      adtf::ucom::ant::weak_object_ptr<T>& i_oRHS)
    {
        i_oLHS.Swap(i_oRHS);
    }
}//ns std
 
#endif //_ADTF_UCOM_ANT_WEAK_OBJECT_PTR_IMPLEMENTATION_HEADER_