TCompPtr.h

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ImtCore-Commercial
#pragma once
 
 
// STD includes
#include <memory>
 
// ACF includes
#include <icomp/CComponentBase.h>
 
 
namespace imtbase
{
 
 
template <class InterfaceType>
class TCompPtr: protected CInterfaceManipBase
{
public:
       typedef CInterfaceManipBase BaseClass;
 
       TCompPtr();
       
       explicit TCompPtr(icomp::IComponent* pointer);
 
       bool IsValid() const;
 
       const InterfaceType* GetPtr() const;
 
       InterfaceType* GetPtr();
 
       void Reset();
 
       template <class CastedInterfaceType>
       CastedInterfaceType Cast(const QByteArray& subComponentId = QByteArray()) const
       {
              CastedInterfaceType* castedPtr = BaseClass::ExtractInterface<CastedInterfaceType>(m_ptr.data(), subComponentId);
 
              return castedPtr;
       }
 
       InterfaceType& operator*() const;
       InterfaceType* operator->() const;
       bool operator==(const TCompPtr& other) const;
 
       void SetPtr(icomp::IComponent* pointer);
 
private:
       QSharedPointer<icomp::IComponent> m_ptr;
       InterfaceType* m_interfacePtr;
};
 
 
template <class InterfaceType>
inline TCompPtr<InterfaceType>::TCompPtr()
       :m_interfacePtr(nullptr)
{
}
 
 
template <class InterfaceType>
inline TCompPtr<InterfaceType>::TCompPtr(icomp::IComponent* pointer)
{
       SetPtr(pointer);
}
 
 
 
// public methods
 
template<class InterfaceType>
inline bool TCompPtr<InterfaceType>::IsValid() const
{
       return m_impl.data() != NULL;
}
 
 
template<class InterfaceType>
inline const InterfaceType* TCompPtr<InterfaceType>::GetPtr() const
{
       return m_interfacePtr;
}
 
 
template<class InterfaceType>
inline InterfaceType* TCompPtr<InterfaceType>::GetPtr()
{
       return m_interfacePtr;
}
 
 
template<class InterfaceType>
inline void TCompPtr<InterfaceType>::Reset()
{
       m_impl.reset();
 
       m_interfacePtr = nullptr;
}
 
 
 
template<class InterfaceType>
inline InterfaceType & TCompPtr<InterfaceType>::operator*() const
{
       Q_ASSERT(m_interfacePtr != nullptr);
 
       return *m_interfacePtr;
}
 
 
template<class InterfaceType>
inline InterfaceType * TCompPtr<InterfaceType>::operator->() const
{
       return m_interfacePtr;
}
 
 
template <class InterfaceType>
inline bool TCompPtr<InterfaceType>::operator==(const TCompPtr<InterfaceType>& other) const
{
       return m_ptr == other.m_ptr;
}
 
 
template <class InterfaceType>
inline void TCompPtr<InterfaceType>::SetPtr(icomp::IComponent* pointer)
{
       InterfaceType* castedPtr = BaseClass::ExtractInterface<InterfaceType>(pointer);
       if (castedPtr != nullptr){
              m_ptr.reset(pointer);
 
              m_interfacePtr = castedPtr;
       }
}
 
 
} // namespace imtbase