update

PenetrateBasic/validation.h

@@ -0,0 +1,160 @@
+#pragma once
+
+#include <QString>
+#include <QList>
+#include <iostream>
+#include <functional>
+
+
+namespace validate {
+	template<typename T> class validator {
+	public:
+		virtual bool check(T value) const {
+			return false;
+		}
+	};
+	template<typename T> class validator_receiver {
+	public:
+		virtual void append(validator<T> inst) { }
+	};
+
+
+
+
+	template<typename... args_type> struct check_delegation;
+	template<> struct check_delegation<> {
+
+		void prest() {
+			std::cout << "ends" << std::endl;
+		}
+	};
+	template<typename head_type, typename... rest_type>
+	struct check_delegation<head_type, rest_type...> : public check_delegation<rest_type...> {
+	private:
+		QList<validator<head_type>> validator_list;
+
+	public:
+		void add(validator<head_type> vinst) {
+			validator_list << vinst;
+		}
+		bool check(head_type value) {
+			for (auto u : validator_list)
+				if (!u.check(value))
+					return false;
+			return true;
+		}
+
+		void prest() {
+			std::cout << "[-]" << validator_list.size() << std::endl;
+			check_delegation<rest_type...>::prest();
+		}
+	};
+
+
+
+
+	template<int idx, typename... args_type> struct elm_pos;
+
+	template<typename head_type, typename... rest_type>
+	struct elm_pos<0, check_delegation<head_type, rest_type...>> {
+		using value_type = head_type;
+		using templet_type = check_delegation<head_type, rest_type...>;
+	};
+	template<int idx, typename head_type, typename... rest_type>
+	struct elm_pos<idx, check_delegation<head_type, rest_type...>> {
+		using value_type = typename elm_pos<idx - 1, check_delegation<rest_type...>>::value_type;
+		using templet_type = typename elm_pos<idx - 1, check_delegation<rest_type...>>::templet_type;
+	};
+
+	template<int idx, typename head_type, typename... rest_type>
+	void __validator_insert_helper(check_delegation<head_type, rest_type...>& target,
+		validator<typename elm_pos<idx, check_delegation<head_type, rest_type...>>::value_type> inst) {
+		using templet_type = typename elm_pos<idx, check_delegation<head_type, rest_type...>>::templet_type;
+		target.templet_type::add(inst);
+	}
+
+
+
+
+	template<int n, typename... args_type> class slice_position;
+
+	template<typename S, typename T> class slice_validator : public validator<S> {
+	private:
+		std::function<T(S)> _proc_conv;
+		validator<T> _sub_validator;
+
+	public:
+		slice_validator(std::function<T(S)> proc, validator<T> vinst)
+			: _proc_conv(proc), _sub_validator(vinst) { }
+
+		virtual bool check(S value) const {
+			auto t_value = _proc_conv(value);
+			return _sub_validator.check(t_value);
+		}
+	};
+	template<int n, typename... args_type> class args_position
+		: public validator_receiver<typename elm_pos<n, check_delegation<args_type...>>::value_type> {
+	public:
+		using param_type = typename elm_pos<n, check_delegation<args_type...>>::value_type;
+
+		args_position(check_delegation<args_type...>& target) :_templet_bind(target) { }
+
+		args_position<n, args_type...>& operator&(validator<param_type> vinst) {
+			append(vinst);
+			return *this;
+		}
+
+		template<typename slice_type>
+		slice_position<n, param_type, slice_type, args_position<n, args_type...>>
+		slice(std::function<slice_type(param_type)> slice_fun) {
+			return slice_position<n, param_type, slice_type, args_position<n, args_type...>>(*this, slice_fun);
+		}
+
+		// validator_receiver
+		virtual void append(validator<param_type> inst) {
+			__validator_insert_helper<n, args_type...>(_templet_bind, inst);
+		}
+
+	private:
+		check_delegation<args_type...>& _templet_bind;
+	};
+	template<int n, typename s_type, typename t_type, typename... args_type>
+	class slice_position<n, s_type, t_type, args_position<n, args_type...>> : public validator_receiver<t_type> {
+	public:
+		slice_position(validator_receiver<s_type>& host, std::function<t_type(s_type)> func)
+			:_conv_func(func), _prev_bind(host) { }
+
+		slice_position<n, s_type, t_type, args_position<n, args_type...>>& operator&(validator<t_type> vinst) {
+			append(vinst);
+			return *this;
+		}
+
+		template<typename slice_type>
+		slice_position<n, t_type, slice_type, args_position<n, args_type...>>
+		slice(std::function<slice_type(t_type)> slice_fun) {
+			return slice_position<n, t_type, slice_type, args_position<n, args_type...>>(*this, slice_fun);
+		}
+
+		// validator_receiver
+		virtual void append(validator<t_type> inst) {
+			slice_validator<s_type, t_type> mid_validator(_conv_func, inst);
+			_prev_bind.append(mid_validator);
+		}
+
+	private:
+		std::function<t_type(s_type)> _conv_func;
+		validator_receiver<s_type>& _prev_bind;
+	};
+
+
+
+
+	template<void* func, typename... types> struct validate_helper;
+	template<void* func, typename return_type, typename... args_type>
+	struct validate_helper<func, return_type, args_type...> : public check_delegation<args_type...> {
+		template<int n> args_position<n, args_type...> pos() {
+			return args_position<n, args_type...>(*this);
+		}
+	};
+
+}