ScopedPtr.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include <type_traits>    // for std::enable_if
#include <cstdio>
 
AST_NAMESPACE_BEGIN
 
 
template<typename T, typename = void>
struct ScopedPtrDeleter
{
    static void cleanup(T* ptr)
    {
        delete ptr;
    }
};
 
template<typename T>
struct ScopedPtrDeleter<T, typename std::enable_if<std::is_base_of<Object, T>::value>::type>
{
    static void cleanup(T* ptr)
    {
        ptr->destruct();
    }
};
 
template<>
struct ScopedPtrDeleter<std::FILE>
{
    static void cleanup(std::FILE* ptr)
    {
        fclose(ptr);
    }
};
 
template<typename T>
class ScopedPtr
{
public:
    ScopedPtr(T* ptr)
        :m_pointer{ ptr }
    { }
    ScopedPtr()
        :m_pointer{ nullptr }
    {}
    ScopedPtr(std::nullptr_t)
        :m_pointer{ nullptr }
    {
    }
    ScopedPtr(ScopedPtr&& other)
        :m_pointer{ other.m_pointer }
    {
        other.m_pointer = nullptr;
    }
    ScopedPtr& operator=(ScopedPtr&& other)
    {
        std::swap(m_pointer, other.m_pointer);
        return *this;
    }
    ScopedPtr& operator=(T* ptr)
    {
        this->reset(ptr);
        return *this;
    }
    ~ScopedPtr()
    {
        this->_delete();
    }
    void reset(T* ptr)
    {
        auto oldPtr = m_pointer;
        m_pointer = ptr;
        this->_delete(oldPtr);
    }
    T* get() const
    {
        return m_pointer;
    }
    T* operator->() const{return m_pointer;}
    operator T*() const{return m_pointer;}
    T* release()
    {
        T* ptr = m_pointer;
        m_pointer = nullptr;
        return ptr;
    }
private:
    ScopedPtr(const ScopedPtr&) = delete;
    ScopedPtr& operator =(const ScopedPtr&) = delete;
    void _delete()
    {
        this->_delete(m_pointer);
    }
    void _delete(T* ptr)
    {
        if(ptr)
            ScopedPtrDeleter<T>::cleanup(ptr);
    }
protected:
    T* m_pointer{nullptr};
};
 
AST_NAMESPACE_END