object_ptr_intf.h

Go to the documentation of this file.

 
#ifndef _ADTF_UCOM_ANT_OBJECT_PTR_INTERFACE_HEADER_
#define _ADTF_UCOM_ANT_OBJECT_PTR_INTERFACE_HEADER_
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
template<typename T>
class DOEXPORT iobject_ptr_base
{
public: //types
    typedef T element_type; 
 
protected: //construction/destruction
    ~iobject_ptr_base() = default;
 
public: //observer
    virtual T*    Get() const = 0;
 
    virtual tResult Reset(const iobject_ptr<T>& i_oOther) = 0;
 
    virtual T*    operator->() const = 0;
 
private:
    template<typename>          friend class object_ptr;
    template<typename>          friend class weak_object_ptr;
    template<typename, typename>   friend class detail::delegate_object_ptr_resetter;
 
    virtual detail::iobject_ptr_ref<size_t>* GetObjPtrRef() const = 0;
};//class iobject_ptr_base<>
 
template<typename T>
class DOEXPORT iobject_ptr : public iobject_ptr_base<T>
{
protected: //construction/destruction
    ~iobject_ptr() = default;
 
public:
    typedef IObject object_type;    
                                    
    virtual operator const iobject_ptr<const T>& () const = 0;
};//class iobject_ptr<T>
 
template<typename T>
class DOEXPORT iobject_ptr<const T> : public iobject_ptr_base<const T>
{
protected: //construction/destruction
    ~iobject_ptr() = default;
 
public:
    typedef const IObject object_type;  
};//class iobject_ptr<const T>
 
//#################################################################################################
//############################### Comparison Operators ############################################
//#################################################################################################
 
template <typename T, typename U>
bool operator==(const iobject_ptr<T>& i_oLHS, const U* i_pRHS)
{
    return i_oLHS.Get() == i_pRHS;
}
 
template <typename T, typename U>
bool operator==(const T* i_pLHS, const iobject_ptr<U>& i_oRHS)
{   //call previous defined operator
    return operator==(i_oRHS, i_pLHS);
}
 
template< typename T, typename U>
bool operator!=(const iobject_ptr<T>& i_oLHS, const U* i_pRHS)
{
    return !operator==(i_oLHS, i_pRHS);
}
 
template< typename T, typename U>
bool operator!=(const T* i_pLHS, const iobject_ptr<U>& i_oRHS)
{
    return !operator==(i_pLHS, i_oRHS);
}
 
template < typename T, typename U >
bool operator==( const iobject_ptr<T>& i_oLHS, const iobject_ptr<U>& i_oRHS )
{
    return i_oLHS.Get() == i_oRHS.Get();
}
 
template< typename T, typename U >
bool operator!=( const iobject_ptr<T>& i_oLHS, const iobject_ptr<U>& i_oRHS )
{
    return !operator==(i_oLHS, i_oRHS);
}
 
template< typename T, typename U >
bool operator<( const iobject_ptr<T>& i_oLHS, const iobject_ptr<U>& i_oRHS )
{
    typedef typename std::common_type<T*, U*>::type common_pointer_type;
    return std::less<common_pointer_type>()(i_oLHS.Get(), i_oRHS.Get());
}
 
template< typename T, typename U >
bool operator>( const iobject_ptr<T>& i_oLHS, const iobject_ptr<U>& i_oRHS )
{
    return operator<(i_oRHS, i_oLHS);
}
 
template< typename T, typename U >
bool operator<=( const iobject_ptr<T>& i_oLHS, const iobject_ptr<U>& i_oRHS )
{
    return !operator>(i_oLHS, i_oRHS);
}
 
template< typename T, typename U >
bool operator>=( const iobject_ptr<T>& i_oLHS, const iobject_ptr<U>& i_oRHS )
{
    return !operator<(i_oLHS, i_oRHS);
}
 
template< typename T >
bool operator==( const iobject_ptr<T>& i_oLHS, std::nullptr_t )
{
    return !i_oLHS.Get();
}
 
template< typename T >
bool operator==( std::nullptr_t, const iobject_ptr<T>& i_oRHS )
{
    return i_oRHS == nullptr;
}
 
template< typename T >
bool operator!=( const iobject_ptr<T>& i_oLHS, std::nullptr_t )
{
    return nullptr != i_oLHS.Get();
}
 
template< typename T >
bool operator!=( std::nullptr_t, const iobject_ptr<T>& i_oRHS )
{
    return i_oRHS != nullptr;
}
 
template< typename T >
bool operator<( const iobject_ptr<T>& i_oLHS, std::nullptr_t )
{
    return std::less<T*>()(i_oLHS.Get(), nullptr);
}
 
template< typename T >
bool operator<( std::nullptr_t, const iobject_ptr<T>& i_oRHS )
{
    return std::less<T*>()(nullptr, i_oRHS.Get());
}
 
template< typename T >
bool operator<=( const iobject_ptr<T>& i_oLHS, std::nullptr_t )
{
    return !operator<(nullptr, i_oLHS);
}
 
template< typename T >
bool operator<=( std::nullptr_t, const iobject_ptr<T>& i_oRHS )
{
    return !operator<(i_oRHS, nullptr);
}
 
template< typename T >
bool operator>( const iobject_ptr<T>& i_oLHS, std::nullptr_t )
{
    return operator<(nullptr, i_oLHS);
}
 
template< typename T >
bool operator>( std::nullptr_t, const iobject_ptr<T>& i_oRHS )
{
    return operator<(i_oRHS, nullptr);
}
 
template< typename T >
bool operator>=( const iobject_ptr<T>& i_oLHS, std::nullptr_t )
{
    return !operator<(i_oLHS, nullptr);
}
 
template< typename T >
bool operator>=( std::nullptr_t, const iobject_ptr<T>& i_oRHS )
{
    return !operator<(nullptr, i_oRHS);
}
 
}//ns ant
 
template<class T>
using iobject_ptr =  ant::iobject_ptr<T>;
 
}//ns ucom
}//ns adtf
 
#endif //_ADTF_UCOM_ANT_OBJECT_PTR_INTERFACE_HEADER_