Class cni_decayed_convertor

include/covscript/core/cni.hpp:269–316

	template <typename _SourceT, typename _TargetT>
	class cni_decayed_convertor {
	private:
		template <typename _From, typename _To, typename = void>
		struct is_specialized
		{
			static constexpr bool value = true;
		};

		template <typename _From, typename _To>
		struct is_specialized<_From, _To, void_t<typename type_convertor<_From, _To>::_not_specialized>>
		{
			static constexpr bool value = false;
		};

		template <typename>
		struct type_extractor;

		template <template <typename, typename> class T, typename _From, typename _To>
		struct type_extractor<T<_From, _To>>
		{
			using source_type = _From;
			using target_type = _To;
		};

		template <typename S, typename T>
		using select_convertor = typename std::conditional<is_specialized<S, T>::value,
		      type_convertor<S, T>, typename std::conditional<is_specialized<decay_t<S>, decay_t<T>>::value, type_convertor<decay_t<S>, decay_t<T>>, typename std::conditional<cni_convertible<S, T>::value, type_convertor<S, T>, void>::type>::type>::type;

	public:
		using convertor = select_convertor<_SourceT, _TargetT>;
		static_assert(!std::is_same<convertor, void>::value, "No suitable type_convertor found.");

		using source_type = typename type_extractor<convertor>::source_type;
		using target_type = typename type_extractor<convertor>::target_type;

		static _TargetT convert_to_cpp(any &val)
		{
			constexpr bool bindable = std::is_reference<decltype(convertor::convert(std::declval<source_type>()))>::value || !std::is_reference<_TargetT>::value;
			using Convertor = cni_decayed_converter_impl<source_type, _TargetT, convertor, bindable>;
			return Convertor::convert(val);
		}

		template <typename T>
		static any convert_to_cs(T &&val)
		{
			return return_to_cs(convertor::convert(std::forward<T>(val)));
		}
	};

// Dynamic argument check
	template <typename T, int index>