zemu 0.1.0

data/src/external/Z/API/Z/classes/functional/Functor.hpp

@@ -0,0 +1,265 @@
+/* Z Kit - classes/functional/Functor.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_functional_Functor_HPP_
+#define _Z_classes_functional_Functor_HPP_
+
+#include <Z/classes/functional/ObjectMemberFunction.hpp>
+
+#if Z_HAS_CLASS(ObjectMemberFunction)
+
+#	ifdef Z_USE_OBJECTIVE_C_RUNTIME
+#		include <Z/classes/functional/ObjectSelector.hpp>
+#	endif
+
+
+	namespace Zeta {
+
+		template <class F> class Functor;
+
+		template <class R, class... P> class Functor<R(P...)> {
+
+			private:
+			typedef R (* Call)(const Functor *, typename Type<P>::to_forwardable...);
+			typedef void (* Destroy)(Functor *);
+
+			Call	call;
+			Destroy destroy;
+
+			union {	R (* function)(P...);
+
+				struct {R (NaT::* function)(P...);
+					NaT *object;
+				} object_member_function;
+
+#				if Z_HAS_CLASS(ObjectSelector)
+					struct {SEL selector;
+						id  object;
+					} object_selector;
+#				endif
+			} target;
+
+
+			struct Callers {
+
+				template <class RR = R>
+				static Z_INLINE typename EnableIf<Type<RR>::is_void, Call>::type function()
+					{
+					return [](const Functor *functor, typename Type<P>::to_forwardable... arguments)
+						{functor->target.function(arguments...);};
+					}
+
+
+				template <class RR = R>
+				static Z_INLINE typename EnableIf<!Type<RR>::is_void, Call>::type function()
+					{
+					return [](const Functor *functor, typename Type<P>::to_forwardable... arguments)
+						{return functor->target.function(arguments...);};
+					}
+
+
+				template <class RR = R>
+				static Z_INLINE typename EnableIf<Type<RR>::is_void, Call>::type object_member_function()
+					{
+					return [](const Functor *functor, typename Type<P>::to_forwardable... arguments)
+						{
+						(functor->target.object_member_function.object->*functor->target.object_member_function.function)
+							(arguments...);
+						};
+					}
+
+
+				template <class RR = R>
+				static Z_INLINE typename EnableIf<!Type<RR>::is_void, Call>::type object_member_function()
+					{
+					return [](const Functor *functor, typename Type<P>::to_forwardable... arguments)
+						{
+						return (functor->target.object_member_function.object->*functor->target.object_member_function.function)
+							(arguments...);
+						};
+					}
+
+
+#				if Z_HAS_CLASS(ObjectSelector)
+
+					typedef R (* CallObjectSelector)(id, SEL, P...);
+
+
+					template <class RR = R>
+					static Z_INLINE typename EnableIf<Type<RR>::is_void, Call>::type object_selector()
+						{
+						return [](const Functor *functor, typename Type<P>::to_forwardable... arguments)
+							{
+							((CallObjectSelector)objc_msgSend)
+								(functor->target.object_selector.object, functor->target.object_selector.selector,
+								 arguments...);
+							};
+						}
+
+
+#					if	Z_CPU_ARCHITECTURE == Z_CPU_ARCHITECTURE_X86_64 || \
+						Z_CPU_ARCHITECTURE == Z_CPU_ARCHITECTURE_X86_32
+
+						template <class RR = R>
+						static Z_INLINE typename EnableIf<
+							!Type<RR>::is_void &&
+							!Type<RR>::is_real &&
+							!Type<RR>::is_structure_or_union,
+						Call>::type object_selector()
+							{
+							return [](const Functor *functor, typename Type<P>::to_forwardable... arguments)
+								{
+								return ((CallObjectSelector)objc_msgSend)
+									(functor->target.object_selector.object, functor->target.object_selector.selector,
+									 arguments...);
+								};
+							}
+
+
+						template <class RR = R>
+						static Z_INLINE typename EnableIf<Type<RR>::is_real, Call>::type object_selector()
+							{
+							return [](const Functor *functor, typename Type<P>::to_forwardable... arguments)
+								{
+								return ((CallObjectSelector)objc_msgSend_fpret)
+									(functor->target.object_selector.object, functor->target.object_selector.selector,
+									 arguments...);
+								};
+							}
+
+#					else
+
+						template <class RR = R>
+						static Z_INLINE typename EnableIf<
+							!Type<RR>::is_void &&
+							!Type<RR>::is_structure_or_union,
+						Call>::type object_selector()
+							{
+							return [](const Functor *functor, typename Type<P>::to_forwardable... arguments)
+								{
+								return ((CallObjectSelector)objc_msgSend)
+									(functor->target.object_selector.object, functor->target.object_selector.selector,
+									 arguments...);
+								};
+							}
+
+#					endif
+
+
+					template <class RR = R>
+					static Z_INLINE typename EnableIf<Type<RR>::is_structure_or_union, Call>::type object_selector()
+						{
+						return [](const Functor *functor, typename Type<P>::to_forwardable... arguments)
+							{
+							return ((CallObjectSelector)objc_msgSend_stret)
+								(functor->target.object_selector.object, functor->target.object_selector.selector,
+								 arguments...);
+							};
+						}
+
+#				endif
+			};
+
+
+			public:
+
+			Z_CT(CPP11) Functor() : call(NULL), destroy(NULL) {}
+
+
+			Z_INLINE Functor(R (* function)(P...))
+			: call(Callers::function()), destroy(NULL)
+				{target.function = function;}
+
+
+			template <class O, class M, class E = typename EnableIf<
+				(Type<O>::is_void_pointer			       ||
+				 (Type<O>::is_pointer				       &&
+				  Type<O>::flow::pointee_type::is_structure_or_union)) &&
+				Type<M>::is_member_function_pointer		       &&
+				TypeAreEqual<
+					typename Type<M>::flow::to_function::end::to_unqualified,
+					R(P...)
+				>::value,
+			M>::type>
+			Z_INLINE Functor(O object, M function)
+			: call(Callers::object_member_function()), destroy(NULL)
+				{
+				target.object_member_function.function = (R (NaT::*)(P...))function;
+				target.object_member_function.object   = (NaT *)object;
+				}
+
+
+			template <class O, class M, class E = typename EnableIf<
+				Type<O>::is_structure_or_union	    &&
+				Type<M>::is_member_function_pointer &&
+				TypeAreEqual<
+					typename Type<M>::flow::to_function::end::to_unqualified,
+					R(P...)
+				>::value,
+			M>::type>
+			Z_INLINE Functor(const O &object, M function)
+			: call(Callers::object_member_function()), destroy(NULL)
+				{
+				target.object_member_function.function = (R (NaT::*)(P...))function;
+				target.object_member_function.object   = (NaT *)&object;
+				}
+
+
+			Z_INLINE Functor(const ObjectMemberFunction<R(P...)> &object_member_function)
+			: call(Callers::object_member_function()), destroy(NULL)
+				{
+				target.object_member_function.function = object_member_function.function;
+				target.object_member_function.object   = object_member_function.object;
+				}
+
+
+#			if Z_HAS_CLASS(ObjectSelector)
+
+				Z_INLINE Functor(id object, SEL selector)
+				: call(Callers::object_selector()), destroy(NULL)
+					{
+					target.object_selector.selector = selector;
+					target.object_selector.object	= object;
+					}
+
+
+				Z_INLINE Functor(const ObjectSelector<R(P...)> &object_selector)
+				: call(Callers::object_selector()), destroy(NULL)
+					{
+					target.object_selector.selector = object_selector.selector;
+					target.object_selector.object	= object_selector.object;
+					}
+
+#			endif
+
+
+			Z_INLINE ~Functor() {if (destroy) destroy(this);}
+
+
+			Z_CT(CPP11) operator Boolean() const {return call != NULL;}
+
+
+			template <class RR = R>
+			Z_INLINE typename EnableIf<Type<RR>::is_void, RR>::type
+			operator ()(typename Type<P>::to_forwardable... arguments) const
+				{call(this, arguments...);}
+
+
+			template <class RR = R>
+			Z_INLINE typename EnableIf<!Type<RR>::is_void, RR>::type
+			operator ()(typename Type<P>::to_forwardable... arguments) const
+				{return call(this, arguments...);}
+		};
+	}
+
+
+#	define Z_HAS_CLASS_Functor TRUE
+#else
+#	define Z_HAS_CLASS_Functor FALSE
+#endif
+
+#endif // _Z_classes_functional_Functor_HPP_

data/src/external/Z/API/Z/classes/functional/MemberFunction.hpp

@@ -0,0 +1,98 @@
+/* Z Kit - classes/functional/MemberFunction.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_functional_MemberFunction_HPP_
+#define _Z_classes_functional_MemberFunction_HPP_
+
+#include <Z/inspection/language.h>
+
+#if	Z_LANGUAGE_HAS(CPP, SFINAE)	       && \
+	Z_LANGUAGE_HAS(CPP, VARIADIC_TEMPLATE) && \
+	Z_LANGUAGE_HAS(CPP, DEFAULT_TEMPLATE_ARGUMENTS_FOR_FUNCTION_TEMPLATE)
+
+#	include <Z/traits/filtering.hpp>
+#	include <Z/traits/Type.hpp>
+
+
+	namespace Zeta {
+
+		template <class F> struct MemberFunction;
+
+		template <class R, class... P> struct MemberFunction<R(P...)> {
+			R (NaT::* function)(P...);
+
+			Z_INLINE MemberFunction() Z_DEFAULTED({})
+
+
+#			if Z_LANGUAGE_HAS_SPECIFIER(CPP, DECLARED_TYPE) && Z_LANGUAGE_HAS_LITERAL(CPP, NULL_POINTER)
+				Z_CT(CPP11) MemberFunction(NullPointer)
+				: function(NULL) {};
+#			endif
+
+
+			template <class M, class E = typename EnableIf<
+				Type<M>::is_member_function_pointer &&
+				TypeAreEqual<typename Type<M>::flow::to_function::end::to_unqualified, R(P...)>::value,
+			M>::type>
+			Z_INLINE MemberFunction(M function)
+			: function((R (NaT::*)(P...))function) {}
+
+
+			Z_CT(CPP11) operator Boolean() const {return function != NULL;}
+
+
+			template <class M, class E = typename EnableIf<
+				Type<M>::is_member_function_pointer &&
+				TypeAreEqual<typename Type<M>::flow::to_function::end::to_unqualified, R(P...)>::value,
+			M>::type>
+			Z_INLINE operator M() const {return (M)function;}
+
+
+			template <class M>
+			Z_INLINE typename EnableIf<
+				Type<M>::is_member_function_pointer &&
+				TypeAreEqual<typename Type<M>::flow::to_function::end::to_unqualified, R(P...)>::value,
+			MemberFunction &>::type
+			operator =(M rhs)
+				{
+				function = (R (NaT::*)(P...))rhs;
+				return *this;
+				}
+
+
+			template <class O, class RR = R>
+			Z_INLINE typename EnableIf<Type<RR>::is_void, RR>::type
+			operator ()(O *object, typename Type<P>::to_forwardable... arguments) const
+				{(((NaT *)object)->*function)(arguments...);}
+
+
+			template <class O, class RR = R>
+			Z_INLINE typename EnableIf<Type<R>::is_void, RR>::type
+			operator ()(const O &object, typename Type<P>::to_forwardable... arguments) const
+				{(((NaT *)&object)->*function)(arguments...);}
+
+
+			template <class O, class RR = R>
+			Z_INLINE typename EnableIf<!Type<R>::is_void, RR>::type
+			operator ()(O *object, typename Type<P>::to_forwardable... arguments) const
+				{return (((NaT *)object)->*function)(arguments...);}
+
+
+			template <class O, class RR = R>
+			Z_INLINE typename EnableIf<!Type<R>::is_void, RR>::type
+			operator ()(const O &object, typename Type<P>::to_forwardable... arguments) const
+				{return (((NaT *)&object)->*function)(arguments...);}
+		};
+	}
+
+
+#	define Z_HAS_CLASS_MemberFunction TRUE
+#else
+#	define Z_HAS_CLASS_MemberFunction FALSE
+#endif
+
+#endif // _Z_classes_functional_MemberFunction_HPP_

data/src/external/Z/API/Z/classes/functional/ObjectMemberFunction.hpp

@@ -0,0 +1,172 @@
+/* Z Kit - classes/functional/ObjectMemberFunction.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_functional_ObjectMemberFunction_HPP_
+#define _Z_classes_functional_ObjectMemberFunction_HPP_
+
+#include <Z/inspection/Z.h>
+#include <Z/classes/functional/MemberFunction.hpp>
+
+#if Z_HAS_CLASS(MemberFunction)
+
+
+	namespace Zeta {
+
+		template <class F> struct ObjectMemberFunction;
+
+		template <class R, class... P> struct ObjectMemberFunction<R(P...)> : MemberFunction<R(P...)> {
+			NaT *object;
+
+			Z_INLINE ObjectMemberFunction() Z_DEFAULTED({})
+
+
+#			if Z_LANGUAGE_HAS(CPP, INHERITING_CONSTRUCTORS)
+				using MemberFunction<R(P...)>::MemberFunction;
+#			else
+				template <class M, class E = typename EnableIf<
+					Type<M>::is_member_function_pointer &&
+					TypeAreEqual<typename Type<M>::flow::to_function::end::to_unqualified, R(P...)>::value,
+				M>::type>
+				Z_INLINE ObjectMemberFunction(M function)
+				: MemberFunction<R(P...)>(function) {}
+#			endif
+
+
+#			if Z_LANGUAGE_HAS_SPECIFIER(CPP, DECLARED_TYPE) && Z_LANGUAGE_HAS_LITERAL(CPP, NULL_POINTER)
+				Z_CT(CPP11) ObjectMemberFunction(NullPointer)
+				: MemberFunction<R(P...)>(NULL), object(NULL) {};
+#			endif
+
+
+			template <class O, class M, class E = typename EnableIf<
+				(Type<O>::is_void_pointer			       ||
+				 (Type<O>::is_pointer				       &&
+				  Type<O>::flow::pointee_type::is_structure_or_union)) &&
+				Type<M>::is_member_function_pointer		       &&
+				TypeAreEqual<typename Type<M>::flow::to_function::end::to_unqualified, R(P...)>::value,
+			M>::type>
+			Z_INLINE ObjectMemberFunction(O object, M function)
+			: MemberFunction<R(P...)>(function), object((NaT *)object) {}
+
+
+			template <class O, class M, class E = typename EnableIf<
+				Type<O>::is_structure_or_union	    &&
+				Type<M>::is_member_function_pointer &&
+				TypeAreEqual<typename Type<M>::flow::to_function::end::to_unqualified, R(P...)>::value,
+			M>::type>
+			Z_INLINE ObjectMemberFunction(const O &object, M function)
+			: MemberFunction<R(P...)>(function), object((NaT *)&object) {}
+
+
+			template <class O, class E = typename EnableIf<Type<O>::is_structure_or_union, O>::type>
+			Z_INLINE operator O *() const {return (O *)object;}
+
+
+			template <class O>
+			Z_INLINE typename EnableIf<Type<O>::is_structure_or_union, ObjectMemberFunction &>::type
+			operator =(O *rhs)
+				{
+				object = (NaT *)rhs;
+				return *this;
+				}
+
+
+			template <class O>
+			Z_INLINE typename EnableIf<Type<O>::is_structure_or_union, ObjectMemberFunction &>::type
+			operator =(const O &rhs)
+				{
+				object = (NaT *)&rhs;
+				return *this;
+				}
+
+
+			template <class M>
+			Z_INLINE typename EnableIf<
+				Type<M>::is_member_function_pointer &&
+				TypeAreEqual<typename Type<M>::flow::to_function::end::to_unqualified, R(P...)>::value,
+			ObjectMemberFunction &>::type
+			operator =(M rhs)
+				{
+				this->function = (R (NaT::*)(P...))rhs;
+				return *this;
+				}
+
+
+			template <class RR = R>
+			Z_INLINE typename EnableIf<Type<RR>::is_void, RR>::type
+			operator ()(typename Type<P>::to_forwardable... arguments) const
+				{(object->*this->function)(arguments...);}
+
+
+			template <class O, class RR = R>
+			Z_INLINE typename EnableIf<Type<RR>::is_void, RR>::type
+			operator ()(O *object, typename Type<P>::to_forwardable... arguments) const
+				{(((NaT *)object)->*this->function)(arguments...);}
+
+
+			template <class O, class RR = R>
+			Z_INLINE typename EnableIf<Type<RR>::is_void, RR>::type
+			operator ()(const O &object, typename Type<P>::to_forwardable... arguments) const
+				{(((NaT *)&object)->*this->function)(arguments...);}
+
+
+			template <class RR = R>
+			Z_INLINE typename EnableIf<!Type<RR>::is_void, RR>::type
+			operator ()(typename Type<P>::to_forwardable... arguments) const
+				{return (object->*this->function)(arguments...);}
+
+
+			template <class O, class RR = R>
+			Z_INLINE typename EnableIf<!Type<RR>::is_void, RR>::type
+			operator ()(O *object, typename Type<P>::to_forwardable... arguments) const
+				{return (((NaT *)object)->*this->function)(arguments...);}
+
+
+			template <class O, class RR = R>
+			Z_INLINE typename EnableIf<!Type<RR>::is_void, RR>::type
+			operator ()(const O &object, typename Type<P>::to_forwardable... arguments) const
+				{return (((NaT *)&object)->*this->function)(arguments...);}
+
+
+			template <class O, class M>
+			Z_INLINE typename EnableIf<
+				(Type<O>::is_void_pointer			       ||
+				 (Type<O>::is_pointer				       &&
+				  Type<O>::flow::pointee_type::is_structure_or_union)) &&
+				Type<M>::is_member_function_pointer		       &&
+				TypeAreEqual<typename Type<M>::flow::to_function::end::to_unqualified, R(P...)>::value,
+			ObjectMemberFunction &>::type
+			set(O object, M function)
+				{
+				this->function = (R (NaT::*)(P...))function;
+				this->object   = (NaT *)&object;
+				return *this;
+				}
+
+
+			template <class O, class M>
+			Z_INLINE typename EnableIf<
+				Type<O>::is_structure_or_union	    &&
+				Type<M>::is_member_function_pointer &&
+				TypeAreEqual<typename Type<M>::flow::to_function::end::to_unqualified, R(P...)>::value,
+			ObjectMemberFunction &>::type
+			set(const O &object, M function)
+				{
+				this->function = (R (NaT::*)(P...))function;
+				this->object   = (NaT *)&object;
+				return *this;
+				}
+		};
+	}
+
+
+#	define Z_HAS_CLASS_ObjectMemberFunction TRUE
+#else
+#	define Z_HAS_CLASS_ObjectMemberFunction FALSE
+#endif
+
+#endif // _Z_classes_functional_ObjectMemberFunction_HPP_