zemu 0.1.0

data/src/external/Z/API/Z/classes/base/Range.hpp

@@ -0,0 +1,111 @@
+/* Z Kit - classes/base/Range.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_base_Range_HPP_
+#define _Z_classes_base_Range_HPP_
+
+#include <Z/macros/type selection.hpp>
+#include <Z/functions/base/value.hpp>
+
+#if defined(Z_USE_NS_RANGE) && Z_LANGUAGE_INCLUDES(OBJECTIVE_CPP)
+#	import <Foundation/NSRange.h>
+#endif
+
+
+namespace Zeta {template <class T> struct Range {
+	typedef typename ZTypeFixedNatural(ZRange, T) Base;
+	T index, size;
+
+	Z_INLINE Range() Z_DEFAULTED({})
+
+	Z_CT(CPP11) Range(T size)	     : index(0),	   size(size)	    {}
+	Z_CT(CPP11) Range(T index, T size)   : index(index),	   size(size)	    {}
+	Z_CT(CPP11) Range(const Base &other) : index(other.index), size(other.size) {}
+
+	Z_CT(CPP11) operator Boolean() const {return !!size;}
+	Z_INLINE    operator Base&  () const {return *((Base *)this);}
+
+
+	Z_CT(CPP11) Boolean operator ==(const Range &rhs) const
+		{return index == rhs.index && size == rhs.size;}
+
+
+	Z_CT(CPP11) Boolean operator !=(const Range &rhs) const
+		{return index != rhs.index || size != rhs.size;}
+
+
+	Z_CT(CPP14) Range operator &(const Range &rhs) const
+		{
+		T index = (this->index > rhs.index) ? this->index : rhs.index;
+		T end	= minimum<T>(end(), rhs.end());
+
+		return end > index ? Range(index, end - index) : Range(0);
+		}
+
+
+	Z_CT(CPP14) Range operator |(const Range &rhs) const
+		{
+		T	index = (this->index < rhs.index) ? this->index : rhs.index,
+			a_end = end(),
+			b_end = rhs.end();
+
+		return Range(index, ((a_end > b_end) ? a_end : b_end) - index);
+		}
+
+
+	Z_INLINE Range &operator &=(const Range &rhs) {return *this = *this & rhs;}
+	Z_INLINE Range &operator |=(const Range &rhs) {return *this = *this | rhs;}
+
+	Z_CT(CPP11) T operator [](T index) const {return this->index + index;}
+
+
+#	if defined(Z_USE_NS_RANGE) && Z_LANGUAGE_INCLUDES(OBJECTIVE_CPP)
+
+		Z_CT(CPP11) Range(const NSRange &range)
+		: index(range.location), size(range.length) {}
+
+
+#		if Z_LANGUAGE_HAS(CPP, INITIALIZER_LIST)
+			Z_CT(CPP11) operator NSRange() const
+				{return NSRange{NSUInteger(index), NSUInteger(size)};}
+#		else
+			Z_CT(CPP14) operator NSRange() const
+				{
+				NSRange result = {NSUInteger(index), NSUInteger(size)};
+				return result;
+				}
+#		endif
+
+#	endif
+
+
+	Z_CT(CPP11) Boolean contains(const Range &other) const
+		{return other.index >= index && other.end() <= end();}
+
+
+	Z_CT(CPP11) Boolean contains(T index) const
+		{return index >= this->index && index < end();}
+
+
+	Z_CT(CPP11) T end() const
+		{return index + size;}
+
+
+	Z_CT(CPP11) Boolean intersects(const Range &other) const
+		{return	index < other.end() && other.index < end();}
+
+
+	Z_CT(CPP11) Boolean is_zero() const
+		{return !index && !size;}
+
+
+	Z_INLINE void swap(Range &other)
+		{Zeta::swap<Base>(this, &other);}
+};}
+
+
+#endif // _Z_classes_base_Range_HPP_

data/src/external/Z/API/Z/classes/base/SizedString.hpp

@@ -0,0 +1,66 @@
+/* Z Kit - classes/base/SizedString.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2017 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_base_SizedString_HPP_
+#define _Z_classes_base_SizedString_HPP_
+
+#include <Z/types/base.hpp>
+
+
+namespace Zeta {namespace Detail {namespace SizedString {
+
+	template <USize I> class Element : public Element<I - 1> {
+		protected:
+		Char _character;
+
+		public:
+		Z_CT(CPP11) Element(const Char *string)
+		: Element<I - 1>(string), _character(string[I]) {}
+	};
+
+
+	template <> class Element<0> {
+		protected:
+		Char _character;
+
+		public:
+		Z_CT(CPP11) Element(const Char *string)
+		: _character(string[0]) {}
+	};
+}}}
+
+
+namespace Zeta {
+
+	template <USize S> class SizedString : public Detail::SizedString::Element<S - 1> {
+		protected:
+		Char _null_character;
+
+		public:
+		Z_CT(CPP11) SizedString(const Char *string)
+		: Detail::SizedString::Element<S - 1>(string), _null_character('\0') {}
+
+		Z_INLINE operator const Char *() const
+			{return &this->Detail::SizedString::Element<0>::_character;}
+	};
+
+
+	template <> class SizedString<0> {
+		protected:
+		Char _null_character;
+
+		public:
+		Z_CT(CPP11) SizedString(const Char *string)
+		: _null_character('\0') {}
+
+		Z_INLINE operator const Char *() const
+			{return &_null_character;}
+	};
+}
+
+
+#endif // _Z_classes_base_SizedString_HPP_

data/src/external/Z/API/Z/classes/base/Status.hpp

@@ -0,0 +1,89 @@
+/* Z Kit - classes/base/Status.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_base_Status_HPP_
+#define _Z_classes_base_Status_HPP_
+
+#include <Z/keys/status.h>
+#include <Z/types/base.hpp>
+
+
+namespace Zeta {struct Status {
+
+	enum {	OK	      = Z_OK,
+		End	      = Z_END,
+		Updated	      = Z_UPDATED,
+		Unimplemented = Z_UNIMPLEMENTED
+	};
+
+	struct Error {enum {
+		Unknown		   = Z_ERROR_UNKNOWN,
+		AlreadyExists	   = Z_ERROR_ALREADY_EXISTS,
+		AlreadyInUse	   = Z_ERROR_ALREADY_IN_USE,
+		AlreadyOpen	   = Z_ERROR_ALREADY_OPEN,
+		AlreadyRunning	   = Z_ERROR_ALREADY_RUNNING,
+		Busy		   = Z_ERROR_BUSY,
+		Closed		   = Z_ERROR_CLOSED,
+		ClosedByPeer	   = Z_ERROR_CLOSED_BY_PEER,
+		Empty		   = Z_ERROR_EMPTY,
+		Exception	   = Z_ERROR_EXCEPTION,
+		Full		   = Z_ERROR_FULL,
+		LimitReached	   = Z_ERROR_LIMIT_REACHED,
+		Locked		   = Z_ERROR_LOCKED,
+		Loop		   = Z_ERROR_LOOP,
+		InvalidAddress	   = Z_ERROR_INVALID_ADDRESS,
+		InvalidArgument	   = Z_ERROR_INVALID_ARGUMENT,
+		InvalidData	   = Z_ERROR_INVALID_DATA,
+		InvalidFormat	   = Z_ERROR_INVALID_FORMAT,
+		InvalidIndex	   = Z_ERROR_INVALID_INDEX,
+		InvalidInterval	   = Z_ERROR_INVALID_INTERVAL,
+		InvalidIO	   = Z_ERROR_INVALID_IO,
+		InvalidProtocol	   = Z_ERROR_INVALID_PROTOCOL,
+		InvalidRange	   = Z_ERROR_INVALID_RANGE,
+		InvalidRatio	   = Z_ERROR_INVALID_RATIO,
+		InvalidSize	   = Z_ERROR_INVALID_SIZE,
+		InvalidType	   = Z_ERROR_INVALID_TYPE,
+		InvalidValue	   = Z_ERROR_INVALID_VALUE,
+		NotAvailable	   = Z_ERROR_NOT_AVAILABLE,
+		NotEnoughMemory	   = Z_ERROR_NOT_ENOUGH_MEMORY,
+		NotEnoughSpace	   = Z_ERROR_NOT_ENOUGH_SPACE,
+		NotEnoughResources = Z_ERROR_NOT_ENOUGH_RESOURCES,
+		NotExecutable	   = Z_ERROR_NOT_EXECUTABLE,
+		NotFinalized	   = Z_ERROR_NOT_FINALIZED,
+		NotFound	   = Z_ERROR_NOT_FOUND,
+		NotInitialized	   = Z_ERROR_NOT_INITIALIZED,
+		NotReadable	   = Z_ERROR_NOT_READABLE,
+		NotWritable	   = Z_ERROR_NOT_WRITABLE,
+		NotSupported	   = Z_ERROR_NOT_SUPPORTED,
+		RaceCondition	   = Z_ERROR_RACE_CONDITION,
+		Rejected	   = Z_ERROR_REJECTED,
+		StackOverflow	   = Z_ERROR_STACK_OVERFLOW,
+		Stalled		   = Z_ERROR_STALLED,
+		Terminated	   = Z_ERROR_TERMINATED,
+		TimeOut		   = Z_ERROR_TIME_OUT,
+		TooBig		   = Z_ERROR_TOO_BIG,
+		TooSmall	   = Z_ERROR_TOO_SMALL,
+		Unauthorized	   = Z_ERROR_UNAUTHORIZED,
+		Unreachable	   = Z_ERROR_UNREACHABLE
+	};};
+
+	ZStatus code;
+
+	Z_INLINE Status() Z_DEFAULTED({})
+
+	Z_CT(CPP11) Status(ZStatus code) : code(code) {}
+
+	Z_CT(CPP11) operator ZStatus() const {return code;}
+
+	Z_CT(CPP11) Boolean operator ==(ZStatus status) const {return code == status;}
+	Z_CT(CPP11) Boolean operator !=(ZStatus status) const {return code != status;}
+
+	Z_CT(CPP11) Boolean is_error() const {return code < 0;}
+};}
+
+
+#endif // _Z_classes_base_Status_HPP_

data/src/external/Z/API/Z/classes/base/Symbol.hpp

@@ -0,0 +1,39 @@
+/* Z Kit - classes/base/Symbol.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_base_Symbol_HPP_
+#define _Z_classes_base_Symbol_HPP_
+
+#include <Z/types/base.hpp>
+
+
+namespace Zeta {struct Symbol {
+	UInt64 id;
+
+	Z_INLINE Symbol() Z_DEFAULTED({})
+
+	Z_CT(CPP11) Symbol(UInt64 id)
+	: id(id) {}
+
+	Z_CT(CPP14) Symbol(const Char *string)
+	: id(Z_UINT64(14695981039346656037))
+		{while (*string) id = (id ^ *string++) * Z_UINT64(109951162821);}
+
+	Z_CT(CPP11) operator UInt64() const {return id;}
+
+	Z_CT(CPP11) Boolean operator ==(UInt64 id) const {return this->id == id;}
+	Z_CT(CPP11) Boolean operator !=(UInt64 id) const {return this->id != id;}
+};}
+
+
+#ifdef Z_USE_SYMBOL_ABBREVIATION
+#	define $( string) Zeta::Symbol(#string)
+#	define $$(string) Zeta::Symbol( string)
+#endif
+
+
+#endif // _Z_classes_base_Symbol_HPP_

data/src/external/Z/API/Z/classes/base/Tuple.hpp

@@ -0,0 +1,111 @@
+/* Z Kit - classes/base/Tuple.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_base_Tuple_HPP_
+#define _Z_classes_base_Tuple_HPP_
+
+#include <Z/inspection/language.h>
+
+#if Z_LANGUAGE_HAS(CPP, VARIADIC_TEMPLATE_EXTENDED_PARAMETERS)
+
+#	include <Z/traits/Type.hpp>
+
+
+	namespace Zeta {namespace Detail {namespace Tuple {
+
+		template <class type_list> class Element;
+
+
+		template <class... T> struct Super {
+			typedef Element<typename TypeListRotateRight<TypeList<T...>, 1>::type> type;
+		};
+
+
+		template <class T0>
+		struct Element<TypeList<T0> > {
+			typedef T0 Value;
+
+			Value value;
+
+			Z_INLINE Element() Z_DEFAULTED({})
+
+			Z_CT(CPP11) Element(typename Zeta::Type<T0>::to_forwardable value)
+			: value(value) {}
+		};
+
+
+		template <class TN, class... T>
+		struct Element<TypeList<TN, T...> > : Super<T...>::type {
+			typedef TN Value;
+
+			Value value;
+
+			Z_INLINE Element() Z_DEFAULTED({})
+
+			Z_CT(CPP11) Element(
+				typename Zeta::Type<T >::to_forwardable... previous,
+				typename Zeta::Type<TN>::to_forwardable value
+			) : Super<T...>::type(previous...), value(value) {}
+		};
+	}}}
+
+
+	namespace Zeta {template <class... T> class Tuple : public Detail::Tuple::Super<T...>::type {
+
+		private:
+		typedef typename Detail::Tuple::Super<T...>::type Super;
+
+		public:
+		template <UInt I> class At {
+
+			private:
+			enum {tail_size = TypeCount<T...>::value - (I + 1)};
+
+			public:
+			typedef Detail::Tuple::Element<typename TypeListRotateRight<
+				typename TypeListRemoveTail<TypeList<T...>, tail_size>::type, 1
+			>::type> Element;
+
+			typedef typename Element::Value type;
+		};
+
+
+#		if Z_LANGUAGE_HAS(CPP, INHERITING_CONSTRUCTORS)
+			using Super::Super;
+#		else
+			Z_INLINE Tuple() Z_DEFAULTED({})
+
+			Z_CT(CPP11) Tuple(typename Type<T>::to_forwardable... values)
+			: Super(values...) {}
+#		endif
+
+
+		template <UInt I>
+		Z_INLINE typename At<I>::type &at()
+			{return At<I>::Element::value;}
+
+
+		template <UInt I>
+		Z_CT(CPP11) typename Type<typename At<I>::type>::to_forwardable get() const
+			{return At<I>::Element::value;}
+
+
+		template <UInt I>
+		Z_INLINE Tuple &set(typename Type<typename At<I>::type>::to_forwardable value)
+			{
+			At<I>::Element::value = value;
+			return *this;
+			}
+	};}
+
+
+#	define Z_HAS_CLASS_Tuple TRUE
+#else
+#	define Z_HAS_CLASS_Tuple FALSE
+#endif
+
+#endif // _Z_classes_base_Tuple_HPP_