Class cni

include/covscript/core/cni.hpp:590–679

	};

	class cni final {
		template <typename T>
		struct construct_helper
		{
			template <typename X, typename RetT, typename... ArgsT>
			static cni_holder_base *_construct(X &&val, RetT (*target_function)(ArgsT...))
			{
				using source_function_type = typename cni_decayed_conversion_cpp<RetT>::target_type (*)(
				                                 typename cni_decayed_conversion_cs<ArgsT>::source_type...);
				// Return type
				static_assert(cni_convertible<RetT, typename cni_decayed_conversion_cpp<RetT>::target_type>::value,
				              "Invalid conversion.");
				// Argument type
				check_conversion(target_function, source_function_type(nullptr));
				return new cni_holder<T, source_function_type>(std::forward<X>(val));
			}

			template <typename X>
			static cni_holder_base *construct(X &&val)
			{
				return _construct(std::forward<X>(val), typename cov::function_parser<T>::type::common_type(nullptr));
			}
		};

		cni_holder_base *mCni = nullptr;

	public:
		cni() = delete;

		cni(const cni &c) : mCni(c.mCni->clone()) {}

		template <typename T>
		explicit cni(T &&val) : mCni(
			    construct_helper<typename cni_modify<typename std::remove_reference<T>::type>::type>::construct(
			        std::forward<T>(val)))
		{
		}

		template <typename T, typename X>
		cni(T &&val, cni_type<X>) : mCni(
			    new cni_holder<typename cni_modify<typename std::remove_reference<T>::type>::type, typename cni_modify<X>::type>(
			        std::forward<T>(val)))
		{
			// Analysis the function
			using target_function_type = typename cov::function_parser<typename cni_modify<typename std::remove_reference<T>::type>::type>::type::common_type;
			using source_function_type = typename cov::function_parser<typename cni_modify<X>::type>::type::common_type;
			// Check consistency
			// Argument size
			static_assert(
			    count_args_size(target_function_type(nullptr)) == count_args_size(source_function_type(nullptr)),
			    "Invalid argument size.");
			// Return type
			static_assert(
			    cni_convertible<typename cov::function_parser<target_function_type>::type::return_type, typename cov::function_parser<source_function_type>::type::return_type>::value,
			    "Invalid conversion.");
			// Argument type
			check_conversion(target_function_type(nullptr), source_function_type(nullptr));
		}