raii.h

Go to the documentation of this file.

#ifndef WXM_RAII_H
#define WXM_RAII_H
 
#include <utility>
 
namespace wxm
{
template<class T, class PTR_TYPE = T*, class CPTR_TYPE = const T*> class raii_base
{
    PTR_TYPE d_ = PTR_TYPE();
 
    raii_base(const raii_base&) = delete;
    raii_base& operator=(const raii_base&) = delete;
 
protected:
    virtual void dec(PTR_TYPE d) = 0;
    virtual void inc(PTR_TYPE d) = 0;
 
    raii_base& operator=(PTR_TYPE d)
    {
        dec(d_);
        d_ = d;
        return *this;
    }
 
    ~raii_base() = default;
 
public:
    raii_base() noexcept = default;
 
    raii_base(raii_base&& o) noexcept : d_(o.d_)
    {
        o.d_ = PTR_TYPE();
    }
 
    void swap(raii_base& o) noexcept
    {
        auto tmp = d_;
        d_ = o.d_;
        o.d_ = tmp;
    }
 
    raii_base(PTR_TYPE d) noexcept : d_(d)
    {
    }
 
    PTR_TYPE release()
    {
        auto res = d_;
        d_ = PTR_TYPE();
        return res;
    }
 
    PTR_TYPE& reset(PTR_TYPE p = PTR_TYPE())
    {
        dec(d_);
        d_ = p;
        return d_;
    }
 
    operator PTR_TYPE() noexcept
    {
        return d_;
    }
 
    operator CPTR_TYPE() const noexcept
    {
        return d_;
    }
 
    T& operator*()
    {
        return *d_;
    }
 
    const T& operator*() const
    {
        return *d_;
    }
 
    PTR_TYPE get() noexcept
    {
        return d_;
    }
 
    CPTR_TYPE get() const noexcept
    {
        return d_;
    }
};
 
template<class T> class raii_base<T, T, T>
{
    T d_ = T();
 
    raii_base(const raii_base&) = delete;
    raii_base& operator=(const raii_base&) = delete;
 
protected:
    virtual void dec(T d) = 0;
    virtual void inc(T d) = 0;
 
    raii_base& operator=(T d)
    {
        dec(d_);
        d_ = d;
        return *this;
    }
 
    ~raii_base() = default;
 
public:
    raii_base() noexcept = default;
 
    raii_base(raii_base&& o) noexcept : d_(o.d_)
    {
        o.d_ = T();
    }
 
    void swap(raii_base& o) noexcept
    {
        auto tmp = d_;
        d_ = o.d_;
        o.d_ = tmp;
    }
 
    raii_base(T d) noexcept : d_(d)
    {
    }
 
    T release()
    {
        auto res = d_;
        d_ = T();
        return res;
    }
 
    T& reset(T p = T())
    {
        dec(d_);
        d_ = p;
        return d_;
    }
 
    operator T() noexcept
    {
        return d_;
    }
 
    operator const T() const noexcept
    {
        return d_;
    }
 
    T& operator*()
    {
        return d_;
    }
 
    const T& operator*() const
    {
        return d_;
    }
 
    T get() noexcept
    {
        return d_;
    }
 
    const T get() const noexcept
    {
        return d_;
    }
};
} // namespace wxm
 
#endif