TDelPtr.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
 
 
// ACF includes
#include <istd/istd.h>
#include <istd/TPointerBase.h>
 
 
namespace istd
{
 
 
template <class Type, class Accessor = DefaultAccessor<Type> >
class TDelPtr: public TPointerBase<Type>
{
public:
       typedef TPointerBase<Type> BaseClass;
 
       TDelPtr(Type* ptr = NULL);
 
       TDelPtr(const TDelPtr& ptr);
 
       TDelPtr(TDelPtr&& ptr);
 
       ~TDelPtr();
 
       void Reset();
 
       void SetPtr(Type* ptr);
 
       Type* PopPtr();
       void TakeOver(TDelPtr& sourcePtr);
 
       TDelPtr& operator=(const TDelPtr& ptr);
 
       TDelPtr& operator=(TDelPtr&& ptr);
 
       TDelPtr& operator=(Type* ptr);
 
       template <class SourceType>
       bool SetCastedOrRemove(SourceType* ptr)
       {
              Type* castedPtr = dynamic_cast<Type*>(ptr);
 
              SetPtr(castedPtr);
 
              if (castedPtr != NULL){
                     return true;
              }
              else{
                     if (ptr != nullptr){
                            delete ptr;
                     }
 
                     return false;
              }
       }
 
protected:
       void Detach();
};
 
 
// inline methods
 
template <class Type, class Accessor>
inline TDelPtr<Type, Accessor>::TDelPtr(Type* ptr)
:      BaseClass(ptr)
{
}
 
 
template <class Type, class Accessor>
inline TDelPtr<Type, Accessor>::TDelPtr(const TDelPtr<Type, Accessor>& I_IF_DEBUG(ptr))
:      BaseClass(NULL)
{
       I_IF_DEBUG(Q_ASSERT(ptr.GetPtr() == NULL));
}
 
 
template <class Type, class Accessor>
inline TDelPtr<Type, Accessor>::TDelPtr(TDelPtr<Type, Accessor>&& ptr)
:      BaseClass(NULL)
{
       SetPtr(ptr.PopPtr());
}
 
 
template <class Type, class Accessor>
inline TDelPtr<Type, Accessor>::~TDelPtr()
{
       TDelPtr::Detach();
}
 
 
template <class Type, class Accessor>
inline void TDelPtr<Type, Accessor>::Reset()
{
       SetPtr(NULL);
}
 
 
template <class Type, class Accessor>
inline void TDelPtr<Type, Accessor>::SetPtr(Type* ptr)
{
       Detach();
 
       BaseClass::SetPtr(ptr);
}
 
 
template <class Type, class Accessor>
inline Type* TDelPtr<Type, Accessor>::PopPtr()
{
       Type* slavePtr = BaseClass::GetPtr();
       BaseClass::SetPtr(NULL);
 
       return slavePtr;
}
 
 
template <class Type, class Accessor>
void TDelPtr<Type, Accessor>::TakeOver(TDelPtr& sourcePtr)
{
       SetPtr(sourcePtr.PopPtr());
}
 
 
// public methods
 
template <class Type, class Accessor>
TDelPtr<Type, Accessor>& TDelPtr<Type, Accessor>::operator=(const TDelPtr& I_IF_DEBUG(ptr))
{
       I_IF_DEBUG(Q_ASSERT(ptr.GetPtr() == NULL));
 
       Reset();
 
       return *this;
}
 
 
template <class Type, class Accessor>
TDelPtr<Type, Accessor>& TDelPtr<Type, Accessor>::operator=(TDelPtr&& ptr)
{
       SetPtr(ptr.PopPtr());
 
       return *this;
}
 
 
template <class Type, class Accessor>
TDelPtr<Type, Accessor>& TDelPtr<Type, Accessor>::operator=(Type* ptr)
{
       Detach();
 
       BaseClass::SetPtr(ptr);
 
       return *this;
}
 
 
// protected methods
 
template <class Type, class Accessor>
void TDelPtr<Type, Accessor>::Detach()
{
       Type* ptr = BaseClass::GetPtr();
       if (ptr == NULL){
              return;
       }
 
       Accessor::Delete(ptr);
}
 
 
} // namespace istd