A few style changes, and forwarding of Aligned<T> constructors using variadic templates

Author: NickStrupat

Aligned.hpp

@@ -5,22 +5,26 @@
 #include <cstdint>
 #include <memory>
 #include <type_traits>
-#include "AlignedArrayBase.hpp"
+
 #include "AlignedBase.hpp"
+#include "AlignedArrayConstructorCaller.hpp"
+#include "AlignedArrayDestructorCaller.hpp"
 
-#define ALIGNED_BYTES_SIZE(alignment, sizeOfTPaddedToAlignment) alignment + sizeOfTPaddedToAlignment - 1
-#define ALIGNED_POINTER(T, bytes, sizeOfTPaddedToAlignment) reinterpret_cast<T *>(uintptr_t(bytes) + (sizeOfTPaddedToAlignment - 1) & ~uintptr_t(sizeOfTPaddedToAlignment - 1))
-#define ALIGNED_ARRAY_BYTES_SIZE(T, sizeOfTPaddedToAlignment, size) sizeof(T) + (sizeOfTPaddedToAlignment * size) - 1
-#define ALIGNED_ARRAY_INDEX_POINTER(T, pFirstElement, sizeOfTPaddedToAlignment, index) reinterpret_cast<T *>(uintptr_t(pFirstElement) + (sizeOfTPaddedToAlignment * index))
+#define ALIGNED_BYTES_SIZE(alignment, sizeOfTPaddedToAlignment) (alignment + sizeOfTPaddedToAlignment - 1)
+#define ALIGNED_POINTER(T, bytes, sizeOfTPaddedToAlignment) (reinterpret_cast<T *>(uintptr_t(bytes) + (sizeOfTPaddedToAlignment - 1) & ~uintptr_t(sizeOfTPaddedToAlignment - 1)))
+#define ALIGNED_ARRAY_BYTES_SIZE(T, sizeOfTPaddedToAlignment, size) (sizeof(T) + (sizeOfTPaddedToAlignment * size) - 1)
+#define ALIGNED_ARRAY_INDEX_POINTER(T, pFirstElement, sizeOfTPaddedToAlignment, index) (reinterpret_cast<T *>(uintptr_t(pFirstElement) + (sizeOfTPaddedToAlignment * index)))
 
 template<typename T, std::size_t Alignment = -1>
 class Aligned : AlignedBase<T, Alignment> {
 	uint8_t bytes[ALIGNED_BYTES_SIZE(Alignment, sizeOfTPaddedToAlignment)];
-	T * pValue;
-public:
-	Aligned(T const & value = T())
+	T * const pValue;
+	Aligned()
 		: pValue(ALIGNED_POINTER(T, bytes, sizeOfTPaddedToAlignment))
-	{ *pValue = T(value); }
+	{}
+public:
+	template<typename... Args>
+	Aligned(Args &&... args) : Aligned() { new (pValue) T(args...); }
 	~Aligned() { pValue->T::~T(); }
 	T & Ref() { return *pValue; }
 	T const & Ref() const { return *pValue; }
@@ -29,52 +33,20 @@ class Aligned : AlignedBase<T, Alignment> {
 template<typename T>
 class Aligned<T, -1> : AlignedBase<T, -1> {
 	std::unique_ptr<uint8_t[]> const pBytes;
-	T * pValue;
-public:
-	Aligned(std::size_t alignment, T const & value = T())
+	T * const pValue;
+	Aligned(std::size_t alignment)
 		: AlignedBase(alignment)
 		, pBytes(new uint8_t[ALIGNED_BYTES_SIZE(alignment, sizeOfTPaddedToAlignment)])
 		, pValue(ALIGNED_POINTER(T, pBytes.get(), sizeOfTPaddedToAlignment))
-	{ *pValue = T(value);	}
+	{}
+public:
+	template<typename... Args>
+	Aligned(std::size_t alignment, Args &&... args) : Aligned() { new (pValue) T(args...); }
 	~Aligned() { pValue->T::~T(); }
 	T & Ref() { return *pValue; }
 	T const & Ref() const { return *pValue; }
 };
 
-template<typename T, bool IsTriviallyDefaultConstructible = std::is_trivially_default_constructible<T>::value>
-class AlignedArrayConstructorCaller {
-	AlignedArrayConstructorCaller();
-public:
-	static void Call(std::size_t const, T * const, std::size_t const) {}
-};
-
-template<typename T>
-class AlignedArrayConstructorCaller<T, false> {
-	AlignedArrayConstructorCaller();
-public:
-	static void Call(std::size_t const size, T * const pFirstElement, std::size_t const sizeOfTPaddedToAlignment) {
-		for (std::size_t i = 0; i != size; ++i)
-			new (ALIGNED_ARRAY_INDEX_POINTER(T, pFirstElement, sizeOfTPaddedToAlignment, i)) T;
-	}
-};
-
-template<typename T, bool IsTriviallyDestructible = std::is_trivially_destructible<T>::value>
-class AlignedArrayDestructorCaller {
-	AlignedArrayDestructorCaller();
-public:
-	static void Call(std::size_t const, T * const, std::size_t const) {}
-};
-
-template<typename T>
-class AlignedArrayDestructorCaller<T, false> {
-	AlignedArrayDestructorCaller();
-public:
-	static void Call(std::size_t const size, T * const pFirstElement, std::size_t const sizeOfTPaddedToAlignment) {
-		for (std::size_t i = 0; i != size; ++i)
-			ALIGNED_ARRAY_INDEX_POINTER(T, pFirstElement, sizeOfTPaddedToAlignment, i)->T::~T();
-	}
-};
-
 template<typename T, std::size_t Size, std::size_t Alignment>
 class Aligned<T[Size], Alignment> : AlignedBase<T, Alignment> {
 	Aligned(Aligned const &);

AlignedArrayConstructorCaller.hpp

@@ -0,0 +1,21 @@
+#ifndef ALIGNEDARRAYCONSTRUCTORCALLER_HPP_INCLUDED
+#define ALIGNEDARRAYCONSTRUCTORCALLER_HPP_INCLUDED
+
+template<typename T, bool IsTriviallyDefaultConstructible = std::is_trivially_default_constructible<T>::value>
+class AlignedArrayConstructorCaller {
+	AlignedArrayConstructorCaller();
+public:
+	static void Call(std::size_t const, T * const, std::size_t const) {}
+};
+
+template<typename T>
+class AlignedArrayConstructorCaller<T, false> {
+	AlignedArrayConstructorCaller();
+public:
+	static void Call(std::size_t const size, T * const pFirstElement, std::size_t const sizeOfTPaddedToAlignment) {
+		for (std::size_t i = 0; i != size; ++i)
+			new (ALIGNED_ARRAY_INDEX_POINTER(T, pFirstElement, sizeOfTPaddedToAlignment, i)) T;
+	}
+};
+
+#endif

AlignedArrayDestructorCaller.hpp

@@ -0,0 +1,21 @@
+#ifndef ALIGNEDARRAYDESTRUCTORCALLER_HPP_INCLUDED
+#define ALIGNEDARRAYDESTRUCTORCALLER_HPP_INCLUDED
+
+template<typename T, bool IsTriviallyDestructible = std::is_trivially_destructible<T>::value>
+class AlignedArrayDestructorCaller {
+	AlignedArrayDestructorCaller();
+public:
+	static void Call(std::size_t const, T * const, std::size_t const) {}
+};
+
+template<typename T>
+class AlignedArrayDestructorCaller<T, false> {
+	AlignedArrayDestructorCaller();
+public:
+	static void Call(std::size_t const size, T * const pFirstElement, std::size_t const sizeOfTPaddedToAlignment) {
+		for (std::size_t i = 0; i != size; ++i)
+			ALIGNED_ARRAY_INDEX_POINTER(T, pFirstElement, sizeOfTPaddedToAlignment, i)->T::~T();
+	}
+};
+
+#endif

AlignedBase.hpp

@@ -1,5 +1,5 @@
-#ifndef ALIGNED_BASE_HPP_INCLUDED
-#define ALIGNED_BASE_HPP_INCLUDED
+#ifndef ALIGNEDBASE_HPP_INCLUDED
+#define ALIGNEDBASE_HPP_INCLUDED
 
 #include <cstddef>
 #include <exception>

CacheAligned.hpp

@@ -1,18 +1,18 @@
-#ifndef CACHE_ALIGNED_HPP_INCLUDED
-#define CACHE_ALIGNED_HPP_INCLUDED
+#ifndef CACHEALIGNED_HPP_INCLUDED
+#define CACHEALIGNED_HPP_INCLUDED
 
 #include <cstddef>
 #include "CacheAlignedBase.hpp"
 
 template<typename T>
-class CacheAligned : public Aligned<T>, CacheAlignedBase {
+class CacheAligned : public Aligned<T>, CacheAlignedBase<T> {
 public:
 	CacheAligned() : Aligned(cacheLineSize()) {}
 	CacheAligned(T const & value) : Aligned(cacheLineSize(), value) {}
 };
 
 template<typename T>
-class CacheAligned<T[]> : public Aligned<T[]>, CacheAlignedBase {
+class CacheAligned<T[]> : public Aligned<T[]>, CacheAlignedBase<T> {
 public:
 	CacheAligned(std::size_t size) : Aligned(cacheLineSize(), size) {}
 };

CacheAlignedBase.hpp

@@ -1,16 +1,23 @@
-#ifndef CACHE_ALIGNED_BASE_HPP_INCLUDED
-#define CACHE_ALIGNED_BASE_HPP_INCLUDED
+#ifndef CACHEALIGNEDBASE_HPP_INCLUDED
+#define CACHEALIGNEDBASE_HPP_INCLUDED
 
 #include <cstddef>
-#include "CacheLineSize/cacheLineSize.h"
+extern "C" {
+	#include "CacheLineSize/CacheLineSize.h"
+}
 
+template<typename T>
 class CacheAlignedBase {
 protected:
 	CacheAlignedBase() {}
-	static std::size_t cacheLineSize() {
-		static std::size_t cacheLineSize = cache_line_size();
+	static size_t cacheLineSize;
+	/*inline static std::size_t cacheLineSize() {
+		static std::size_t cacheLineSize = CacheLineSize();
 		return cacheLineSize;
-	}
+	}*/
 };
 
+template<typename T>
+size_t CacheAlignedBase::cacheLineSize(CacheLineSize());
+
 #endif

IsPowerOfTwo.hpp

@@ -1,5 +1,5 @@
-#ifndef IS_POWER_OF_TWO_HPP_INCLUDED
-#define IS_POWER_OF_TWO_HPP_INCLUDED
+#ifndef ISPOWEROFTWO_HPP_INCLUDED
+#define ISPOWEROFTWO_HPP_INCLUDED
 
 #define IS_POWER_OF_TWO(x) ((x != 0) && ((x & (x - 1)) == 0))
 

RoundUp.hpp

@@ -1,5 +1,5 @@
-#ifndef ROUND_UP_HPP_INCLUDED
-#define ROUND_UP_HPP_INCLUDED
+#ifndef ROUNDUP_HPP_INCLUDED
+#define ROUNDUP_HPP_INCLUDED
 
 #define ROUND_UP(from, to) (from + to - 1 - (from - 1) % to)