TOptDelPtr.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
 
 
// ICF 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;
 
    typedef std::function<void (Type*)> ReleaseFn;
 
    TOptDelPtr(const TOptDelPtr& ptr) = delete;
 
    TOptDelPtr(Type* ptr = nullptr, ReleaseFn releaseFn = nullptr);
 
    TOptDelPtr(Type* ptr, bool releaseFlag);
 
    TOptDelPtr(TOptDelPtr&& ptr);
 
    TOptDelPtr(std::unique_ptr<Type>&& ptr);
 
    ~TOptDelPtr();
 
    bool IsToRelase() const;
 
    void Reset();
 
    void SetPtr(Type* ptr, ReleaseFn releaseFn = nullptr);
 
    Type* GetFreePtr() const;
 
    Type* release();
 
    void Swap(TOptDelPtr& ptr);
 
    TOptDelPtr& operator=(const TOptDelPtr& ptr);
 
    TOptDelPtr& operator=(TOptDelPtr&& ptr);
 
    TOptDelPtr& operator=(std::unique_ptr<Type>&& ptr);
    TOptDelPtr& operator=(Type* ptr);
 
    template <class SourceType>
    bool SetCastedOrRemove(SourceType* ptr, ReleaseFn releaseFn = nullptr)
    {
        Type* castedPtr = dynamic_cast<Type*>(ptr);
 
        if (castedPtr != nullptr){
            SetPtr(castedPtr, releaseFn);
 
            return true;
        }
        else {
            SetPtr(nullptr);
 
            delete ptr;
 
            return false;
        }
    }
 
    template <class SourcePtrType>
    bool SetCastedOrRemove(std::unique_ptr<SourcePtrType> ptr)
    {
        Type* castedPtr = dynamic_cast<Type*>(ptr.get());
 
        if (castedPtr != nullptr) {
            ptr.release();
            SetPtr(castedPtr, SimpleDeleter);
 
            return true;
        }
        else {
            SetPtr(nullptr);
 
            return false;
        }
    }
 
    // static methods
    static void SimpleDeleter(Type* ptr);
 
protected:
    void Detach();
 
private:
    ReleaseFn m_releaseFn;
};
 
 
// inline methods
 
template <class Type, bool DelArray>
inline TOptDelPtr<Type, DelArray>::TOptDelPtr(Type* ptr, ReleaseFn releaseFn)
:   BaseClass(ptr), m_releaseFn(releaseFn)
{
}
 
 
template <class Type, bool DelArray>
inline TOptDelPtr<Type, DelArray>::TOptDelPtr(Type* ptr, bool releaseFlag)
:   BaseClass(ptr), m_releaseFn(releaseFlag? SimpleDeleter: nullptr)
{
}
 
 
template <class Type, bool DelArray>
inline TOptDelPtr<Type, DelArray>::TOptDelPtr(TOptDelPtr&& ptr)
:   BaseClass(ptr.get()), m_releaseFn(std::move(ptr.m_releaseFn))
{
    ptr.BaseClass::SetPtr(nullptr);
}
 
 
template <class Type, bool DelArray>
inline TOptDelPtr<Type, DelArray>::TOptDelPtr(std::unique_ptr<Type>&& ptr)
:   BaseClass(ptr.release()), m_releaseFn(SimpleDeleter)
{
}
 
 
template <class Type, bool DelArray>
inline TOptDelPtr<Type, DelArray>::~TOptDelPtr()
{
    Detach();
}
 
 
template <class Type, bool DelArray>
inline void TOptDelPtr<Type, DelArray>::Reset()
{
    SetPtr(nullptr);
}
 
 
template <class Type, bool DelArray>
inline bool TOptDelPtr<Type, DelArray>::IsToRelase() const
{
    return m_releaseFn != nullptr;
}
 
 
template <class Type, bool DelArray>
inline void TOptDelPtr<Type, DelArray>::SetPtr(Type* ptr, ReleaseFn releaseFn)
{
    Detach();
 
    BaseClass::SetPtr(ptr);
 
    m_releaseFn = releaseFn;
}
 
 
template <class Type, bool DelArray>
Type* TOptDelPtr<Type, DelArray>::GetFreePtr() const
{
    if (m_releaseFn == nullptr) {
        return BaseClass::get();
    }
 
    return nullptr;
}
 
 
template <class Type, bool DelArray>
inline Type* TOptDelPtr<Type, DelArray>::release()
{
    Type* slavePtr = BaseClass::get();
 
    BaseClass::SetPtr(nullptr);
    m_releaseFn = nullptr;
 
    return slavePtr;
}
 
 
// public methods
 
template <class Type, bool DelArray>
void TOptDelPtr<Type, DelArray>::Swap(TOptDelPtr& ptr)
{
    BaseClass::Swap(ptr);
    std::swap(m_releaseFn, ptr.m_releaseFn);
}
 
 
template <class Type, bool DelArray>
TOptDelPtr<Type, DelArray>& TOptDelPtr<Type, DelArray>::operator=(const TOptDelPtr& ptr)
{
    if (ptr.m_releaseFn == nullptr){
        SetPtr(ptr.m_ptr, nullptr);
 
        return *this;
    }
 
    Q_ASSERT(ptr.m_ptr == nullptr);
 
    return *this;
}
 
 
template <class Type, bool DelArray>
TOptDelPtr<Type, DelArray>& TOptDelPtr<Type, DelArray>::operator=(TOptDelPtr&& ptr)
{
    SetPtr(ptr.m_ptr, std::move(ptr.m_releaseFn));
 
    ptr.m_releaseFn = nullptr;
    ptr.m_ptr = nullptr;
 
    return *this;
}
 
 
template <class Type, bool DelArray>
TOptDelPtr<Type, DelArray>& TOptDelPtr<Type, DelArray>::operator=(std::unique_ptr<Type>&& ptr)
{
    SetPtr(ptr.release(), SimpleDeleter);
 
    return *this;
}
 
 
template <class Type, bool DelArray>
TOptDelPtr<Type, DelArray>& TOptDelPtr<Type, DelArray>::operator=(Type* ptr)
{
    SetPtr(ptr);
 
    return *this;
}
 
 
// static methods
 
template <class Type, bool DelArray>
void TOptDelPtr<Type, DelArray>::SimpleDeleter(Type* ptr)
{
    if (DelArray) {
        delete[] ptr;
    }
    else {
        delete ptr;
    }
}
 
 
// protected methods
 
template <class Type, bool DelArray>
void TOptDelPtr<Type, DelArray>::Detach()
{
    if (m_releaseFn != nullptr){
        Type* ptr = BaseClass::get();
        if (ptr != nullptr) {
            m_releaseFn(ptr);
        }
    }
}
 
 
} // namespace istd