TOptDelPtr.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, bool DelArray = false>
class TOptDelPtr: public TPointerBase<Type>
{
public:
       typedef TPointerBase<Type> BaseClass;
 
       TOptDelPtr(Type* ptr = NULL, bool releaseFlag = false);
 
       TOptDelPtr(const TOptDelPtr& ptr);
 
       ~TOptDelPtr();
 
       bool IsToRelase() const;
 
       void Reset();
 
       void SetPtr(Type* ptr, bool releaseFlag = false);
 
       Type* PopPtr();
       void TakeOver(TOptDelPtr& sourcePtr);
 
       TOptDelPtr& operator=(const TOptDelPtr& ptr);
       TOptDelPtr& operator=(Type* ptr);
 
       template <class SourceType>
       bool SetCastedOrRemove(SourceType* ptr, bool releaseFlag = false)
       {
              Type* castedPtr = dynamic_cast<Type*>(ptr);
 
              SetPtr(castedPtr, releaseFlag);
 
              if (castedPtr != NULL){
                     return true;
              }
              else if (releaseFlag && (ptr != nullptr)){
                     delete ptr;
              }
 
              return false;
       }
 
protected:
       void Detach();
 
private:
       bool m_releaseFlag = false;
};
 
 
// inline methods
 
template <class Type, bool DelArray>
inline TOptDelPtr<Type, DelArray>::TOptDelPtr(Type* ptr, bool releaseFlag)
:      BaseClass(ptr), m_releaseFlag(releaseFlag)
{
}
 
 
template <class Type, bool DelArray>
inline TOptDelPtr<Type, DelArray>::TOptDelPtr(const TOptDelPtr<Type, DelArray>& ptr)
:      BaseClass(NULL), m_releaseFlag(false)
{
       if (!ptr.m_releaseFlag){
              SetPtr(ptr.GetPtr(), false);
 
              return;
       }
 
       Q_ASSERT(ptr.GetPtr() == NULL);
}
 
 
template <class Type, bool DelArray>
inline TOptDelPtr<Type, DelArray>::~TOptDelPtr()
{
       Detach();
}
 
 
template <class Type, bool DelArray>
inline void TOptDelPtr<Type, DelArray>::Reset()
{
       SetPtr(NULL);
}
 
 
template <class Type, bool DelArray>
inline bool TOptDelPtr<Type, DelArray>::IsToRelase() const
{
       return m_releaseFlag;
}
 
 
template <class Type, bool DelArray>
inline void TOptDelPtr<Type, DelArray>::SetPtr(Type* ptr, bool releaseFlag)
{
       Detach();
 
       BaseClass::SetPtr(ptr);
 
       m_releaseFlag = releaseFlag;
}
 
 
template <class Type, bool DelArray>
inline Type* TOptDelPtr<Type, DelArray>::PopPtr()
{
       Type* slavePtr = BaseClass::GetPtr();
       BaseClass::SetPtr(NULL);
 
       return slavePtr;
}
 
 
template <class Type, bool DelArray>
void TOptDelPtr<Type, DelArray>::TakeOver(TOptDelPtr& sourcePtr)
{
       SetPtr(sourcePtr.PopPtr(), sourcePtr.IsToRelase());
}
 
 
// public methods
 
template <class Type, bool DelArray>
TOptDelPtr<Type, DelArray>& TOptDelPtr<Type, DelArray>::operator=(const TOptDelPtr& I_IF_DEBUG(ptr))
{
       if (m_releaseFlag){
              I_IF_DEBUG(Q_ASSERT(ptr.GetPtr() == NULL));
       }
 
       Reset();
 
       return *this;
}
 
 
template <class Type, bool DelArray>
TOptDelPtr<Type, DelArray>& TOptDelPtr<Type, DelArray>::operator=(Type* ptr)
{
       Detach();
 
       BaseClass::SetPtr(ptr);
 
       return *this;
}
 
 
// protected methods
 
template <class Type, bool DelArray>
void TOptDelPtr<Type, DelArray>::Detach()
{
       if (m_releaseFlag){
              Type* ptr = BaseClass::GetPtr();
              if (ptr == NULL){
                     return;
              }
 
              if (DelArray){
                     delete[] ptr;
              }
              else{
                     delete ptr;
              }
       }
}
 
 
} // namespace istd