lockedobject_intf.h

Go to the documentation of this file.

 
#ifndef _ADTF_UCOM_ANT_LOCKED_OBJECT_INTERFACE_INCLUDES_HEADER_
#define _ADTF_UCOM_ANT_LOCKED_OBJECT_INTERFACE_INCLUDES_HEADER_
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
class DOEXPORT ILockedObject : public IObject
{
    public:
        ADTF_IID(ILockedObject, "lockedobject.ant.ucom.adtf.iid");
 
    public:
        virtual tResult Lock() const = 0;
        virtual tResult Unlock() const = 0;
 
    protected:
        ~ILockedObject() = default;
};
 
class DOEXPORT ISharedLockedObject : public ILockedObject
{
    public:
        ADTF_IID(ISharedLockedObject, "sharedlockedobject.ant.ucom.adtf.iid");
 
    public:
        virtual tResult LockShared() const = 0;
        virtual tResult UnlockShared() const = 0;
 
    protected:
        ~ISharedLockedObject() = default;
};
 
 
template <typename T>
class iobject_ptr_locked
{
    public:
        virtual T* Get() const = 0;
 
        virtual tResult Reset(const iobject_ptr<T>& i_oOther) = 0;
};
 
template <typename T>
class iobject_ptr_shared_locked
{
    public:
        virtual T* Get() const = 0;
        virtual tResult Reset(const iobject_ptr<T>& i_oOther) = 0;
};
 
namespace detail
{
template <typename T>
class object_ptr_locked_common
{
    protected:
        object_ptr<T> m_pObjectPtr;
 
        object_ptr_locked_common() = default;
        object_ptr_locked_common(object_ptr_locked_common&& o_oOther)
        {
            m_pObjectPtr.Swap(o_oOther.m_pObjectPtr);
        }
 
    public:
        T* operator->() const
        {
            return m_pObjectPtr.Get();
        }
 
        T& operator*() const
        {
            return *m_pObjectPtr.Get();
        }
 
        explicit operator bool() const
        {
            return static_cast<bool>(m_pObjectPtr);
        }
 
    protected:
        virtual void UnlockObject() = 0;
 
        tResult Reset(const iobject_ptr<T>& i_oOther)
        {
            Release();
            return m_pObjectPtr.Reset(i_oOther);
        }
 
        void Release()
        {
            if (m_pObjectPtr)
            {
                UnlockObject();
                m_pObjectPtr = nullptr;
            }
        }
 
        void Swap(object_ptr_locked_common& i_oOther)
        {
            m_pObjectPtr.Swap(i_oOther.m_pObjectPtr);
        }
 
        T* GetPtr() const
        {
            return m_pObjectPtr.Get();
        }
 
    private:
        object_ptr_locked_common(const object_ptr_locked_common&) = delete;
        object_ptr_locked_common& operator=(const object_ptr_locked_common&) = delete;
 
};
 
}
 
template <typename T>
class object_ptr_locked:
        public iobject_ptr_locked<T>,
        public detail::object_ptr_locked_common<T>
{
    private:
        typedef detail::object_ptr_locked_common<T> base_type;
 
    public:
        object_ptr_locked() = default;
 
        object_ptr_locked(object_ptr_locked&& o_oOther) = default;
 
        ~object_ptr_locked()
        {
            base_type::Release();
        }
 
        object_ptr_locked& operator=(object_ptr_locked&& o_oOther)
        {
            base_type::Swap(o_oOther);
            return *this;
        }
 
        object_ptr_locked& operator=(std::nullptr_t)
        {
            base_type::Release();
            return *this;
        }
 
        virtual T* Get() const
        {
            return base_type::GetPtr();;
        }
 
        virtual tResult Reset(const iobject_ptr<T>& i_oOther)
        {
            return base_type::Reset(i_oOther);
        }
 
    protected:
        void UnlockObject() override
        {
            const ILockedObject* pLockedObject = ucom_cast<const ILockedObject*>(base_type::GetPtr());
            if (pLockedObject)
            {
                pLockedObject->Unlock();
            }
        }
 
};
 
template <typename T>
class object_ptr_shared_locked:
        public iobject_ptr_shared_locked<T>,
        public detail::object_ptr_locked_common<T>
{
    private:
        typedef detail::object_ptr_locked_common<T> base_type;
 
    public:
        object_ptr_shared_locked() = default;
 
        object_ptr_shared_locked(object_ptr_shared_locked&& o_oOther) = default;
 
        ~object_ptr_shared_locked()
        {
            base_type::Release();
        }
 
        object_ptr_shared_locked& operator=(object_ptr_shared_locked&& o_oOther)
        {
            base_type::Swap(o_oOther);
            return *this;
        }
 
        object_ptr_shared_locked& operator=(std::nullptr_t)
        {
            base_type::Release();
            return *this;
        }
 
        virtual T* Get() const
        {
            return base_type::GetPtr();;
        }
 
        virtual tResult Reset(const iobject_ptr<T>& i_oOther)
        {
            return base_type::Reset(i_oOther);
        }
 
    protected:
        void UnlockObject() override
        {
            const ISharedLockedObject* pLockedObject = ucom_cast<const ISharedLockedObject*>(base_type::GetPtr());
            if (pLockedObject)
            {
                pLockedObject->UnlockShared();
            }
        }
 
};
 
}//namespace ant
 
using ant::ILockedObject;
using ant::ISharedLockedObject;
 
using ant::iobject_ptr_locked;
using ant::object_ptr_locked;
using ant::iobject_ptr_shared_locked;
using ant::object_ptr_shared_locked;
 
}//namespace ucom
}//namespace adtf
 
//*************************************************************************************************
#endif //_ADTF_UCOM_ANT_LOCKED_OBJECT_INTERFACE_INCLUDES_HEADER_