From 8efeb15c9f3f0ab40fa36eb04f707cd0a565e54a Mon Sep 17 00:00:00 2001
From: gf712 <gil_f.hoben@hotmail.com>
Date: Thu, 4 Jun 2020 10:14:07 +0100
Subject: [PATCH] implicit conversions

---
 src/shogun/base/SGObject.h           | 130 ++++++++++++++++-----------
 src/shogun/lib/any.h                 |   8 +-
 src/shogun/util/traits.h             |  10 ++-
 tests/unit/base/SGObject_unittest.cc |   5 +-
 4 files changed, 93 insertions(+), 60 deletions(-)

diff --git a/src/shogun/base/SGObject.h b/src/shogun/base/SGObject.h
index 74ad866d2f9..52e117e685b 100644
--- a/src/shogun/base/SGObject.h
+++ b/src/shogun/base/SGObject.h
@@ -131,7 +131,7 @@ SG_FORCED_INLINE const char* convert_string_to_char(const char* name)
  */
 class SGObject: public std::enable_shared_from_this<SGObject>
 {
-	template <typename ReturnType, typename CastType>
+	template <typename ReturnType>
 	struct ParameterGetterInterface
 	{
 		ReturnType& m_value;
@@ -529,21 +529,8 @@ class SGObject: public std::enable_shared_from_this<SGObject>
 		const auto& value = param.get_value();
 		try
 		{
-			if (param.get_properties().has_property(ParameterProperties::CONSTFUNCTION))
-			{
-				ParameterGetterInterface<ReturnType, std::function<ReturnType()>> visitor{result};
-				value.visit_with(&visitor);
-			}
-			else if (param.get_properties().has_property(ParameterProperties::AUTO))
-			{
-				ParameterGetterInterface<ReturnType, AutoValue<ReturnType>> visitor{result};
-				value.visit_with(&visitor);
-			}
-			else
-			{
-				ParameterGetterInterface<ReturnType, ReturnType> visitor{result};
-				value.visit_with(&visitor);
-			}
+			ParameterGetterInterface<ReturnType> visitor{result};
+			value.visit_with(&visitor);
 		}
 		catch (const std::bad_optional_access&)
 		{
@@ -767,24 +754,22 @@ class SGObject: public std::enable_shared_from_this<SGObject>
 	template<typename T>
 	void register_parameter_visitor() const
 	{
-		if constexpr (is_auto_value_v<T>)
+		using Type = std::conditional_t<is_auto_value_v<T>, traits::variant_type_t<0, T>, T>;
+
+		if constexpr (std::is_arithmetic_v<Type> && !std::is_same_v<Type, bool>)
 		{
-			using ReturnType = traits::get_variant_type_t<0, T>;
-			Any::register_visitor<T, ParameterPutInterface<ReturnType>>(
-				[](T* value, auto* visitor)
-				{
-					*value = visitor->m_value;	
-				}
-			);
+			Any::register_visitor<T, ParameterPutInterface<float32_t>>(
+				[](T* value, auto* visitor) { *value = utils::safe_convert<Type>(visitor->m_value);});
+			Any::register_visitor<T, ParameterPutInterface<float64_t>>(
+				[](T* value, auto* visitor) { *value = utils::safe_convert<Type>(visitor->m_value);});
+			Any::register_visitor<T, ParameterPutInterface<int32_t>>(
+				[](T* value, auto* visitor) { *value = utils::safe_convert<Type>(visitor->m_value);});
+			Any::register_visitor<T, ParameterPutInterface<int64_t>>(
+				[](T* value, auto* visitor) { *value = utils::safe_convert<Type>(visitor->m_value);});
 		}
-		else
-		{
-			Any::register_visitor<T, ParameterPutInterface<T>>(
-				[](T* value, auto* visitor)
-				{
-					*value = visitor->m_value;	
-				}
-			);	
+		else {
+			Any::register_visitor<T, ParameterPutInterface<Type>>(
+				[](Type* value, auto* visitor) { *value = visitor->m_value;});			
 		}
 
 		if constexpr (traits::is_functional<T>::value)
@@ -792,20 +777,29 @@ class SGObject: public std::enable_shared_from_this<SGObject>
 			if constexpr (!traits::returns_void<T>::value)
 			{
 				using ReturnType = typename T::result_type;
-				Any::register_visitor<T, ParameterGetterInterface<ReturnType, T>>(
-					[](T* value, auto* visitor)
-					{
-						visitor->m_value = value->operator()();
-					}
-				);
+				if constexpr (std::is_arithmetic_v<ReturnType> && !std::is_same_v<Type, bool>) {
+					Any::register_visitor<T, ParameterGetterInterface<float32_t>>(
+						[](T* value, auto* visitor) {visitor->m_value = utils::safe_convert<float32_t>(value->operator()());});
+					Any::register_visitor<T, ParameterGetterInterface<float64_t>>(
+						[](T* value, auto* visitor) {visitor->m_value = utils::safe_convert<float64_t>(value->operator()());});
+					Any::register_visitor<T, ParameterGetterInterface<int32_t>>(
+						[](T* value, auto* visitor) {visitor->m_value = utils::safe_convert<int32_t>(value->operator()());});
+					Any::register_visitor<T, ParameterGetterInterface<int64_t>>(
+						[](T* value, auto* visitor) {visitor->m_value = utils::safe_convert<int64_t>(value->operator()());});
+				}
+				else {
+					Any::register_visitor<T, ParameterGetterInterface<ReturnType>>(
+						[](T* value, auto* visitor) {visitor->m_value = value->operator()();});
+				}
 			}
 		}
 		else if constexpr (is_auto_value_v<T>)
 		{
-			using ReturnType = traits::get_variant_type_t<0, T>;
-			Any::register_visitor<T, ParameterGetterInterface<ReturnType, T>>(
-				[](T* value, auto* visitor)
-				{
+			using ReturnType = traits::variant_type_t<0, T>;
+			static_assert(std::is_arithmetic_v<ReturnType> && !std::is_same_v<Type, bool>, 
+				"Cannot handle non arithmetic types in AutoValue yet");
+			Any::register_visitor<T, ParameterGetterInterface<float32_t>>(
+				[](T* value, auto* visitor) {
 					if (std::holds_alternative<AutoValueEmpty>(*value))
 					{
 						// std::bad_optional_access does not support error messages
@@ -814,18 +808,50 @@ class SGObject: public std::enable_shared_from_this<SGObject>
 						throw std::bad_optional_access{};
 					}
 					else
-						visitor->m_value = std::get<ReturnType>(*value);
-				}
-			);
+						visitor->m_value = utils::safe_convert<float32_t>(std::get<ReturnType>(*value));
+			});
+			Any::register_visitor<T, ParameterGetterInterface<float64_t>>(
+				[](T* value, auto* visitor) {
+					if (std::holds_alternative<AutoValueEmpty>(*value))
+						throw std::bad_optional_access{};
+					else
+						visitor->m_value = utils::safe_convert<float64_t>(std::get<ReturnType>(*value));
+			});
+			Any::register_visitor<T, ParameterGetterInterface<int32_t>>(
+				[](T* value, auto* visitor) {
+					if (std::holds_alternative<AutoValueEmpty>(*value))
+						throw std::bad_optional_access{};
+					else
+						visitor->m_value = utils::safe_convert<int32_t>(std::get<ReturnType>(*value));
+			});
+			Any::register_visitor<T, ParameterGetterInterface<int64_t>>(
+				[](T* value, auto* visitor) {
+					if (std::holds_alternative<AutoValueEmpty>(*value))
+						throw std::bad_optional_access{};
+					else
+						visitor->m_value = utils::safe_convert<int64_t>(std::get<ReturnType>(*value));
+			});
 		}
 		else
 		{
-			Any::register_visitor<T, ParameterGetterInterface<T, T>>(
-				[](T* value, auto* visitor)
-				{
-					visitor->m_value = *value;	
-				}
-			);
+			if constexpr(std::is_arithmetic_v<T> && !std::is_same_v<Type, bool>) {
+				Any::register_visitor<T, ParameterGetterInterface<float32_t>>(
+					[](T* value, auto* visitor) {visitor->m_value = utils::safe_convert<float32_t>(*value);});
+				Any::register_visitor<T, ParameterGetterInterface<float64_t>>(
+					[](T* value, auto* visitor) {visitor->m_value = utils::safe_convert<float64_t>(*value);});
+				Any::register_visitor<T, ParameterGetterInterface<int32_t>>(
+					[](T* value, auto* visitor) {visitor->m_value = utils::safe_convert<int32_t>(*value);});
+				Any::register_visitor<T, ParameterGetterInterface<int64_t>>(
+					[](T* value, auto* visitor) {visitor->m_value = utils::safe_convert<int64_t>(*value);});
+			}
+			else {
+				Any::register_visitor<T, ParameterGetterInterface<T>>(
+					[](T* value, auto* visitor)
+					{
+						visitor->m_value = *value;	
+					}
+				);
+			}
 		}
 	}
 	/** Registers a class parameter which is identified by a tag.
@@ -840,6 +866,7 @@ class SGObject: public std::enable_shared_from_this<SGObject>
 	void register_param(Tag<T>& _tag, const T& value)
 	{
 		create_parameter(_tag, AnyParameter(make_any(value)));
+		register_parameter_visitor<T>();
 	}
 
 	/** Registers a class parameter which is identified by a name.
@@ -854,6 +881,7 @@ class SGObject: public std::enable_shared_from_this<SGObject>
 	void register_param(std::string_view name, const T& value)
 	{
 		create_parameter(BaseTag(name), AnyParameter(make_any(value)));
+		register_parameter_visitor<T>();
 	}
 
 	/** Puts a pointer to some parameter into the parameter map.
diff --git a/src/shogun/lib/any.h b/src/shogun/lib/any.h
index ecef7026af7..115e3ccf47e 100644
--- a/src/shogun/lib/any.h
+++ b/src/shogun/lib/any.h
@@ -1316,11 +1316,11 @@ namespace shogun
 		if constexpr (std::is_base_of_v<SGObject, Derived>)
 		{
 			Any::register_caster<T, SGObject*>(
-			    [](T value) { return dynamic_cast<SGObject*>(value); });
+			    [](T value) { return static_cast<SGObject*>(value); });
 			if constexpr (!std::is_same_v<std::nullptr_t, base_type<Derived>>
 					&& !std::is_same_v<Derived, base_type<Derived>>)
 				Any::register_caster<T, base_type<Derived>*>([](T value) {
-					return dynamic_cast<base_type<Derived>*>(value);
+					return static_cast<base_type<Derived>*>(value);
 				});
 		}
 		if constexpr (traits::is_shared_ptr<T>::value)
@@ -1329,11 +1329,11 @@ namespace shogun
 			if constexpr (std::is_base_of_v<SGObject, SharedType>)
 			{
 				Any::register_caster<T, std::shared_ptr<SGObject>>(
-						[](T value) { return std::dynamic_pointer_cast<SGObject>(value); });
+						[](T value) { return std::static_pointer_cast<SGObject>(value); });
 				if constexpr (!std::is_same_v<std::nullptr_t, base_type<SharedType>>
 						&& !std::is_same_v<SharedType, base_type<SharedType>>)
 					Any::register_caster<T, std::shared_ptr<base_type<SharedType>>>([](T value) {
-						return std::dynamic_pointer_cast<base_type<SharedType>>(value);
+						return std::static_pointer_cast<base_type<SharedType>>(value);
 					});
 			}
 		}
diff --git a/src/shogun/util/traits.h b/src/shogun/util/traits.h
index e80dbc125d0..fb1dcf4d340 100644
--- a/src/shogun/util/traits.h
+++ b/src/shogun/util/traits.h
@@ -175,15 +175,19 @@ namespace shogun
 		inline constexpr bool is_any_of_v = is_any_of<T, Ts...>::value;
 
 		template<uint32_t idx, typename Ts>
-		struct get_variant_type{};
+		struct variant_type{
+			using type = Ts;
+		    static constexpr bool value = false;
+		};
 
 		template<uint32_t idx, typename ...Ts>
-		struct get_variant_type<idx, std::variant<Ts...>>{
+		struct variant_type<idx, std::variant<Ts...>>{
 		    using type = typename std::tuple_element<idx, std::tuple<Ts...>>::type;
+		    static constexpr bool value = true;
 		};
 
 		template<uint32_t idx, typename ...Ts>
-		using get_variant_type_t = typename get_variant_type<idx, Ts...>::type;
+		using variant_type_t = typename variant_type<idx, Ts...>::type;
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 	} // namespace traits
 } // namespace shogun
diff --git a/tests/unit/base/SGObject_unittest.cc b/tests/unit/base/SGObject_unittest.cc
index 8f1f4e3c035..d34e57f93a2 100644
--- a/tests/unit/base/SGObject_unittest.cc
+++ b/tests/unit/base/SGObject_unittest.cc
@@ -483,9 +483,10 @@ TEST(SGObject, tags_set_get_int)
 
 	EXPECT_THROW(obj->get<int32_t>("foo"), ShogunException);
 	obj->put(MockObject::kInt, 10);
+	EXPECT_NO_THROW(obj->put(MockObject::kInt, 10.0));
 	EXPECT_EQ(obj->get(Tag<int32_t>(MockObject::kInt)), 10);
-	EXPECT_THROW(obj->get<float64_t>(MockObject::kInt), ShogunException);
-	EXPECT_THROW(obj->get(Tag<float64_t>(MockObject::kInt)), ShogunException);
+	EXPECT_EQ(obj->get<float64_t>(MockObject::kInt), 10.0);
+	EXPECT_EQ(obj->get(Tag<float64_t>(MockObject::kInt)), 10.0);
 	EXPECT_EQ(obj->get<int>(MockObject::kInt), 10);
 }