object_ptr_utilities.h

Go to the documentation of this file.

 
#ifndef _ADTF_UCOM_ANT_OBJECT_PTR_UTILITIES_IMPLEMENTATION_HEADER_
#define _ADTF_UCOM_ANT_OBJECT_PTR_UTILITIES_IMPLEMENTATION_HEADER_
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
template<typename T>
class enable_object_ptr_from_this
{
protected:  //construction/destruction
    enable_object_ptr_from_this() = default;
    ~enable_object_ptr_from_this() = default;
    enable_object_ptr_from_this(const enable_object_ptr_from_this&) = default;
    enable_object_ptr_from_this& operator = (const enable_object_ptr_from_this&) = default;
 
public:
    object_ptr<T> object_ptr_from_this()
    {
        return m_pWeak.Lock();
    }
 
    object_ptr<const T> object_ptr_from_this() const
    {
        return m_pWeak.Lock();
    }
 
private:
    //Only make_object_ptr has access to Assign()
    template<typename Implementation, typename ...Args> friend
        typename std::enable_if
                 <
                    std::is_base_of
                    <
                        enable_object_ptr_from_this<typename std::remove_cv<Implementation>::type>,
                        typename std::remove_cv<Implementation>::type
                    >::value,
                    object_ptr<Implementation>
                 >::type
    make_object_ptr(Args&&... args);
 
    void Assign(const object_ptr<T>& i_pObject)
    {
        m_pWeak.Reset(i_pObject);
    }
 
private:    //private data
    weak_object_ptr<T>  m_pWeak;    
};//template<typename T> class enable_object_ptr_from_this
 
//#################################################################################################
//############################### Special free functions ##########################################
//#################################################################################################
template<typename T, typename U>
object_ptr<T> ucom_object_ptr_cast(const iobject_ptr<U>& i_oOther)
{
    const auto p = ucom_cast<typename object_ptr<T>::element_type*>(i_oOther.Get());
    if (nullptr != p)
    {
        return object_ptr<T>(i_oOther, p);
    }
    return object_ptr<T>();
}
 
template<typename Implementation, typename ...Args>
inline
    typename std::enable_if
    <
        !std::is_base_of
        <
            enable_object_ptr_from_this<typename std::remove_cv<Implementation>::type>,
            typename std::remove_cv<Implementation>::type
        >::value,
        object_ptr<Implementation>
    >::type
make_object_ptr(Args&&... args)
{
    return object_ptr<Implementation>(
        new (std::nothrow) Implementation(std::forward<Args>(args)...));
}
 
template<typename Implementation, typename ...Args>
inline
    typename std::enable_if
             <
                std::is_base_of
                <
                    enable_object_ptr_from_this<typename std::remove_cv<Implementation>::type>,
                    typename std::remove_cv<Implementation>::type
                >::value,
                object_ptr<Implementation>
             >::type
make_object_ptr(Args&&... args)
{
    using namespace std;    //remove_cv, forward, nothrow
    //as a workaround we need to create non const version to assign the delegate
    object_ptr<typename remove_cv<Implementation>::type> pTmp(
        new (nothrow) typename remove_cv<Implementation>::type(forward<Args>(args)...));
    if (pTmp)
    {
        auto& pEnablerTmp = static_cast<enable_object_ptr_from_this
                            <
                                typename std::remove_cv<Implementation>::type
                            >&>(*pTmp);
        pEnablerTmp.Assign(pTmp);
    }
    return pTmp;
}
 
template<
    typename T,
    typename U,
    template<typename> class TDest = iobject_ptr,
    template<typename> class TSrc = iobject_ptr>
tResult reset_object_ptr(TDest<const T>& o_oDest, const TSrc<U>& i_oSrc)
{
    //must be checked beforehand to determine error if ucom_object_ptr_cast returns empty
    if (nullptr == i_oSrc.Get())
    {   //resetting empty is not an error
        o_oDest.Reset(object_ptr<const T>());
        return ERR_NOERROR;
    }
 
    //if the subsequent call returns empty, the ucom_cast<> failed
    const auto pTmp = ucom_object_ptr_cast<const T>(i_oSrc);
    if (!pTmp)
    {   //reset empty and return error
        o_oDest.Reset(object_ptr<const T>());
        return ERR_NO_INTERFACE;
    }
 
    return o_oDest.Reset(pTmp);
}
 
template<typename T, template<typename> class TSrc = iobject_ptr>
tResult reset_object_ptr(iobject_ptr<const T>& o_oDest, const TSrc<T>& i_oSrc)
{
    const object_ptr<const T> pTmp(i_oSrc);
    return o_oDest.Reset(pTmp);
}
 
}//ns ant
 
namespace penguin
{
 
template<typename T>
ant::object_ptr<T> ucom_object_ptr_const_cast(const ant::iobject_ptr<const T>& i_oOther)
{
    const auto p = const_cast<typename ant::object_ptr<T>::element_type*>(i_oOther.Get());
    if (nullptr != p)
    {
        return ant::object_ptr<T>(i_oOther, p);
    }
    return ant::object_ptr<T>();
}
 
}
 
template<class T>
using enable_object_ptr_from_this = ant::enable_object_ptr_from_this<T>;
 
using ant::ucom_object_ptr_cast;
 
using ant::make_object_ptr;
 
using ant::reset_object_ptr;
 
using penguin::ucom_object_ptr_const_cast;
 
}//ns ucom
}//ns adtf
 
#endif //_ADTF_UCOM_ANT_OBJECT_PTR_UTILITIES_IMPLEMENTATION_HEADER_