mn_unique_ptr.hpp

Go to the documentation of this file.

/*
*This file is part of the Mini Thread Library (https://github.com/RoseLeBlood/MiniThread ).
*Copyright (c) 2018 Amber-Sophia Schroeck
*
*The Mini Thread Library is free software; you can redistribute it and/or modify
*it under the terms of the GNU Lesser General Public License as published by
*the Free Software Foundation, version 3, or (at your option) any later version.
 
*The Mini Thread Library is distributed in the hope that it will be useful, but
*WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
*General Public License for more details.
*
*You should have received a copy of the GNU Lesser General Public
*License along with the Mini Thread  Library; if not, see
*<https://www.gnu.org/licenses/>.
*/
#ifndef __MINILIB_UNIQUE_PTR_H__
#define __MINILIB_UNIQUE_PTR_H__
 
#include "../mn_config.hpp"
 
#include "../mn_copyable.hpp"
#include "../mn_deleter.hpp"
#include "../mn_functional.hpp"
 
#include "../utils/mn_utils.hpp"
 
 
namespace mn {
    namespace pointer {
        template <typename T, class TAllocator = memory::default_allocator,
                 class TDeleter = memory::default_delete<T, TAllocator> >
        class basic_unique_ptr : public mn::only_move_tag<void> {
        public:
            using value_type = T;
            using pointer = T*;
            using const_pointer = const T*;
            using reference = T&;
            using const_reference = const T&;
            using deleter_type = TDeleter;
            using allotor_type = TAllocator;
 
            using self_type = basic_unique_ptr<value_type, allotor_type, deleter_type>;
 
            constexpr basic_unique_ptr() noexcept
                : m_ptr(nullptr), m_refDeleter(deleter_type()) { }
 
            constexpr basic_unique_ptr(nullptr_t) noexcept
                : m_ptr(nullptr), m_refDeleter(deleter_type()) { }
 
            explicit basic_unique_ptr(pointer pPointer) noexcept
                : m_ptr(pPointer), m_refDeleter(deleter_type()) { }
 
            basic_unique_ptr(pointer pPointer, deleter_type& deleter) noexcept
                : m_ptr(pPointer), m_refDeleter(deleter) { }
 
            basic_unique_ptr(pointer pPointer, const deleter_type& deleter) noexcept
                : m_ptr(pPointer), m_refDeleter(deleter) { }
 
            basic_unique_ptr(pointer pPointer, deleter_type&& deleter) noexcept
                : m_ptr(std::move(pPointer)), m_refDeleter(std::move(deleter)) { }
 
            basic_unique_ptr(self_type&& other)
                : m_ptr(other.release()), m_refDeleter(mn::forward<deleter_type>(other.get_deleter()) ) { }
 
            template<typename U, class UAllocator = memory::default_allocator,
                     class UDeleter = memory::default_delete<U, UAllocator>>
            basic_unique_ptr(basic_unique_ptr<U, UAllocator, UDeleter>&& other) noexcept
                : m_ptr(other.release()), m_refDeleter(mn::forward<deleter_type>(other.get_deleter()) ) { }
 
            ~basic_unique_ptr() noexcept {
                //deleter_type _deleter = m_mPair.second();
 
                if (m_ptr != nullptr) get_deleter()(m_ptr);
                m_ptr = nullptr;
            }
 
 
            self_type&  operator=(self_type&& other) noexcept {
                reset(other.release());
                m_refDeleter = mn::forward<deleter_type>(other.get_deleter());
                return *this;
            }
 
            template<typename U, class UAllocator = memory::default_allocator,
                     class UDeleter = memory::default_delete<U, UAllocator>>
            self_type&  operator=(basic_unique_ptr<U, UAllocator, UDeleter>&& other) noexcept {
                reset(other.release());
                m_refDeleter = mn::forward<deleter_type>(other.get_deleter());
                return *this;
            }
 
            pointer release() noexcept {
                pointer _ptr = get();
                m_ptr = pointer();
                return *this;
            }
 
            void reset(pointer pPtr) noexcept {
                mn::swap(m_ptr, pPtr);
                if (pPtr != pointer())
                    get_deleter()(pPtr);
            }
            void swap(self_type& other) noexcept {
                mn::swap(m_ptr, other.m_ptr);
                mn::swap(m_refDeleter, other.m_refDeleter);
            }
            pointer get() const noexcept {
                return m_ptr;
            }
 
            deleter_type& get_deleter() noexcept {
                return m_refDeleter;
            }
            const deleter_type& get_deleter() const noexcept {
                return m_refDeleter;
            }
 
 
            reference operator*() const {
                return *m_ptr;
            }
            pointer operator->() const noexcept {
                return m_ptr;
            }
            explicit operator bool() const noexcept {
                return m_ptr == nullptr ? false : true;
            }
        private:
            pointer m_ptr;
            deleter_type& m_refDeleter;
        };
 
        template <typename T, class TAllocator, class TDeleter >
        class basic_unique_ptr<T[], TAllocator, TDeleter> : public mn::only_move_tag<void> {
        public:
            using value_type = T;
            using pointer = T*;
            using const_pointer = const T*;
            using reference = T&;
            using const_reference = const T&;
            using deleter_type = TDeleter;
            using allotor_type = TAllocator;
 
            using self_type = basic_unique_ptr<value_type, allotor_type, deleter_type>;
 
            constexpr basic_unique_ptr() noexcept
                : m_ptr(nullptr), m_refDeleter(deleter_type()) { }
 
            constexpr basic_unique_ptr(nullptr_t) noexcept
                : m_ptr(nullptr), m_refDeleter(deleter_type()) { }
 
            explicit basic_unique_ptr(pointer pPointer) noexcept
                : m_ptr(pPointer), m_refDeleter(deleter_type()) { }
 
            basic_unique_ptr(pointer pPointer, deleter_type& deleter) noexcept
                : m_ptr(pPointer), m_refDeleter(deleter) { }
 
            basic_unique_ptr(pointer pPointer, const deleter_type& deleter) noexcept
                : m_ptr(pPointer), m_refDeleter(deleter) { }
 
            basic_unique_ptr(pointer pPointer, deleter_type&& deleter) noexcept
                : m_ptr(std::move(pPointer)), m_refDeleter(std::move(deleter)) { }
 
            basic_unique_ptr(self_type&& other)
                : m_ptr(other.release()), m_refDeleter(mn::forward<deleter_type>(other.get_deleter()) ) { }
 
            template<typename U, class UAllocator = memory::default_allocator,
                     class UDeleter = memory::default_delete<U, UAllocator>>
            basic_unique_ptr(basic_unique_ptr<U, UAllocator, UDeleter>&& other) noexcept
                : m_ptr(other.release()), m_refDeleter(mn::forward<deleter_type>(other.get_deleter()) ) { }
 
            template<typename U>
            explicit basic_unique_ptr(U* p) noexcept = delete;
            ~basic_unique_ptr() noexcept {
                //deleter_type _deleter = m_mPair.second();
 
                if (m_ptr != nullptr) get_deleter()(m_ptr);
                m_ptr = nullptr;
            }
 
 
            self_type&  operator=(self_type&& other) noexcept {
                reset(other.release());
                m_refDeleter = mn::forward<deleter_type>(other.get_deleter());
                return *this;
            }
 
            template<typename U, class UAllocator = memory::default_allocator,
                     class UDeleter = memory::default_delete<U, UAllocator>>
            self_type&  operator=(basic_unique_ptr<U, UAllocator, UDeleter>&& other) noexcept {
                reset(other.release());
                m_refDeleter = mn::forward<deleter_type>(other.get_deleter());
                return *this;
            }
 
            pointer release() noexcept {
                pointer _ptr = get();
                m_ptr = pointer();
                return *this;
            }
 
            void reset(pointer pPtr) noexcept {
                mn::swap(m_ptr, pPtr);
                if (pPtr != pointer())
                    get_deleter()(pPtr);
            }
            void swap(self_type& other) noexcept {
                mn::swap(m_ptr, other.m_ptr);
                mn::swap(m_refDeleter, other.m_refDeleter);
            }
 
            pointer get() const noexcept {
                return m_ptr;
            }
 
            deleter_type& get_deleter() noexcept {
                return m_refDeleter;
            }
            const deleter_type& get_deleter() const noexcept {
                return m_refDeleter;
            }
 
            reference operator*() const {
                return *m_ptr;
            }
            pointer operator->() const noexcept {
                return m_ptr;
            }
 
            reference operator[] (size_t pos) const {
                assert(m_ptr != nullptr);
                return m_ptr[pos];
            }
            explicit operator bool() const noexcept {
                return m_ptr == nullptr ? false : true;
            }
 
            // Disable construction from convertible pointer types.
            template<typename U>
            basic_unique_ptr(U*, const deleter_type) = delete;
 
            // Disable construction from convertible pointer types.
            template<typename U>
            basic_unique_ptr(U*, deleter_type&&) = delete;
        private:
            pointer m_ptr;
            deleter_type& m_refDeleter;
        };
 
        template<typename T, class TA, class TD>
        void swap(basic_unique_ptr<T, TA, TD>& a, basic_unique_ptr<T, TA, TD>& b) {
            a.swap(b);
        }
 
        template<typename T, class TA, class TD>
        inline bool operator == (basic_unique_ptr<T, TA, TD>& a, basic_unique_ptr<T, TA, TD>& b) {
            return a.get() == b.get();
        }
 
 
        template<typename T, class TA, class TD>
        inline bool operator != (basic_unique_ptr<T, TA, TD>& a, basic_unique_ptr<T, TA, TD>& b) {
            return a.get() != b.get();
        }
 
        template<typename T, class TA, class TD>
        inline bool operator < (basic_unique_ptr<T, TA, TD>& a, basic_unique_ptr<T, TA, TD>& b) {
            using pointer = typename basic_unique_ptr<T, TA, TD>::pointer;
            return mn::less<pointer>(a.get(), b.get());
        }
        template<typename T, class TA, class TD>
        inline bool operator > (basic_unique_ptr<T, TA, TD>& a, basic_unique_ptr<T, TA, TD>& b) {
            using pointer = typename basic_unique_ptr<T, TA, TD>::pointer;
            return mn::greater<pointer>(a.get(), b.get());
        }
 
        template<typename T, class TA, class TD>
        inline bool operator <= (basic_unique_ptr<T, TA, TD>& a, basic_unique_ptr<T, TA, TD>& b) {
            return a.get() <= b.get();
        }
 
        template<typename T, class TA, class TD>
        inline bool operator >= (basic_unique_ptr<T, TA, TD>& a, basic_unique_ptr<T, TA, TD>& b) {
            return a.get() >= b.get();
        }
 
 
        template<typename T, typename... TArgs>
        inline basic_unique_ptr<T> make_unique(TArgs&&... args) {
            return basic_unique_ptr<T>(new T(mn::forward<TArgs>(args)...));
        }
 
        template<typename T>
        inline basic_unique_ptr<T[]> make_unique(size_t siNums) {
            return basic_unique_ptr<T>(new T[siNums]() );
        }
 
        template<typename T, typename... TArgs>
        inline basic_unique_ptr<T[]> make_unique(TArgs&&...) = delete;
 
        template<typename T,
                class TAllocator = memory::default_allocator,
                class TDeleter = memory::default_delete<T, TAllocator>>
        using unique_ptr = basic_unique_ptr<T, TAllocator, TDeleter>;
    }
}
 
#endif // __MINILIB_UNIQUE_PTR_H__