object_ptr_intf.h

Go to the documentation of this file.

#pragma once
 
#include <adtfucom3/interfaces/object_intf.h>
#include <a_utils/core/result.h>
 
#include <cstddef>
#include <type_traits>
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
template<typename T> class iobject_ptr;

namespace detail
{

template<typename TSize>
class DOEXPORT iobject_ptr_ref
{
protected: // types
    typedef TSize size_type;
 
protected: // construction/destruction
    ~iobject_ptr_ref() = default;
 
public:
    virtual void IncreaseUseCount() = 0;
    virtual void DecreaseUseCount() = 0;
 
    virtual void IncreaseWeakCount() = 0;
    virtual void DecreaseWeakCount() = 0;
 
    virtual bool IncreaseUseCountNonZero() = 0;
}; // class iobject_ptr_ref
 
} // namespace detail

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;
 
    virtual detail::iobject_ptr_ref<size_t>* GetObjPtrRef() const = 0;

    T& operator*() const noexcept
    {
        return *Get();
    }
 
}; // 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; 

    // GCC before 15 reports this as hidden by the unrelated conversion operators of derived
    // classes. Suppress it at the declaration, which is where the diagnostic is emitted.
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 15
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Woverloaded-virtual"
#endif
    virtual operator const iobject_ptr<const T>&() const = 0;
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 15
    #pragma GCC diagnostic pop
#endif
}; // 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);
}
 
} // namespace ant

template<class T>
using iobject_ptr = ant::iobject_ptr<T>;
 
} // namespace ucom
} // namespace adtf