Trait: introduce function visit

New function allows to call a functor on current alternative of
arbitrary variant. Actually, the function mimics `std::visit`.

Author: drewdzzz

src/Utils/Traits.hpp

@@ -87,6 +87,7 @@
 
 #include <cstddef>
 #include <iterator>
+#include <functional>
 #include <tuple>
 #include <type_traits>
 #include <variant>
@@ -554,6 +555,55 @@ constexpr bool is_variant_v =
 	!std::is_reference_v<std::remove_cv_t<T>> &&
 	details::is_variant_h<std::remove_cv_t<T>>::value;
 
+namespace details {
+/**
+ * Class that have only one static method which invokes functor on I-th
+ * alternative of variant.
+ */
+template <size_t I>
+struct VisitJumpGenerator {
+	template<class F, class V>
+	static constexpr void jump(F&& f, V&& v)
+	{
+		std::invoke(f, tnt::get<I>(v));
+	}
+};
+
+/**
+ * Jump table for visitor - i-th element of data is a method that invokes
+ * functor on i-th alternative of variant.
+ */
+template <class F, class V>
+struct VisitJumps {
+	using jump_t = void (*)(F&&, V&&);
+	using variant_t = std::remove_reference_t<V>;
+	static constexpr size_t v_size = std::variant_size_v<variant_t>;
+	using data_t = std::array<jump_t, v_size>;
+	data_t data;
+
+	template <size_t... I>
+	static constexpr data_t
+	build_by_range(tnt::iseq<I...>)
+	{
+		return {(VisitJumpGenerator<I>::jump)...};
+	}
+
+	constexpr VisitJumps() :
+		data(build_by_range(tnt::make_iseq<v_size>{})) {}
+};
+};
+
+/**
+ * Invokes the functor on current alternative of variant.
+ */
+template <class F, class V>
+void visit(F &&f, V &&v)
+{
+	static constexpr details::VisitJumps<F, V> jumps;
+	auto visitor = jumps.data[v.index()];
+	visitor(std::forward<F>(f), std::forward<V>(v));
+}
+
 /**
  * Check whether the type looks like std::optional, at least it has
  * operator bool, operator *, bool has_value() and value() methods.

test/TraitsUnitTest.cpp

@@ -1075,6 +1075,75 @@ test_common()
 	static_assert(s5.get<3>() == 3);
 }
 
+void
+test_visit()
+{
+	using variant_t = std::variant<int, bool, std::string, double>;
+
+	variant_t variant = 10;
+	size_t test_count = 0;
+	tnt::visit([&](const auto &value) {
+		using value_t = std::remove_cv_t<std::remove_reference_t<decltype(value)>>;
+		if constexpr (std::is_same_v<value_t, int>) {
+			fail_unless(value == 10);
+			test_count++;
+		}
+	}, variant);
+
+	variant = true;
+	tnt::visit([&](const auto &value) {
+		using value_t = std::remove_cv_t<std::remove_reference_t<decltype(value)>>;
+		if constexpr (std::is_same_v<value_t, bool>) {
+			fail_unless(value);
+			test_count++;
+		}
+	}, variant);
+
+	variant = std::string("abc");
+	tnt::visit([&](const auto &value) {
+		using value_t = std::remove_cv_t<std::remove_reference_t<decltype(value)>>;
+		if constexpr (std::is_same_v<value_t, std::string>) {
+			fail_unless(value == "abc");
+			test_count++;
+		}
+	}, variant);
+
+	variant = 3.0;
+	tnt::visit([&](const auto &value) {
+		using value_t = std::remove_cv_t<std::remove_reference_t<decltype(value)>>;
+		if constexpr (std::is_same_v<value_t, double>) {
+			fail_unless(value == 3.0);
+			test_count++;
+		}
+	}, variant);
+
+	/* Check if all the tests were fired. */
+	fail_unless(test_count == 4);
+
+	test_count = 0;
+	CustomVariant custom_variant;
+	custom_variant.template emplace<0>(42);
+	tnt::visit([&](const auto &value) {
+		using value_t = std::remove_cv_t<std::remove_reference_t<decltype(value)>>;
+		if constexpr (std::is_same_v<value_t, int>) {
+			fail_unless(value == 42);
+			test_count++;
+		}
+	}, custom_variant);
+
+	custom_variant.template emplace<1>(66.6);
+	tnt::visit([&](const auto &value) {
+		using value_t = std::remove_cv_t<std::remove_reference_t<decltype(value)>>;
+		if constexpr (std::is_same_v<value_t, double>) {
+			fail_unless(value == 66.6);
+			test_count++;
+		}
+	}, custom_variant);
+
+	/* Check if all the tests were fired. */
+	fail_unless(test_count == 2);
+}
+
 int main()
 {
 	test_integer_traits();
@@ -1089,4 +1158,5 @@ int main()
 	test_rw_container_traits();
 	test_is_method_callable();
 	test_common();
+	test_visit();
 }