TPointerBase.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
 
 
namespace istd
{
 
 
template <class Type>
class DefaultAccessor
{
public:
       static void Delete(Type* ptr)
       {
              Q_ASSERT(ptr != NULL);
              if (ptr != NULL){
                     delete ptr;
              }
       }
};
 
 
template <class Type>
class ArrayAccessor
{
public:
       static void Delete(Type* ptr)
       {
              Q_ASSERT(ptr != NULL);
              if (ptr != NULL){
                     delete[] ptr;
              }
       }
};
 
 
template <class Type>
class TPointerBase
{
public:
       TPointerBase(Type* ptr = NULL);
 
       void SetPtr(Type* ptr);
 
       void Reset();
 
       Type* GetPtr() const;
       bool IsValid() const;
 
       void Swap(TPointerBase& ptr);
 
       Type& operator*() const;
 
       template <class CastedType>
       CastedType Cast() const
       {
              return dynamic_cast<CastedType>(GetPtr());
       }
 
       // operators
       Type* operator->() const;
       bool operator==(const TPointerBase<Type>& ptr) const;
       bool operator!=(const TPointerBase<Type>& ptr) const;
       bool operator<(const TPointerBase<Type>& ptr) const;
       bool operator>(const TPointerBase<Type>& ptr) const;
       bool operator<=(const TPointerBase<Type>& ptr) const;
       bool operator>=(const TPointerBase<Type>& ptr) const;
       bool operator==(const Type* ptr) const;
       bool operator!=(const Type* ptr) const;
       bool operator<(const Type* ptr) const;
       bool operator>(const Type* ptr) const;
       bool operator<=(const Type* ptr) const;
       bool operator>=(const Type* ptr) const;
 
protected:
       // blocked operators
       TPointerBase<Type>& operator=(const TPointerBase<Type> ptr);
 
       Type*& GetPtrRef();
 
private:
       Type* m_ptr = nullptr;
};
 
 
// inline methods
 
template <class Type>
inline void TPointerBase<Type>::Reset()
{
       m_ptr = NULL;
}
 
 
template <class Type>
inline Type* TPointerBase<Type>::GetPtr() const
{
       return m_ptr;
}
 
 
template <class Type>
inline bool TPointerBase<Type>::IsValid() const
{
       return (m_ptr != NULL);
}
 
 
template <class Type>
void TPointerBase<Type>::Swap(TPointerBase& ptr)
{
       qSwap(m_ptr, ptr.m_ptr);
}
 
 
template <class Type>
inline Type& TPointerBase<Type>::operator*() const
{
       Q_ASSERT(m_ptr != NULL);
       
       return *m_ptr;
}
 
 
template <class Type>
inline Type* TPointerBase<Type>::operator->() const
{
       return m_ptr;
}
 
 
template <class Type>
inline bool TPointerBase<Type>::operator==(const TPointerBase<Type>& ptr) const
{
       return (m_ptr == ptr.m_ptr);
}
 
 
template <class Type>
inline bool TPointerBase<Type>::operator!=(const TPointerBase<Type>& ptr) const
{
       return (m_ptr != ptr.m_ptr);
}
 
 
template <class Type>
inline bool TPointerBase<Type>::operator<(const TPointerBase<Type>& ptr) const
{
       return m_ptr < ptr.m_ptr;
}
 
 
template <class Type>
inline bool TPointerBase<Type>::operator>(const TPointerBase<Type>& ptr) const
{
       return m_ptr > ptr.m_ptr;
}
 
 
template <class Type>
inline bool TPointerBase<Type>::operator<=(const TPointerBase<Type>& ptr) const
{
       return m_ptr <= ptr.m_ptr;
}
 
 
template <class Type>
inline bool TPointerBase<Type>::operator>=(const TPointerBase<Type>& ptr) const
{
       return m_ptr >= ptr.m_ptr;
}
 
 
template <class Type>
inline bool TPointerBase<Type>::operator==(const Type* ptr) const
{
       return (m_ptr == ptr);
}
 
 
template <class Type>
inline bool TPointerBase<Type>::operator!=(const Type* ptr) const
{
       return (m_ptr != ptr);
}
 
 
template <class Type>
bool TPointerBase<Type>::operator<(const Type* ptr) const
{
       return (m_ptr < ptr);
}
 
 
template <class Type>
bool TPointerBase<Type>::operator>(const Type* ptr) const
{
       return (m_ptr > ptr);
}
 
 
template <class Type>
bool TPointerBase<Type>::operator<=(const Type* ptr) const
{
       return (m_ptr <= ptr);
}
 
 
template <class Type>
bool TPointerBase<Type>::operator>=(const Type* ptr) const
{
       return (m_ptr >= ptr);
}
 
 
// protected inline methods
 
template <class Type>
inline TPointerBase<Type>::TPointerBase(Type* ptr)
{
       m_ptr = ptr;
}
 
 
template <class Type>
inline void TPointerBase<Type>::SetPtr(Type* ptr)
{
       m_ptr = ptr;
}
 
 
template <class Type>
inline TPointerBase<Type>& TPointerBase<Type>::operator=(const TPointerBase<Type> ptr)
{
       m_ptr = ptr.m_ptr;
       
       return *this;
}
 
 
template <class Type>
inline Type*& TPointerBase<Type>::GetPtrRef()
{
       return m_ptr;
}
 
 
} // namespace istd