From 5472be17791249ffbbb233e4db5e558fae259ff6 Mon Sep 17 00:00:00 2001
From: ChrisBenua <kpbenua@edu.hse.ru>
Date: Sat, 6 Mar 2021 14:18:02 +0300
Subject: [PATCH 1/7] completed Variant

---
 module-1/homework/Variant/tests.cpp |  16 ++-
 module-1/homework/Variant/variant.h | 182 ++++++++++++++++++++++++++--
 2 files changed, 183 insertions(+), 15 deletions(-)

diff --git a/module-1/homework/Variant/tests.cpp b/module-1/homework/Variant/tests.cpp
index a6099b36..2af47220 100644
--- a/module-1/homework/Variant/tests.cpp
+++ b/module-1/homework/Variant/tests.cpp
@@ -7,24 +7,32 @@
 
 TEST(Get, Test1) {
     variant<int, double, std::string> v;
+    //v = std::string("Hello world");
     v = "Hello world";
-    ASSERT_EQ(std::get<std::string>(v),"Hello world");
+    ASSERT_EQ(get<std::string>(v),"Hello world");
+}
+
+TEST(Get, Test1_1) {
+    variant<int, double, std::string> v;
+    v = std::string("Hello world");
+    ASSERT_EQ(get<std::string>(v),"Hello world");
 }
 
 TEST(Get, Test2) {
     variant<int, double, std::string> v;
     v = 12.0;
-    ASSERT_NEAR(std::get<double>(v), 12.0, 1e-5);
+    ASSERT_NEAR(get<double>(v), 12.0, 1e-5);
 }
 
+
 TEST(Get, Test3) {
     variant<int, double, std::string> v;
     v = "Hello world";
-    ASSERT_EQ(std::get<2>(v), "Hello world");
+    ASSERT_EQ(get<2>(v), "Hello world");
 }
 
 TEST(Get, Test4) {
     variant<int, double, std::string> v;
     v = 12.0;
-    ASSERT_NEAR(std::get<1>(v), 12.0, 1e-5);
+    ASSERT_NEAR(get<1>(v), 12.0, 1e-5);
 }
\ No newline at end of file
diff --git a/module-1/homework/Variant/variant.h b/module-1/homework/Variant/variant.h
index 8c1e2c31..c7c77e60 100644
--- a/module-1/homework/Variant/variant.h
+++ b/module-1/homework/Variant/variant.h
@@ -2,6 +2,75 @@
 
 #pragma once
 
+template <auto val>
+constexpr void static_print() {
+#if !defined(__GNUC__) || defined(__clang__)
+    int static_print_is_implemented_only_for_gcc = 0;
+#else
+    int unused = 0;
+#endif
+};
+
+template<std::size_t Index, typename... Types>
+union __union;
+
+template<std::size_t Index>
+union  __union<Index> {
+
+};
+
+struct __union_helper {
+    template<typename U>
+    static constexpr auto&& get(U&& v, std::in_place_index_t<0>) {
+        return std::forward<U>(v).head;
+    }
+
+    template<typename U, std::size_t Idx>
+    static constexpr auto&& get(U&& v, std::in_place_index_t<Idx>) {
+        return get(std::forward<U>(v).tail, std::in_place_index<Idx - 1>);
+    }
+
+    template<std::size_t Idx, typename U, std::size_t UnIdx, typename Head, typename... Tail>
+    static void set(U&& value, std::in_place_index_t<0>, __union<UnIdx, Head, Tail...>& u) {
+        if (std::is_same_v<Head, U>) {
+            u.head = value;
+        } else if (std::is_convertible_v<U, Head>) {
+            u.head = (Head)value;
+        }
+    }
+
+    template<std::size_t Idx, typename U, std::size_t UnIdx, typename Head, typename... Tail>
+    static void set(U&& value, std::in_place_index_t<Idx>, __union<UnIdx, Head, Tail...>& u) {
+        set<Idx - 1>(std::forward<U>(value), std::in_place_index<Idx - 1>, u.tail);
+    }
+};
+
+
+template<std::size_t Index, typename T, typename... Types>
+union __union<Index, T, Types...> {
+public:
+
+    T head;
+    __union<Index + 1, Types...> tail;
+
+    __union() {
+        if (!std::is_trivially_constructible_v<T>) {
+            head = T();
+        }
+    }
+
+    ~__union() {
+        if (!std::is_trivially_destructible_v<T>) {
+            head.~T();
+        }
+        if (!std::is_trivially_destructible_v<decltype(tail)>) {
+            tail.~decltype(tail)();
+        }
+    }
+
+    friend struct __union_helper;
+};
+
 template<typename... Types>
 class variant;
 
@@ -11,35 +80,126 @@ struct variant_alternative;
 template<std::size_t Idx, typename T>
 using variant_alternative_t = typename variant_alternative<Idx, T>::type;
 
-template<std::size_t Idx, class... _Types>
-struct variant_alternative<Idx, variant<_Types...>> {
-  using type =  // Your code goes here
+static constexpr int not_founded = -1;
+
+template<class From, class To>
+auto test_implicitly_convertible(int) -> decltype(
+    void(std::declval<void(&)(To)>()(std::declval<From>())), std::true_type{}
+);
+
+template<class, class>
+auto test_implicitly_convertible(...) -> std::false_type;
+
+template<class From, class To>
+struct is_implicitly_convertible : std::integral_constant<bool,
+         decltype(test_implicitly_convertible<From, To>(0))::value> {};
+
+template<std::size_t SizeofFounded>
+constexpr std::size_t find_type_pos(
+        std::size_t cur_pos,
+        const bool (&founded)[SizeofFounded],
+        const bool (&constr)[SizeofFounded]
+        ) {
+    return (cur_pos == SizeofFounded) ? not_founded :
+    ((founded[cur_pos] || constr[cur_pos]) ? cur_pos : find_type_pos(cur_pos + 1, founded, constr));
+}
+
+template<std::size_t SizeofFounded>
+constexpr std::size_t find_type_pos(
+        std::size_t cur_pos,
+        const bool (&founded)[SizeofFounded]
+) {
+    return (cur_pos == SizeofFounded) ? not_founded :
+           ((founded[cur_pos]) ? cur_pos : find_type_pos(cur_pos + 1, founded));
+}
+
+template<typename TargetType, typename... Types>
+struct find_exactly_one_checked_ {
+    constexpr static bool founded[sizeof...(Types)] = {std::is_same<TargetType, Types>::value...};
+    constexpr static bool constructible[sizeof...(Types)] = {is_implicitly_convertible<TargetType, Types>::value...};
+    constexpr static std::size_t valueForAssignment = find_type_pos(0, founded) == -1 ? find_type_pos(0, founded, constructible) : find_type_pos(0, founded);//find_type_pos(0, founded);
+    constexpr static std::size_t value = find_type_pos(0, founded);//find_type_pos(0, founded);
+};
+
+template<typename TargetType, typename... Types>
+struct find_exactly_one_t : public find_exactly_one_checked_<TargetType, Types...> {};
+
+template<typename head, typename... tail>
+struct Typelist{
+    typedef head Head;
+    typedef Typelist<tail...> Tail;
+};
+
+template<unsigned int index, class TList> struct TypeAt;
+
+template<typename Head, typename... Tail>
+struct TypeAt<0, Typelist<Head, Tail...>> {
+    typedef Head Result;
+};
+template<unsigned int i, typename Head, typename... Tail>
+struct TypeAt<i, Typelist<Head, Tail...>> {
+    typedef typename TypeAt<i - 1, Typelist<Tail...>>::Result Result;
+};
+
+template<std::size_t Idx, class... Types>
+struct variant_alternative<Idx, variant<Types...>> {
+  using type = typename TypeAt<Idx, Typelist<Types...>>::Result;// Your code goes here
 };
 
+
+template<typename T, typename... Types>
+auto&& generic_get(variant<Types...>& v) {
+    return __union_helper::get(std::forward<variant<Types...>>(v).data_, std::in_place_index<find_exactly_one_t<T, Types...>::value>);
+}
+
 template<typename... Types>
 class variant {
-
-    public:
+public:
     
     // Special member functions
     constexpr variant() noexcept;
     
     template<typename T>
     variant& operator=( T&& t ) noexcept;
-    
-    private:
+
+    template<typename T, typename... Types_> friend
+    auto&& generic_get(variant<Types_...>& v);
+private:
     // Your code goes here
+    __union<0, Types...> data_;
 };
 
+template<typename... Types>
+template<typename T>
+variant<Types...>& variant<Types...>::operator=(T&& t) noexcept {
+    constexpr auto value = find_exactly_one_t<T, Types...>::valueForAssignment;
+    static_assert(value != -1);
+    static_print<value>();
+    __union_helper::set<value>(std::forward<T>(t), std::in_place_index<value>, this->data_);
+    return *this;
+}
+
+template<typename... Types>
+constexpr variant<Types...>::variant() noexcept {};
+
+
 // Non-member functions
 template<std::size_t I, typename... Types>
-constexpr variant_alternative_t<I, variant<Types...>>& get(variant<Types...>& v);
+constexpr const variant_alternative_t<I, variant<Types...>>& get(variant<Types...>& v) {
+    return generic_get<typename TypeAt<I, Typelist<Types...>>::Result>(std::forward<decltype(v)>(v));
+}
 
 template<std::size_t I, typename... Types>
-constexpr variant_alternative_t<I, variant<Types...>>&& get(variant<Types...>&& v);
+constexpr variant_alternative_t<I, variant<Types...>>&& get(variant<Types...>&& v) {
+    return generic_get<typename TypeAt<I, Typelist<Types...>>::Result>(std::move(v));
+}
 
 template<typename T, typename... Types>
-constexpr T& get(variant<Types...>& v);
+constexpr const T& get(variant<Types...>& v) {
+    return generic_get<T>(v);
+}
 
 template<typename T, typename... Types>
-constexpr T&& get( variant<Types...>&& v );
\ No newline at end of file
+constexpr T&& get( variant<Types...>&& v ) {
+    return generic_get<T>(std::move(v));
+}
\ No newline at end of file

From 6870e6aa645bb9060766fe344b0e4b2ab8464160 Mon Sep 17 00:00:00 2001
From: ChrisBenua <kpbenua@edu.hse.ru>
Date: Sat, 6 Mar 2021 14:22:41 +0300
Subject: [PATCH 2/7] fix

---
 module-1/homework/Variant/tests.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/module-1/homework/Variant/tests.cpp b/module-1/homework/Variant/tests.cpp
index ee6f1595..df9fda53 100644
--- a/module-1/homework/Variant/tests.cpp
+++ b/module-1/homework/Variant/tests.cpp
@@ -20,20 +20,20 @@ TEST(Get, Test1_1) {
 }
 
 TEST(Get, Test2) {
-    task::variant<int, double, std::string> v;
+    variant<int, double, std::string> v;
     v = 12.0;
     ASSERT_NEAR(get<double>(v), 12.0, 1e-5);
 }
 
 
 TEST(Get, Test3) {
-    task::variant<int, double, std::string> v;
+    variant<int, double, std::string> v;
     v = "Hello world";
     ASSERT_EQ(get<2>(v), "Hello world");
 }
 
 TEST(Get, Test4) {
-    task::variant<int, double, std::string> v;
+    variant<int, double, std::string> v;
     v = 12.0;
     ASSERT_NEAR(get<1>(v), 12.0, 1e-5);
 }
\ No newline at end of file

From 9abdcba82e87ffdf28c9641288a37ff50db80ab7 Mon Sep 17 00:00:00 2001
From: ChrisBenua <kpbenua@edu.hse.ru>
Date: Sat, 6 Mar 2021 14:25:34 +0300
Subject: [PATCH 3/7] added #include <utility>

---
 module-1/homework/Variant/variant.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/module-1/homework/Variant/variant.h b/module-1/homework/Variant/variant.h
index 679e06be..9f577f8d 100644
--- a/module-1/homework/Variant/variant.h
+++ b/module-1/homework/Variant/variant.h
@@ -1,4 +1,5 @@
 #include <cstdlib>
+#include <utility>
 
 #pragma once
 

From 0758d148e92ff2c0ba43f2493e6a646b6e958f35 Mon Sep 17 00:00:00 2001
From: ChrisBenua <kpbenua@edu.hse.ru>
Date: Sat, 6 Mar 2021 14:37:26 +0300
Subject: [PATCH 4/7] fix

---
 module-1/homework/Variant/variant.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/module-1/homework/Variant/variant.h b/module-1/homework/Variant/variant.h
index 9f577f8d..def1bc20 100644
--- a/module-1/homework/Variant/variant.h
+++ b/module-1/homework/Variant/variant.h
@@ -65,7 +65,7 @@ union __union<Index, T, Types...> {
             head.~T();
         }
         if (!std::is_trivially_destructible_v<decltype(tail)>) {
-            tail.~decltype(tail)();
+            tail.~__union<Index + 1, Types...>();
         }
     }
 

From 441dbb9830522150d2f2818212f314f5f272c1a9 Mon Sep 17 00:00:00 2001
From: ChrisBenua <kpbenua@edu.hse.ru>
Date: Sat, 6 Mar 2021 14:38:50 +0300
Subject: [PATCH 5/7] fix

---
 module-1/homework/Variant/variant.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/module-1/homework/Variant/variant.h b/module-1/homework/Variant/variant.h
index def1bc20..401ad1c0 100644
--- a/module-1/homework/Variant/variant.h
+++ b/module-1/homework/Variant/variant.h
@@ -64,9 +64,6 @@ union __union<Index, T, Types...> {
         if (!std::is_trivially_destructible_v<T>) {
             head.~T();
         }
-        if (!std::is_trivially_destructible_v<decltype(tail)>) {
-            tail.~__union<Index + 1, Types...>();
-        }
     }
 
     friend struct __union_helper;

From 408327c4f9bfb48d612ef0c14326b17312ed02d5 Mon Sep 17 00:00:00 2001
From: ChrisBenua <kpbenua@edu.hse.ru>
Date: Sat, 6 Mar 2021 14:42:12 +0300
Subject: [PATCH 6/7] enhancement

---
 module-1/homework/Variant/variant.h | 35 +++++++++++------------------
 1 file changed, 13 insertions(+), 22 deletions(-)

diff --git a/module-1/homework/Variant/variant.h b/module-1/homework/Variant/variant.h
index 401ad1c0..6a65c7e2 100644
--- a/module-1/homework/Variant/variant.h
+++ b/module-1/homework/Variant/variant.h
@@ -3,14 +3,17 @@
 
 #pragma once
 
-template <auto val>
-constexpr void static_print() {
-#if !defined(__GNUC__) || defined(__clang__)
-    int static_print_is_implemented_only_for_gcc = 0;
-#else
-    int unused = 0;
-#endif
-};
+template<class From, class To>
+auto test_implicitly_convertible(int) -> decltype(
+void(std::declval<void(&)(To)>()(std::declval<From>())), std::true_type{}
+);
+
+template<class, class>
+auto test_implicitly_convertible(...) -> std::false_type;
+
+template<class From, class To>
+struct is_implicitly_convertible : std::integral_constant<bool,
+        decltype(test_implicitly_convertible<From, To>(0))::value> {};
 
 template<std::size_t Index, typename... Types>
 union __union;
@@ -35,8 +38,8 @@ struct __union_helper {
     static void set(U&& value, std::in_place_index_t<0>, __union<UnIdx, Head, Tail...>& u) {
         if (std::is_same_v<Head, U>) {
             u.head = value;
-        } else if (std::is_convertible_v<U, Head>) {
-            u.head = (Head)value;
+        } else if (is_implicitly_convertible<U, Head>::value) {
+            u.head = value;
         }
     }
 
@@ -80,17 +83,6 @@ using variant_alternative_t = typename variant_alternative<Idx, T>::type;
 
 static constexpr int not_founded = -1;
 
-template<class From, class To>
-auto test_implicitly_convertible(int) -> decltype(
-    void(std::declval<void(&)(To)>()(std::declval<From>())), std::true_type{}
-);
-
-template<class, class>
-auto test_implicitly_convertible(...) -> std::false_type;
-
-template<class From, class To>
-struct is_implicitly_convertible : std::integral_constant<bool,
-         decltype(test_implicitly_convertible<From, To>(0))::value> {};
 
 template<std::size_t SizeofFounded>
 constexpr std::size_t find_type_pos(
@@ -172,7 +164,6 @@ template<typename T>
 variant<Types...>& variant<Types...>::operator=(T&& t) noexcept {
     constexpr auto value = find_exactly_one_t<T, Types...>::valueForAssignment;
     static_assert(value != -1);
-    static_print<value>();
     __union_helper::set<value>(std::forward<T>(t), std::in_place_index<value>, this->data_);
     return *this;
 }

From f813c228da3f7a43f68bf04220de88c95e0a6ca0 Mon Sep 17 00:00:00 2001
From: ChrisBenua <kpbenua@edu.hse.ru>
Date: Sat, 6 Mar 2021 14:42:36 +0300
Subject: [PATCH 7/7] enhancement2

---
 module-1/homework/Variant/variant.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/module-1/homework/Variant/variant.h b/module-1/homework/Variant/variant.h
index 6a65c7e2..1ed7fc30 100644
--- a/module-1/homework/Variant/variant.h
+++ b/module-1/homework/Variant/variant.h
@@ -5,7 +5,7 @@
 
 template<class From, class To>
 auto test_implicitly_convertible(int) -> decltype(
-void(std::declval<void(&)(To)>()(std::declval<From>())), std::true_type{}
+    void(std::declval<void(&)(To)>()(std::declval<From>())), std::true_type{}
 );
 
 template<class, class>