add smart_pointer_traits

add container/array
add default_deleter and add this support to list

Author: Amber-Sophia Schroeck

include/allocator/mn_basic_allocator.hpp

@@ -20,6 +20,7 @@
 
 #include "../mn_config.hpp"
 
+#include "../mn_algorithm.hpp"
 #include "../mn_functional.hpp"
 #include "../mn_typetraits.hpp"
 #include "../utils/mn_alignment.hpp"
@@ -145,8 +146,9 @@ namespace mn {
 			Type* construct(Args&&... args) {
 				auto _size = sizeof(Type);
 
-				pointer _mem = allocate(_size, mn::alignment_for(_size) );
-				return new (_mem) Type(mn::forward<Args>(args)...);
+				void* _mem = allocate(_size, mn::alignment_for(_size) );
+
+				return ::new (_mem) Type(mn::forward<Args>(args)...);
 			}
 
 			/**
@@ -160,7 +162,7 @@ namespace mn {
 
 				auto _size = sizeof(Type);
 
-				if(mn::is_class<Type>::value) address->~Type();
+				mn::destruct<Type>(address);
 				deallocate(address, _size, mn::alignment_for(_size));
 			}
 

include/allocator/mn_basic_deleter.hpp

@@ -24,35 +24,87 @@
 #include "mn_basic_allocator.hpp"
 #include "mn_allocator_typetraits.hpp"
 
+#include "../mn_functional.hpp"
+
 namespace mn {
 	namespace memory {
-		 template<typename Type, class TAllocator>
+		/**
+		 * @brief A Simple template for a deleter.
+		 * @tparam Type The type of pointer to delete.
+		 * @tparam TAllocator The using allocator for call deallocate
+		 */
+		template<typename Type, class TAllocator>
         class basic_deleter  {
         public:
 			using value_type  = Type;
 			using allocator = TAllocator;
 			using pointer = TAllocator*;
 			using reference = TAllocator&;
 
+			/**
+			 * @brief Construct a basic deleter, without a allocator
+			 * @note Atentation: call set_allocator first, otherwise the deleter not work
+			 */
 			constexpr basic_deleter() : m_refAllocator(nullptr) {}
-			constexpr basic_deleter(reference alloc) noexcept
+			/**
+			 * @brief Construt a basic deleter
+			 * @param alloc The using allocator class
+			 */
+			constexpr basic_deleter(reference alloc, size_t) noexcept
             	: m_refAllocator(&alloc) { }
 
-            reference get_allocator() {
+			/**
+			 * @brief Converting constructor.
+			 * Allows conversion from a deleter for arrays of another type, @p U,
+		 	 * only if @p U* is convertible to @p value_type*.
+			 */
+			template<typename U, typename = typename enable_if<is_convertible<U*,value_type*>::value>::type>
+			basic_deleter(const basic_deleter<U, TAllocator>& other)  noexcept
+				 : m_refAllocator(other.m_refAllocator)  { }
+
+            /**
+			 * @brief Is the deleter valid - have a allocator
+			 * @return True when the deleter valid is anh false if not.
+			 */
+			bool is_valid() const noexcept {
+				return m_refAllocator != nullptr;
+			}
+
+			/**
+			 * @brief Get a reference from the using allocator.
+			 * @return The reference from the using allocator.
+			 */
+			reference get_allocator() {
 				return *m_refAllocator;
             }
 
-            bool is_valid() const noexcept {
-				return m_refAllocator != nullptr;
-			}
+            /**
+			 * @brief Set the using allocator for delete.
+			 * @param alloc The reference of the using allocator.
+			 */
+            void set_allocator(reference alloc) noexcept {
+				m_refAllocator = &alloc;
+            }
 
-			void operator()(value_type* pointer) noexcept {
-                m_refAllocator.deallocate(pointer, sizeof(value_type), alignof(value_type));
+            /**
+			 * @brief Calls @c deallocate @p pArray
+			 */
+			void operator()(value_type* pP) noexcept {
+				static_assert(!mn::is_void<value_type>::value, "can't delete pP to incomplete type");
+				static_assert(sizeof(value_type) > 0, "can't delete pP to incomplete type");
+
+                m_refAllocator->deallocate(pP, sizeof(value_type), alignof(value_type));
             }
 		private:
 			pointer m_refAllocator;
         };
 
+        /**
+		 * @brief A Simple template for a deleter.
+		 * @tparam Type The type of pointer to delete.
+		 * @tparam TAllocator The using allocator for call deallocate
+		 * @note Specialization for arrays
+		 */
         template<typename Type, class TAllocator>
         class basic_deleter<Type[], TAllocator> {
         public:
@@ -61,25 +113,82 @@ namespace mn {
 			using pointer = TAllocator*;
 			using reference = TAllocator&;
 
+			template<typename U>
+			using remove_cv_type = typename mn::remove_cv<U>::type;
+
+			/**
+			 * @brief Like is_base_of<_Tp, _Up> but false if unqualified types are the same
+			 */
+			template<typename U>
+			using is_derived_Tp = integral_constant< bool, is_base_of<value_type, U>::value &
+			 						!(is_same<remove_cv_type<value_type>, remove_cv_type<U>>::value )>;
+
+			/**
+			 * @brief Construct a basic deleter, without a allocator
+			 * @note Atentation: call set_allocator first, otherwise the deleter not work
+			 */
 			constexpr basic_deleter() : m_refAllocator(nullptr), m_sArraySize(0u) {}
+			/**
+			 * @brief Construt a basic deleter
+			 * @param alloc The using allocator class
+			 * @param size The size of the array
+			 */
 			constexpr basic_deleter(reference alloc, size_t size) noexcept
             	: m_refAllocator(&alloc), m_sArraySize(size) { }
 
+			/**
+			 * @brief Converting constructor.
+			 * Allows conversion from a deleter for arrays of another type, @p U,
+		 	 * only if @p U* is convertible to @p value_type*.
+			 */
+			template<typename U, typename = typename enable_if<is_convertible<U*, value_type*>::value>::type>
+			basic_deleter(const basic_deleter<U[], TAllocator>& other)  noexcept
+				 : m_refAllocator(other.m_refAllocator), m_sArraySize(other.m_sArraySize)  { }
+
+			/**
+			 * @brief Is the deleter valid - have a allocator
+			 * @return True when the deleter valid is anh false if not.
+			 */
 			bool is_valid() const noexcept {
 				return m_refAllocator != nullptr;
 			}
 
+			/**
+			 * @brief Get a reference from the using allocator.
+			 * @return The reference from the using allocator.
+			 */
 			reference get_allocator() {
 				return *m_refAllocator;
             }
 
+            /**
+			 * @brief Set the using allocator for delete.
+			 * @param alloc The reference of the using allocator.
+			 */
+            void set_allocator(reference alloc) noexcept {
+				m_refAllocator = &alloc;
+            }
+
+            /**
+			 * @brief Get the size of the array.
+			 * @return The size of the array.
+			 */
             size_t get_size() const {
             	return m_sArraySize;
             }
 
-			void operator()(value_type* pointer) noexcept {
-                m_refAllocator.deallocate(pointer, m_sArraySize, sizeof(value_type), alignof(value_type));
+            /**
+			 * @brief Calls @c deallocate @p pArray
+			 */
+			void operator()(value_type* pArray) noexcept {
+				static_assert(sizeof(value_type) > 0, "can't delete pArray to incomplete type");
+                m_refAllocator->deallocate(pArray, m_sArraySize, sizeof(value_type), alignof(value_type));
             }
+
+
+            template<typename U>
+			typename enable_if<is_derived_Tp<U>::value>::type operator()(value_type*) const = delete;
+
 		private:
 			pointer m_refAllocator;
 			size_t m_sArraySize;