Core: Replace StackAllocation by StackArray

This will cleanup alloca usage a little bit
2017-10-14 18:04:16 +02:00
parent 333a7903ff
commit 683b09144d
6 changed files with 236 additions and 51 deletions
--- a/include/Nazara/Core/MemoryHelper.hpp
+++ b/include/Nazara/Core/MemoryHelper.hpp
@@ -23,12 +23,15 @@
 #endif

 #ifdef NAZARA_ALLOCA_SUPPORT
-	#define NazaraStackAllocation(size) Nz::StackAllocation(NAZARA_ALLOCA(size))
+	#define NazaraStackAllocation(T, size) Nz::StackArray<T>(static_cast<T*>(NAZARA_ALLOCA((size) * sizeof(T))), size)
+	#define NazaraStackAllocationNoInit(T, size) Nz::StackArray<T>(static_cast<T*>(NAZARA_ALLOCA((size) * sizeof(T))), size, Nz::NoInitTag())
 #else
-	#define NazaraStackAllocation(size) Nz::StackAllocation(Nz::OperatorNew(size))
+	#define NazaraStackAllocation(T, size) Nz::StackArray<T>(static_cast<T*>(Nz::OperatorNew((size) * sizeof(T))), size)
+	#define NazaraStackAllocationNoInit(T, size) Nz::StackArray<T>(static_cast<T*>(Nz::OperatorNew((size) * sizeof(T))), size, Nz::NoInitTag())
 #endif

 #include <cstddef>
+#include <iterator>

 namespace Nz
 {
@@ -41,19 +44,70 @@ namespace Nz
 	template<typename T>
 	void PlacementDestroy(T* ptr);

-	class StackAllocation
+	struct NoInitTag {};
+
+	template<typename T>
+	class StackArray
 	{
 		public:
-			explicit StackAllocation(void* stackMemory);
-			~StackAllocation();
+			using value_type = T;
+			using const_iterator = const value_type*;
+			using const_pointer = const value_type*;
+			using const_reference = const value_type&;
+			using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+			using difference_type = std::ptrdiff_t;
+			using iterator = value_type*;
+			using pointer = value_type*;
+			using reference = value_type&;
+			using reverse_iterator = std::reverse_iterator<iterator>;
+			using size_type = std::size_t;

-			void* GetPtr();
+			StackArray(T* stackMemory, std::size_t size);
+			StackArray(T* stackMemory, std::size_t size, NoInitTag);
+			~StackArray();

-			operator void*();
+			reference back();
+			const_reference back() const;
+
+			iterator begin() noexcept;
+			const_iterator begin() const noexcept;
+
+			const_iterator cbegin() const noexcept;
+			const_iterator cend() const noexcept;
+			const_iterator crbegin() const noexcept;
+			const_iterator crend() const noexcept;
+
+			T* data() noexcept;
+			const T* data() const noexcept;
+
+			bool empty() const noexcept;
+
+			iterator end() noexcept;
+			const_iterator end() const noexcept;
+
+			void fill(const T& value);
+
+			reference front() noexcept;
+			const_reference front() const noexcept;
+
+			size_type max_size() const noexcept;
+
+			reverse_iterator rbegin() noexcept;
+			const_reverse_iterator rbegin() const noexcept;
+
+			reverse_iterator rend() noexcept;
+			const_reverse_iterator rend() const noexcept;
+
+			size_type size() const noexcept;
+
+			reference operator[](size_type pos);
+			const_reference operator[](size_type pos) const;

 		private:
-			void* m_ptr;
+			std::size_t m_size;
+			T* m_ptr;
 	};
+
 }

 #include <Nazara/Core/MemoryHelper.inl>
--- a/include/Nazara/Core/MemoryHelper.inl
+++ b/include/Nazara/Core/MemoryHelper.inl
@@ -11,6 +11,8 @@

 #include <Nazara/Core/MemoryHelper.hpp>
 #include <Nazara/Core/MemoryManager.hpp>
+#include <algorithm>
+#include <cassert>
 #include <new>
 #include <utility>
 #include <Nazara/Core/Debug.hpp>
@@ -77,48 +79,184 @@ namespace Nz

 	/*!
 	* \ingroup core
-	* \class Nz::StackAllocation
-	* \brief Core class that represents a stack allocation
+	* \class Nz::StackArray
+	* \brief Core class that represents a stack-allocated (if alloca is present) array
 	*/

+	template<typename T>
+	StackArray<T>::StackArray(T* stackMemory, std::size_t size) :
+	m_size(size),
+	m_ptr(stackMemory)
+	{
+		for (std::size_t i = 0; i < m_size; ++i)
+			PlacementNew(&m_ptr[i]);
+	}

-	/*!
-	* \brief Constructs a StackAllocation object with a pointer to a memory allocated with NAZARA_ALLOCA or OperatorNew is alloca is not supported
-	*
-	* \param ptr Pointer to raw memory
-	*/
-	inline StackAllocation::StackAllocation(void* stackMemory) :
+	template<typename T>
+	StackArray<T>::StackArray(T* stackMemory, std::size_t size, NoInitTag) :
+	m_size(size),
 	m_ptr(stackMemory)
 	{
 	}

-	/*!
-	* \brief Destructs the object and release memory if necessary
-	*/
-	inline StackAllocation::~StackAllocation()
+	template<typename T>
+	StackArray<T>::~StackArray()
 	{
+		for (std::size_t i = 0; i < m_size; ++i)
+			m_ptr[i].~T();
+
 		#ifndef NAZARA_ALLOCA_SUPPORT
 		OperatorDelete(m_ptr);
 		#endif
 	}

-	/*!
-	* \brief Access the internal pointer
-	* \return internal memory pointer
-	*/
-	inline void* StackAllocation::GetPtr()
+	template<typename T>
+	typename StackArray<T>::reference StackArray<T>::back()
+	{
+		assert(m_size != 0);
+		return m_ptr[m_size - 1];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_reference StackArray<T>::back() const
+	{
+		assert(m_size != 0);
+		return m_ptr[m_size - 1];
+	}
+
+	template<typename T>
+	typename StackArray<T>::iterator StackArray<T>::begin() noexcept
+	{
+		return &m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::begin() const noexcept
+	{
+		return &m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::cbegin() const noexcept
+	{
+		return &m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::cend() const noexcept
+	{
+		return &m_ptr[m_size];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::crbegin() const noexcept
+	{
+		return &m_ptr[m_size];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::crend() const noexcept
+	{
+		return &m_ptr[0];
+	}
+
+	template<typename T>
+	T* StackArray<T>::data() noexcept
 	{
 		return m_ptr;
 	}

-	/*!
-	* \brief Access the internal pointer
-	* \return internal memory pointer
-	*/
-	inline StackAllocation::operator void*()
+	template<typename T>
+	const T* StackArray<T>::data() const noexcept
 	{
 		return m_ptr;
 	}
+
+	template<typename T>
+	bool StackArray<T>::empty() const noexcept
+	{
+		return m_size == 0;
+	}
+
+	template<typename T>
+	typename StackArray<T>::iterator StackArray<T>::end() noexcept
+	{
+		return &m_ptr[m_size];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_iterator StackArray<T>::end() const noexcept
+	{
+		return &m_ptr[m_size];
+	}
+
+	template<typename T>
+	void StackArray<T>::fill(const T& value)
+	{
+		std::fill(begin(), end(), value);
+	}
+
+	template<typename T>
+	typename StackArray<T>::reference StackArray<T>::front() noexcept
+	{
+		return m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_reference StackArray<T>::front() const noexcept
+	{
+		return m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::size_type StackArray<T>::max_size() const noexcept
+	{
+		return size();
+	}
+
+	template<typename T>
+	typename StackArray<T>::reverse_iterator StackArray<T>::rbegin() noexcept
+	{
+		return m_ptr[m_size];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_reverse_iterator StackArray<T>::rbegin() const noexcept
+	{
+		return m_ptr[m_size];
+	}
+
+	template<typename T>
+	typename StackArray<T>::reverse_iterator StackArray<T>::rend() noexcept
+	{
+		return m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_reverse_iterator StackArray<T>::rend() const noexcept
+	{
+		return m_ptr[0];
+	}
+
+	template<typename T>
+	typename StackArray<T>::size_type StackArray<T>::size() const noexcept
+	{
+		return m_size;
+	}
+
+	template<typename T>
+	typename StackArray<T>::reference StackArray<T>::operator[](size_type pos)
+	{
+		assert(pos < m_size);
+		return m_ptr[pos];
+	}
+
+	template<typename T>
+	typename StackArray<T>::const_reference StackArray<T>::operator[](size_type pos) const
+	{
+		assert(pos < m_size);
+		return m_ptr[pos];
+	}
 }

 #include <Nazara/Core/DebugOff.hpp>