From 4faa662a59fb5fdb0cad61e256dc3b0eeb1a2409 Mon Sep 17 00:00:00 2001
From: Bananymous <bananymousosq@gmail.com>
Date: Wed, 1 Feb 2023 20:05:34 +0200
Subject: [PATCH] BAN: Rewrite Traits and add some more of them

---
 BAN/include/BAN/Move.h   | 10 +++---
 BAN/include/BAN/Traits.h | 73 +++++++++++++++++++++++++---------------
 2 files changed, 50 insertions(+), 33 deletions(-)

diff --git a/BAN/include/BAN/Move.h b/BAN/include/BAN/Move.h
index fb731b03..1890f0c5 100644
--- a/BAN/include/BAN/Move.h
+++ b/BAN/include/BAN/Move.h
@@ -6,21 +6,21 @@ namespace BAN
 {
 
 	template<typename T>
-	constexpr typename RemoveReference<T>::type&& Move(T&& arg)
+	constexpr remove_reference_t<T>&& Move(T&& arg)
 	{
-		return static_cast<typename RemoveReference<T>::type&&>(arg);
+		return static_cast<remove_reference_t<T>&&>(arg);
 	}
 
 	template<typename T>
-	constexpr T&& Forward(typename RemoveReference<T>::type& arg)
+	constexpr T&& Forward(remove_reference_t<T>& arg)
 	{
 		return static_cast<T&&>(arg);
 	}
 
 	template<typename T>
-	constexpr T&& Forward(typename RemoveReference<T>::type&& arg)
+	constexpr T&& Forward(remove_reference_t<T>&& arg)
 	{
-		static_assert(!IsLValueReference<T>::value);
+		static_assert(!is_lvalue_reference_v<T>);
 		return static_cast<T&&>(arg);
 	}
 
diff --git a/BAN/include/BAN/Traits.h b/BAN/include/BAN/Traits.h
index 28e87fea..4ca18cda 100644
--- a/BAN/include/BAN/Traits.h
+++ b/BAN/include/BAN/Traits.h
@@ -3,39 +3,56 @@
 namespace BAN
 {
 	
-	template<typename T>
-	struct RemoveReference { using type = T; };
-	template<typename T>
-	struct RemoveReference<T&> { using type =  T; };
-	template<typename T>
-	struct RemoveReference<T&&> { using type = T; };
+	template<typename T> struct remove_refenrece { using type = T; };
+	template<typename T> struct remove_refenrece<T&> { using type =  T; };
+	template<typename T> struct remove_refenrece<T&&> { using type = T; };
+	template<typename T> using remove_reference_t = typename remove_refenrece<T>::type;
 
-	template<typename T>
-	struct RemoveConst { using type = T; };
-	template<typename T>
-	struct RemoveConst<const T> { using type = T; };
+	template<typename T> struct remove_const { using type = T; };
+	template<typename T> struct remove_const<const T> { using type = T; };
+	template<typename T> using remove_const_t = typename remove_const<T>::type;
 
-	template<bool B, typename T = void>
-	struct EnableIf {};
-	template<typename T>
-	struct EnableIf<true, T> { using type = T; };
+	template<typename T> struct remove_const_and_reference { using type = remove_const_t<remove_reference_t<T>>; };
+	template<typename T> using remove_const_and_reference_t = typename remove_const_and_reference<T>::type;
 
-	template<typename T, typename S>
-	struct IsSame { static constexpr bool value = false; };
-	template<typename T>
-	struct IsSame<T, T> { static constexpr bool value = true; };
+	template<bool B, typename T = void> struct enable_if {};
+	template<typename T> struct enable_if<true, T> { using type = T; };
+	template<bool B, typename T = void> using enable_if_t = typename enable_if<B, T>::type;
 
-	template<typename T>
-	struct IsLValueReference { static constexpr bool value = false; };
-	template<typename T>
-	struct IsLValueReference<T&> { static constexpr bool value = true; };
+	template<typename T, typename S> struct is_same	{ static constexpr bool value = false; };
+	template<typename T> struct is_same<T, T>		{ static constexpr bool value = true; };
+	template<typename T, typename S> inline constexpr bool is_same_v = is_same<T, S>::value;
 
+	template<typename T> struct is_lvalue_reference		{ static constexpr bool value = false; };
+	template<typename T> struct is_lvalue_reference<T&>	{ static constexpr bool value = true; };
+	template<typename T> inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
 
-	template<typename T>
-	struct Less { constexpr bool operator()(const T& lhs, const T& rhs) const { return lhs < rhs; } };
-	template<typename T>
-	struct Equal { constexpr bool operator()(const T& lhs, const T& rhs) const { return lhs == rhs; } };
-	template<typename T>
-	struct Greater { constexpr bool operator()(const T& lhs, const T& rhs) const { return lhs > rhs; } };
+	template<typename T> struct is_integral { static constexpr bool value = 
+		is_same_v<remove_const_and_reference_t<T>, bool>
+		|| is_same_v<remove_const_and_reference_t<T>, char>
+		|| is_same_v<remove_const_and_reference_t<T>, short>
+		|| is_same_v<remove_const_and_reference_t<T>, int>
+		|| is_same_v<remove_const_and_reference_t<T>, long>
+		|| is_same_v<remove_const_and_reference_t<T>, long long>
+		|| is_same_v<remove_const_and_reference_t<T>, signed char>
+		|| is_same_v<remove_const_and_reference_t<T>, signed short>
+		|| is_same_v<remove_const_and_reference_t<T>, signed int>
+		|| is_same_v<remove_const_and_reference_t<T>, signed long>
+		|| is_same_v<remove_const_and_reference_t<T>, signed long long>
+		|| is_same_v<remove_const_and_reference_t<T>, unsigned char>
+		|| is_same_v<remove_const_and_reference_t<T>, unsigned short>
+		|| is_same_v<remove_const_and_reference_t<T>, unsigned int>
+		|| is_same_v<remove_const_and_reference_t<T>, unsigned long>
+		|| is_same_v<remove_const_and_reference_t<T>, unsigned long long>;
+	};
+	template<typename T> inline constexpr bool is_integral_v = is_integral<T>::value;
+	
+	template<typename T> struct is_pointer		{ static constexpr bool value = false; };
+	template<typename T> struct is_pointer<T*>	{ static constexpr bool value = true; };
+	template<typename T> inline constexpr bool is_pointer_v = is_pointer<T>::value;
+
+	template<typename T> struct less	{ constexpr bool operator()(const T& lhs, const T& rhs) const { return lhs < rhs; } };
+	template<typename T> struct equal	{ constexpr bool operator()(const T& lhs, const T& rhs) const { return lhs == rhs; } };
+	template<typename T> struct greater	{ constexpr bool operator()(const T& lhs, const T& rhs) const { return lhs > rhs; } };
 
 }
\ No newline at end of file