TPointerBase.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
namespace istd
{
 
 
template <class Type>
class DefaultAccessor
{
public:
    static void Delete(Type* ptr)
    {
        Q_ASSERT(ptr != nullptr);
        if (ptr != nullptr){
            delete ptr;
        }
    }
};
 
 
template <class Type>
class ArrayAccessor
{
public:
    static void Delete(Type* ptr)
    {
        Q_ASSERT(ptr != nullptr);
        if (ptr != nullptr){
            delete[] ptr;
        }
    }
};
 
 
template <class Type>
class TPointerBase
{
public:
    TPointerBase(Type* ptr = nullptr);
 
    void SetPtr(Type* ptr);
 
    void Reset();
 
    Type* get() const;
    bool IsValid() const;
 
    Type& operator*() const;
 
    template <class CastedType>
    CastedType Cast() const
    {
        return dynamic_cast<CastedType>(get());
    }
 
    // 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;
    operator bool() const
    {
        return (m_ptr != nullptr);
    }
 
protected:
    // blocked operators
    TPointerBase<Type>& operator=(const TPointerBase<Type> ptr);
 
    Type*& GetPtrRef();
 
    void Swap(TPointerBase& ptr);
 
    Type* m_ptr;
};
 
 
// inline methods
 
template <class Type>
inline void TPointerBase<Type>::Reset()
{
    m_ptr = nullptr;
}
 
 
template <class Type>
inline Type* TPointerBase<Type>::get() const
{
    return m_ptr;
}
 
 
template <class Type>
inline bool TPointerBase<Type>::IsValid() const
{
    return (m_ptr != nullptr);
}
 
 
template <class Type>
inline Type& TPointerBase<Type>::operator*() const
{
    Q_ASSERT(m_ptr != nullptr);
    
    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;
}
 
 
template <class Type>
void TPointerBase<Type>::Swap(TPointerBase& ptr)
{
    std::swap(m_ptr, ptr.m_ptr);
}
 
 
} // namespace istd