From 06916f56be8f67bb9df5cc71073139568294c726 Mon Sep 17 00:00:00 2001
From: Bananymous <bananymousosq@gmail.com>
Date: Tue, 18 Apr 2023 19:53:34 +0300
Subject: [PATCH] BAN: Variant now works with references

References can be assigned with the set() method. Construction nor
assigment operators cannot be used with references to avoid ambiguity
with what assignment to reference does.

You can set the underlying reference with the set() method and access
it with the get() method.

The references are stored as pointers to the object under the hood
which means that size of a reference is sizeof pointer.
---
 BAN/include/BAN/Variant.h | 61 +++++++++++++++++++++++++++++----------
 1 file changed, 45 insertions(+), 16 deletions(-)

diff --git a/BAN/include/BAN/Variant.h b/BAN/include/BAN/Variant.h
index 423342a0..0522f9fe 100644
--- a/BAN/include/BAN/Variant.h
+++ b/BAN/include/BAN/Variant.h
@@ -11,14 +11,19 @@ namespace BAN
 	{
 
 		template<typename T>
-		constexpr size_t max_size() { return sizeof(T); }
-		template<typename T0, typename T1, typename... Ts>
-		constexpr size_t max_size() { return sizeof(T0) > sizeof(T1) ? max_size<T0, Ts...>() : max_size<T1, Ts...>(); }
+		constexpr size_t size_ref_as_ptr() { return is_lvalue_reference_v<T> ? sizeof(remove_reference_t<T>*) : sizeof(T); }
+		template<typename T>
+		constexpr size_t align_ref_as_ptr() { return is_lvalue_reference_v<T> ? alignof(remove_reference_t<T>*) : alignof(T); }
 
 		template<typename T>
-		constexpr size_t max_align() { return alignof(T); }
+		constexpr size_t max_size_ref_as_ptr() { return size_ref_as_ptr<T>(); }
 		template<typename T0, typename T1, typename... Ts>
-		constexpr size_t max_align() { return alignof(T0) > alignof(T1) ? max_align<T0, Ts...>() : max_align<T1, Ts...>(); }
+		constexpr size_t max_size_ref_as_ptr() { return size_ref_as_ptr<T0>() > size_ref_as_ptr<T1>() ? max_size_ref_as_ptr<T0, Ts...>() : max_size_ref_as_ptr<T1, Ts...>(); }
+
+		template<typename T>
+		constexpr size_t max_align_ref_as_ptr() { return align_ref_as_ptr<T>(); }
+		template<typename T0, typename T1, typename... Ts>
+		constexpr size_t max_align_ref_as_ptr() { return align_ref_as_ptr<T0>() > align_ref_as_ptr<T1>() ? max_align_ref_as_ptr<T0, Ts...>() : max_align_ref_as_ptr<T1, Ts...>(); }
 
 		template<typename T, typename T0, typename... Ts>
 		constexpr size_t index()
@@ -35,7 +40,9 @@ namespace BAN
 		void destruct(size_t index, uint8_t* data)
 		{
 			if (index == 0)
-				reinterpret_cast<T*>(data)->~T();
+				if constexpr(!is_lvalue_reference_v<T>)
+					reinterpret_cast<T*>(data)->~T();
+				else;
 			else if constexpr(sizeof...(Ts) > 0)
 				destruct<Ts...>(index - 1, data);
 			else
@@ -89,7 +96,7 @@ namespace BAN
 	}
 
 	template<typename... Ts>
-		requires (!is_lvalue_reference_v<Ts> && ...)
+		requires (!is_const_v<Ts> && ...)
 	class Variant
 	{
 	private:
@@ -114,14 +121,14 @@ namespace BAN
 		}
 
 		template<typename T>
-		Variant(T&& value) requires (can_have<T>())
+		Variant(T&& value) requires (can_have<T>() && !is_lvalue_reference_v<T>)
 			: m_index(detail::index<T, Ts...>())
 		{
 			new (m_storage) T(move(value));	
 		}
 
 		template<typename T>
-		Variant(const T& value) requires (can_have<T>())
+		Variant(const T& value) requires (can_have<T>() && !is_lvalue_reference_v<T>)
 			: m_index(detail::index<T, Ts...>())
 		{
 			new (m_storage) T(value);	
@@ -164,14 +171,14 @@ namespace BAN
 		}
 
 		template<typename T>
-		Variant& operator=(T&& value) requires (can_have<T>())
+		Variant& operator=(T&& value) requires (can_have<T>() && !is_lvalue_reference_v<T>)
 		{
 			*this = Variant(move(value));
 			return *this;
 		}
 
 		template<typename T>
-		Variant& operator=(const T& value) requires (can_have<T>())
+		Variant& operator=(const T& value) requires (can_have<T>() && !is_lvalue_reference_v<T>)
 		{
 			*this = Variant(value);
 			return *this;
@@ -184,7 +191,7 @@ namespace BAN
 		}
 
 		template<typename T>
-		void set(T&& value) requires (can_have<T>())
+		void set(T&& value) requires (can_have<T>() && !is_lvalue_reference_v<T>)
 		{
 			if (has<T>())
 				get<T>() = move(value);
@@ -197,7 +204,7 @@ namespace BAN
 		}
 
 		template<typename T>
-		void set(const T& value) requires (can_have<T>())
+		void set(const T& value) requires (can_have<T>() && !is_lvalue_reference_v<T>)
 		{
 			if (has<T>())
 				get<T>() = value;
@@ -210,19 +217,41 @@ namespace BAN
 		}
 
 		template<typename T>
-		T& get() requires (can_have<T>())
+		void set(T value) requires (can_have<T>() && is_lvalue_reference_v<T>)
+		{
+			clear();
+			m_index = detail::index<T, Ts...>();
+			*reinterpret_cast<remove_reference_t<T>**>(m_storage) = &value;
+		}
+
+		template<typename T>
+		T& get() requires (can_have<T>() && !is_lvalue_reference_v<T>)
 		{
 			ASSERT(has<T>());
 			return *reinterpret_cast<T*>(m_storage);
 		}
 
 		template<typename T>
-		const T& get() const requires (can_have<T>())
+		const T& get() const requires (can_have<T>() && !is_lvalue_reference_v<T>)
 		{
 			ASSERT(has<T>());
 			return *reinterpret_cast<const T*>(m_storage);
 		}
 
+		template<typename T>
+		T get() requires (can_have<T>() && is_lvalue_reference_v<T>)
+		{
+			ASSERT(has<T>());
+			return **reinterpret_cast<remove_reference_t<T>**>(m_storage);
+		}
+
+		template<typename T>
+		const T get() const requires (can_have<T>() && is_lvalue_reference_v<T>)
+		{
+			ASSERT(has<T>());
+			return **reinterpret_cast<const remove_reference_t<T>**>(m_storage);
+		}
+
 		void clear()
 		{
 			if (m_index != invalid_index())
@@ -233,7 +262,7 @@ namespace BAN
 		}
 
 	private:
-		alignas(detail::max_align<Ts...>()) uint8_t m_storage[detail::max_size<Ts...>()] {};
+		alignas(detail::max_align_ref_as_ptr<Ts...>()) uint8_t m_storage[detail::max_size_ref_as_ptr<Ts...>()] {};
 		size_t m_index { invalid_index() };
 	};