TInterfacePtr.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// STL includes
#include <memory>
#include <utility>
#include <functional>
 
// Qt includes
#include <QtCore/QDebug>
 
// ACF includes
#include <istd/IPolymorphic.h>
 
 
namespace istd
{
 
 
template <class InterfaceType, class PolymorphicPointerImpl>
class TInterfacePtr
{
public:
       typedef PolymorphicPointerImpl RootObjectPtr;
       typedef std::function<InterfaceType* ()> ExtractInterfaceFunc;
 
       bool IsValid() const noexcept
       {
              return m_interfacePtr != nullptr;
       }
 
       template<typename Interface = InterfaceType>
       Interface* GetPtr() noexcept
       {
              if constexpr (std::is_same_v<Interface, InterfaceType>){
                     return m_interfacePtr;
              }
              else{
                     return dynamic_cast<Interface*>(m_interfacePtr);
              }
       }
 
       template<typename Interface = InterfaceType>
       const Interface* GetPtr() const noexcept
       {
              if constexpr (std::is_same_v<Interface, InterfaceType>){
                     return m_interfacePtr;
              }
              else{
                     return dynamic_cast<const Interface*>(m_interfacePtr);
              }
       }
 
       const InterfaceType* operator->() const noexcept
       {
              Q_ASSERT(m_interfacePtr != nullptr);
 
              return m_interfacePtr;
       }
 
       InterfaceType* operator->() noexcept
       {
              Q_ASSERT(m_interfacePtr != nullptr);
 
              return m_interfacePtr;
       }
 
       const InterfaceType& operator*() const noexcept
       {
              Q_ASSERT(m_interfacePtr != nullptr);
 
              return *m_interfacePtr;
       }
 
       InterfaceType& operator*() noexcept
       {
              Q_ASSERT(m_interfacePtr != nullptr);
 
              return *m_interfacePtr;
       }
 
       void Reset() noexcept
       {
              m_rootPtr.reset();
              m_interfacePtr = nullptr;
       }
 
       void SetPtr(InterfaceType* interfacePtr)
       {
              // Reset root with the raw pointer. This is only safe if the pointer types match.
              m_rootPtr.reset(interfacePtr);
 
              m_interfacePtr = interfacePtr;
       }
 
       void SetPtr(istd::IPolymorphic* rootPtr, const ExtractInterfaceFunc& extractInterface)
       {
              m_rootPtr.reset(rootPtr);
 
              m_interfacePtr = extractInterface();
       }
 
       void SetPtr(istd::IPolymorphic* rootPtr, InterfaceType* interfacePtr) noexcept
       {
              m_rootPtr.reset(rootPtr);
 
              m_interfacePtr = interfacePtr;
       }
 
       RootObjectPtr& GetBasePtr() noexcept
       {
              return m_rootPtr;
       }
 
       const RootObjectPtr& GetBasePtr() const noexcept
       {
              return m_rootPtr;
       }
 
       //
       // STL-like support
       //
 
       InterfaceType* get() noexcept
       {
              return GetPtr();
       }
 
       const InterfaceType* get() const noexcept
       {
              return GetPtr();
       }
 
       explicit operator bool() const noexcept
       {
              return IsValid();
       }
 
       bool operator==(std::nullptr_t) const noexcept
       {
              return !IsValid();
       }
 
       bool operator!=(std::nullptr_t) const noexcept
       {
              return IsValid();
       }
 
       TInterfacePtr& operator=(std::nullptr_t) noexcept
       {
              Reset();
 
              return *this;
       }
 
protected:
       TInterfacePtr(const TInterfacePtr&) = delete;
       TInterfacePtr& operator=(const TInterfacePtr&) = delete;
 
       TInterfacePtr() noexcept
              :m_interfacePtr(nullptr)
       {
       }
 
       TInterfacePtr(InterfaceType* interfacePtr) noexcept
              :m_interfacePtr(interfacePtr)
       {
              m_rootPtr.reset(interfacePtr);
       }
 
       TInterfacePtr(std::nullptr_t) noexcept
              :m_rootPtr(),
              m_interfacePtr(nullptr)
       {
       }
 
       TInterfacePtr(istd::IPolymorphic* rootPtr, const ExtractInterfaceFunc& extractInterface) noexcept
       {
              SetPtr(rootPtr, extractInterface);
       }
 
       TInterfacePtr(istd::IPolymorphic* rootPtr, InterfaceType* interfacePtr) noexcept
       {
              SetPtr(rootPtr, interfacePtr);
       }
 
       // Move constructor
       TInterfacePtr(TInterfacePtr&& ptr) noexcept
              :m_rootPtr(std::move(ptr.m_rootPtr)),
              m_interfacePtr(std::exchange(ptr.m_interfacePtr, nullptr))
       {
       }
 
       // Move assignment
       TInterfacePtr& operator=(TInterfacePtr&& ptr) noexcept
       {
              if (this != &ptr){
                     m_rootPtr = std::move(ptr.m_rootPtr);
                     m_interfacePtr = std::exchange(ptr.m_interfacePtr, nullptr);
              }
              return *this;
       }
 
protected:
       // invariant: both pointers are either null or valid,
       // and if valid, m_interfacePtr points to an interface implemented by the object owned by m_rootPtr
       RootObjectPtr m_rootPtr;
       InterfaceType* m_interfacePtr = nullptr;
};
 
 
template <class InterfaceType, class RootIntefaceType = istd::IPolymorphic>
class TUniqueInterfacePtr : public TInterfacePtr<InterfaceType, std::unique_ptr<RootIntefaceType>>
{
 
       template<typename U, typename R>
       friend class TUniqueInterfacePtr;
 
public:
       typedef TInterfacePtr<InterfaceType, std::unique_ptr<RootIntefaceType>> BaseClass;
       typedef typename BaseClass::ExtractInterfaceFunc ExtractInterfaceFunc;
 
       static_assert(std::is_base_of_v<istd::IPolymorphic, RootIntefaceType>,
              "RootIntefaceType must derive from istd::IPolymorphic");
       static_assert(std::has_virtual_destructor_v<RootIntefaceType>,
              "RootIntefaceType must have a virtual destructor");
       static_assert(std::is_base_of_v<RootIntefaceType, InterfaceType>,
              "InterfaceType must derive from RootIntefaceType");
 
       TUniqueInterfacePtr() noexcept
              :BaseClass()
       {
       }
 
       TUniqueInterfacePtr(InterfaceType* interfacePtr) noexcept
              :BaseClass(interfacePtr)
       {
       }
 
       template <typename T>
       TUniqueInterfacePtr(std::unique_ptr<T>&& ptr) noexcept
       {
              BaseClass::m_interfacePtr = ptr.get();
              BaseClass::m_rootPtr = std::move(ptr);
       }
 
       explicit TUniqueInterfacePtr(RootIntefaceType* rootPtr, const ExtractInterfaceFunc& extractInterface) noexcept
              :BaseClass(rootPtr, extractInterface)
       {
       }
 
       explicit TUniqueInterfacePtr(RootIntefaceType* rootPtr, InterfaceType* interfacePtr) noexcept
              :BaseClass(rootPtr, interfacePtr)
       {
       }
 
       TUniqueInterfacePtr(const TUniqueInterfacePtr& ptr) = delete;
       TUniqueInterfacePtr& operator=(const TUniqueInterfacePtr& ptr) = delete;
 
       template <typename DerivedType>
       TUniqueInterfacePtr(TUniqueInterfacePtr<DerivedType>&& ptr) noexcept
       {
              static_assert(std::is_base_of_v<InterfaceType, DerivedType>, "DerivedType must extend InterfaceType");
              BaseClass::m_rootPtr = std::move(ptr.m_rootPtr);
              BaseClass::m_interfacePtr = std::exchange(ptr.m_interfacePtr, nullptr);
       }
 
       TUniqueInterfacePtr& operator=(TUniqueInterfacePtr&& ptr) noexcept
       {
              if (this != &ptr){
                     BaseClass::m_rootPtr = std::move(ptr.m_rootPtr);
                     BaseClass::m_interfacePtr = std::exchange(ptr.m_interfacePtr, nullptr);
              }
              return *this;
       }
 
       template <typename DerivedType>
       TUniqueInterfacePtr& operator=(TUniqueInterfacePtr<DerivedType>&& ptr) noexcept
       {
              static_assert(std::is_base_of_v<InterfaceType, DerivedType>, "DerivedType must extend InterfaceType");
              static_assert(!std::is_same_v<DerivedType, InterfaceType>, "Non-templated move assignment operator overload must be used");
 
              BaseClass::m_rootPtr = std::move(ptr.m_rootPtr);
              BaseClass::m_interfacePtr = std::exchange(ptr.m_interfacePtr, nullptr);
              return *this;
       }
 
       TUniqueInterfacePtr& operator=(std::nullptr_t) noexcept
       {
              BaseClass::Reset();
              return *this;
       }
 
       RootIntefaceType* PopRootPtr() noexcept
       {
              BaseClass::m_interfacePtr = nullptr;
 
              return BaseClass::m_rootPtr.release(); // caller owns returned pointer
       }
 
       InterfaceType* PopInterfacePtr() noexcept
       {
              // Case 1: Root and interface are the same (simple objects)
              if (BaseClass::m_rootPtr.get() == BaseClass::m_interfacePtr){
                     InterfaceType* retVal = BaseClass::m_interfacePtr;
 
                     BaseClass::m_interfacePtr = nullptr;
 
                     BaseClass::m_rootPtr.release();
 
                     return retVal;
              }
              
              // Case 2: Only interface is set, no root
              if (BaseClass::m_interfacePtr != nullptr && BaseClass::m_rootPtr.get() == nullptr){
                     InterfaceType* retVal = BaseClass::m_interfacePtr;
 
                     BaseClass::m_interfacePtr = nullptr;
 
                     return retVal;
              }
              
              // Case 3: Root and interface differ (composite components)
              if (BaseClass::m_rootPtr.get() != nullptr && BaseClass::m_interfacePtr != nullptr){
                     // First check if dynamic_cast will succeed to avoid memory leak
                     InterfaceType* castedPtr = dynamic_cast<InterfaceType*>(BaseClass::m_rootPtr.get());
                     if (castedPtr != nullptr){
                            // Cast succeeded, safe to release ownership
                            RootIntefaceType* rootPtr = PopRootPtr();
                            Q_UNUSED(rootPtr);
 
                            return castedPtr;
                     }
 
                     // Cast failed - this should never happen in correct code
                     Q_ASSERT(false && "dynamic_cast failed in PopInterfacePtr - interface pointer type mismatch");
 
                     return nullptr;
              }
              
              // Empty pointer
              return nullptr;
       }
 
       InterfaceType* PopPtr() noexcept
       {
              return PopInterfacePtr();
       }
 
       void TakeOver(TUniqueInterfacePtr<InterfaceType>& from) noexcept
       {
              *this = std::move(from);
       }
 
       template<class SourceInterfaceType>
       bool MoveCastedPtr(TUniqueInterfacePtr<SourceInterfaceType>&& source) noexcept
       {
              InterfaceType* targetPtr = dynamic_cast<InterfaceType*>(source.GetPtr());
              if (targetPtr != nullptr){
                     BaseClass::m_rootPtr = std::move(source.GetBasePtr());
                     BaseClass::m_interfacePtr = targetPtr;
                     source.Reset();
                     return true;
              }
              return false;
       }
 
       template<class SourceInterfaceType>
       [[deprecated]] bool MoveCastedPtr(TUniqueInterfacePtr<SourceInterfaceType>& source) noexcept
       {
              return MoveCastedPtr(std::move(source));
       }
};
 
 
template <class InterfaceType, class RootIntefaceType = istd::IPolymorphic>
class TSharedInterfacePtr : public TInterfacePtr<InterfaceType, std::shared_ptr<RootIntefaceType>>
{
public:
       typedef TInterfacePtr<InterfaceType, std::shared_ptr<RootIntefaceType>> BaseClass;
       typedef typename BaseClass::ExtractInterfaceFunc ExtractInterfaceFunc;
 
       static_assert(std::is_base_of_v<istd::IPolymorphic, RootIntefaceType>, "RootIntefaceType must derive from istd::IPolymorphic");
       static_assert(std::has_virtual_destructor_v<RootIntefaceType>, "RootIntefaceType must have a virtual destructor");
       static_assert(std::is_base_of_v<RootIntefaceType, InterfaceType>,
              "InterfaceType must derive from RootIntefaceType");
 
       TSharedInterfacePtr() noexcept
              :BaseClass()
       {
       }
 
       TSharedInterfacePtr(InterfaceType* interfacePtr) noexcept
              :BaseClass(interfacePtr)
       {
       }
 
       TSharedInterfacePtr(RootIntefaceType* rootPtr, const ExtractInterfaceFunc& extractInterface) noexcept
              :BaseClass(rootPtr, extractInterface)
       {
       }
 
       TSharedInterfacePtr(const TSharedInterfacePtr& ptr) noexcept
       {
              BaseClass::m_rootPtr = ptr.m_rootPtr;
              BaseClass::m_interfacePtr = ptr.m_interfacePtr;
       }
 
       template <typename DerivedType>
       TSharedInterfacePtr(const TSharedInterfacePtr<DerivedType>& other) noexcept
       {
              static_assert(std::is_base_of_v<InterfaceType, DerivedType>, "DerivedType must extend InterfaceType");
              BaseClass::m_rootPtr = other.GetBasePtr();
              BaseClass::m_interfacePtr = const_cast<DerivedType*>(other.GetPtr());
       }
 
       template<typename DerivedType>
       TSharedInterfacePtr(const std::shared_ptr<DerivedType>& ptr) noexcept
       {
              static_assert(std::is_base_of_v<RootIntefaceType, InterfaceType>, "Here InterfaceType must extend RootIntefaceType");
              static_assert(std::is_base_of_v<InterfaceType, DerivedType>, "DerivedType must extend InterfaceType");
              BaseClass::m_rootPtr = ptr;
              BaseClass::m_interfacePtr = ptr.get();
       }
 
       template<typename DerivedType>
       TSharedInterfacePtr(std::unique_ptr<DerivedType>&& ptr) noexcept
       {
              static_assert(std::is_base_of_v<RootIntefaceType, InterfaceType>, "Here InterfaceType must extend RootIntefaceType");
              static_assert(std::is_base_of_v<InterfaceType, DerivedType>, "DerivedType must extend InterfaceType");
              BaseClass::m_interfacePtr = ptr.get();
              BaseClass::m_rootPtr = std::move(ptr);
       }
 
       TSharedInterfacePtr(TSharedInterfacePtr&& ptr) noexcept
       {
              BaseClass::m_rootPtr = std::move(ptr.m_rootPtr);
              BaseClass::m_interfacePtr = std::exchange(ptr.m_interfacePtr, nullptr);
       }
 
       template <typename DerivedType>
       TSharedInterfacePtr(TUniqueInterfacePtr<DerivedType>&& ptr) noexcept
       {
              FromUnique(std::move(ptr));
       }
 
       ~TSharedInterfacePtr()
       {
              Reset();
       }
 
       void Reset() noexcept
       {
              BaseClass::m_rootPtr.reset();
              BaseClass::m_interfacePtr = nullptr;
       }
 
       TSharedInterfacePtr& operator=(const TSharedInterfacePtr& ptr) noexcept
       {
              BaseClass::m_rootPtr = ptr.m_rootPtr;
              BaseClass::m_interfacePtr = ptr.m_interfacePtr;
              return *this;
       }
 
       template <typename DerivedType>
       TSharedInterfacePtr& operator=(const TSharedInterfacePtr<DerivedType>& ptr) noexcept
       {
              static_assert(std::is_base_of_v<InterfaceType, DerivedType>, "DerivedType must extend InterfaceType");
              BaseClass::m_rootPtr = ptr.GetBasePtr();
              BaseClass::m_interfacePtr = const_cast<DerivedType*>(ptr.GetPtr());
              return *this;
       }
 
       TSharedInterfacePtr& operator=(TSharedInterfacePtr&& ptr) noexcept
       {
              BaseClass::m_rootPtr = std::move(ptr.m_rootPtr);
              BaseClass::m_interfacePtr = std::exchange(ptr.m_interfacePtr, nullptr);
              return *this;
       }
 
       template<typename DerivedType>
       TSharedInterfacePtr& FromUnique(TUniqueInterfacePtr<DerivedType>&& uniquePtr) noexcept
       {
              static_assert(std::is_base_of_v<InterfaceType, DerivedType>, "DerivedType must extend InterfaceType");
 
              if (!uniquePtr.IsValid()){
                     Reset();
                     return *this;
              }
 
              BaseClass::m_interfacePtr = uniquePtr.GetPtr();
 
              // Acquire raw pointer in one step and assign to shared_ptr to avoid leaks on exceptions.
              RootIntefaceType* rawRoot = uniquePtr.PopRootPtr(); // caller (this function) now owns rawRoot
              if (rawRoot == nullptr){
                     Reset();
                     return *this;
              }
 
              // Create shared_ptr from raw pointer (shared_ptr now owns it)
              BaseClass::m_rootPtr = std::shared_ptr<RootIntefaceType>(rawRoot);
 
              return *this;
       }
 
       [[deprecated]] TSharedInterfacePtr& FromUnique(TUniqueInterfacePtr<InterfaceType>& uniquePtr) noexcept
       {
              return FromUnique(std::move(uniquePtr));
       }
 
       template <typename OtherInterface>
       static TSharedInterfacePtr CreateFromUnique(TUniqueInterfacePtr<OtherInterface>& uniquePtr) noexcept
       {
              TSharedInterfacePtr retVal;
              if (!uniquePtr.IsValid()){
                     return retVal;
              }
 
              // Try dynamic cast on the raw pointer before transferring ownership
              InterfaceType* interfacePtr = dynamic_cast<InterfaceType*>(uniquePtr.GetPtr());
              if (interfacePtr != nullptr){
                     RootIntefaceType* rawRoot = uniquePtr.PopRootPtr();
                     retVal.BaseClass::m_rootPtr = std::shared_ptr<RootIntefaceType>(rawRoot);
                     retVal.BaseClass::m_interfacePtr = interfacePtr;
              }
 
              return retVal;
       }
 
       static TSharedInterfacePtr CreateFromUnique(TUniqueInterfacePtr<InterfaceType>&& uniquePtr) noexcept
       {
              TSharedInterfacePtr retVal;
              retVal.FromUnique(std::move(uniquePtr));
              return retVal;
       }
 
       [[deprecated]] static TSharedInterfacePtr CreateFromUnique(TUniqueInterfacePtr<InterfaceType>& uniquePtr) noexcept
       {
              return CreateFromUnique(std::move(uniquePtr));
       }
 
       template<class SourceInterfaceType>
       bool MoveCastedPtr(TUniqueInterfacePtr<SourceInterfaceType>&& source) noexcept
       {
              if (!source.IsValid()){
                     Reset();
                     return true;
              }
 
              InterfaceType* targetPtr = dynamic_cast<InterfaceType*>(source.GetPtr());
              if (targetPtr != nullptr){
                     // Transfer ownership of the unique_ptr into shared_ptr safely
                     RootIntefaceType* rawRoot = source.PopRootPtr();
                     BaseClass::m_rootPtr = std::shared_ptr<RootIntefaceType>(rawRoot);
                     BaseClass::m_interfacePtr = targetPtr;
                     return true;
              }
 
              return false;
       }
 
       template<class SourceInterfaceType>
       [[deprecated]] bool MoveCastedPtr(TUniqueInterfacePtr<SourceInterfaceType>& source) noexcept
       {
              return MoveCastedPtr(std::move(source));
       }
 
       template<class SourceInterfaceType>
       bool SetCastedPtr(TSharedInterfacePtr<SourceInterfaceType>& source) noexcept
       {
              if (!source.IsValid()){
                     Reset();
                     return true;
              }
 
              InterfaceType* targetPtr = dynamic_cast<InterfaceType*>(source.GetPtr());
              if (targetPtr != nullptr){
                     BaseClass::m_rootPtr = source.GetBasePtr();
                     BaseClass::m_interfacePtr = targetPtr;
                     return true;
              }
 
              return false;
       }
 
       //
       // Qt-like support
       //
 
       template <class T>
       TSharedInterfacePtr<T> dynamicCast() noexcept
       {
              TSharedInterfacePtr<T> retVal;
              retVal.SetCastedPtr(*this);
              return retVal;
       }
 
       template <class T>
       TSharedInterfacePtr<const T> dynamicCast() const noexcept
       {
              TSharedInterfacePtr<const T> retVal;
              retVal.SetCastedPtr(const_cast<TSharedInterfacePtr&>(*this));
              return retVal;
       }
};
 
 
} // namespace istd