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)
        :pointer_{ ptr }
    { }
    ScopedPtr()
        :pointer_{ nullptr }
    {}
    ScopedPtr(std::nullptr_t)
        :pointer_{ nullptr }
    {
    }
    ScopedPtr(ScopedPtr&& other)
        :pointer_{ other.pointer_ }
    {
        other.pointer_ = nullptr;
    }
    ScopedPtr& operator=(ScopedPtr&& other)
    {
        std::swap(pointer_, other.pointer_);
        return *this;
    }
    ScopedPtr& operator=(T* ptr)
    {
        this->reset(ptr);
        return *this;
    }
    ~ScopedPtr()
    {
        this->_delete();
    }
    void reset(T* ptr)
    {
        auto oldPtr = pointer_;
        pointer_ = ptr;
        this->_delete(oldPtr);
    }
    void reset()
    {
        this->reset(nullptr);
    }
    T* get() const
    {
        return pointer_;
    }
    T* operator->() const{return pointer_;}
    operator T*() const{return pointer_;}
 
    T* release()
    {
        T* ptr = pointer_;
        pointer_ = nullptr;
        return ptr;
    }
private:
    ScopedPtr(const ScopedPtr&) = delete;
    ScopedPtr& operator =(const ScopedPtr&) = delete;
    void _delete()
    {
        this->_delete(pointer_);
    }
    void _delete(T* ptr)
    {
        if(ptr)
            ScopedPtrDeleter<T>::cleanup(ptr);
    }
protected:
    T* pointer_{nullptr};
};
 
AST_NAMESPACE_END