UniquePtr.h

// UniquePtr.h
//
 
namespace nkMemory
{
    template <typename T>
    class UniquePtr
    {
        public :
 
            // Constructors
            UniquePtr () noexcept ;
            UniquePtr (T* data) noexcept ;
            template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U>>>
            UniquePtr (U* data) noexcept ;
            UniquePtr (const UniquePtr<T>& other) = delete ;
            UniquePtr (UniquePtr<T>&& other) noexcept ;
            template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U>>>
            UniquePtr (UniquePtr<U>&& other) noexcept ;
 
            // Destructor
            ~UniquePtr () ;
 
        public :
 
            // Getters
            T* get () const ;
 
            bool empty () const ;
 
        public :
 
            // Management
            T* release () ;
 
            void reset (T* data = nullptr) ;
 
        public :
 
            // Operators
            T& operator* () ;
 
            const T& operator* () const ;
 
            T* operator-> () ;
 
            const T* operator-> () const ;
            
            UniquePtr<T>& operator= (const UniquePtr<T>& other) = delete ;
 
            UniquePtr<T>& operator= (UniquePtr<T>&& other) noexcept ;
 
            operator bool () const ;
 
            bool operator! () const ;
 
            operator std::unique_ptr<T> () ;
 
            template <typename U, typename = std::enable_if_t<std::is_base_of_v<U, T>>>
            operator std::unique_ptr<U> () ;
 
        public :
 
            // Templated constructors
            UniquePtr (std::unique_ptr<T> stdPtr) noexcept ;
 
            template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U>>>
            UniquePtr (std::unique_ptr<U> stdPtr) noexcept ;
    } ;
 
    // Emulation
    template <typename T, typename... Args>
    static UniquePtr<T> makeUnique (Args&&... args) ;
}