Polishing of Traits (b8c5cccd) · Commits · Tomáš Jakubec / GTMesh

src/GTMesh/Macros/MacroForEach.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -3,7 +3,7 @@

		/*
		* Macros FOR_EACH are supposed to repeat
		* any other macro for each argument passed as
		* any other macro for each argument passed through
		* variadic parameters.
		*/

src/GTMesh/Traits/CustomTypeTraits.h

+81 −85

Original line number	Diff line number	Diff line
		#ifndef CUSTOMTRAITS_H
		#define CUSTOMTRAITS_H
		#include "Traits.h"
		#include <iostream>
		#include <type_traits>
		#include "Traits.h"

		namespace Impl {

		@@ -12,119 +12,115 @@ using void_t = void;
		template<typename...>
		using bool_t = bool;


		template<typename T1, typename T2 = void>
		struct __is_exportable : public std::false_type {

		};
		struct is_exportable : public std::false_type
		{};

		template<typename T1>
		struct __is_exportable< T1,
		void_t<decltype(std::cerr << std::declval<const T1&>())> > : public std::true_type {};


		struct is_exportable<T1, void_t<decltype(std::cerr << std::declval<const T1 &>())>>
		: public std::true_type
		{};

		template<typename T1, typename T2 = void>
		struct __is_iterable : public std::false_type {};
		struct is_iterable : public std::false_type
		{};

		template<typename T1>
		struct __is_iterable< T1,
		void_t<decltype(std::declval<const T1&>().begin()), decltype (std::declval<const T1&>().end())> > : public std::true_type {};

		struct is_iterable<
		T1,
		void_t<decltype(std::declval<const T1 &>().begin()), decltype(std::declval<const T1 &>().end())>>
		: public std::true_type
		{};

		template<typename T1, typename T2 = void>
		struct __is_indexable : public std::false_type {};
		struct is_indexable : public std::false_type
		{};

		template<typename T1>
		struct __is_indexable< T1,
		void_t<decltype (std::declval<const T1&>()[0]), decltype (std::declval<const T1&>().size())> > : public std::true_type {};

		struct is_indexable<
		T1,
		void_t<decltype(std::declval<const T1 &>()[0]), decltype(std::declval<const T1 &>().size())>>
		: public std::true_type
		{};

		template<typename T1, typename T2 = void>
		struct __is_tnl_indexable : public std::false_type {};
		struct is_tnl_indexable : public std::false_type
		{};

		template<typename T1>
		struct __is_tnl_indexable< T1,
		void_t<decltype (std::declval<const T1&>()[0]), decltype (std::declval<const T1&>().getSize())> > : public std::true_type {};


		struct is_tnl_indexable<
		T1,
		void_t<decltype(std::declval<const T1 &>()[0]), decltype(std::declval<const T1 &>().getSize())>>
		: public std::true_type
		{};

		template<typename T1, typename VOID = void>
		struct __is_traits : public std::false_type {};

		struct is_traits : public std::false_type
		{};

		template<typename T1>
		struct __is_traits<
		T1,
		void_t<decltype(T1::isTraits)>
		> : public std::true_type {};

		struct is_traits<T1, void_t<decltype(T1::isTraits)>> : public std::true_type
		{};

		template<typename T1, typename VOID = void>
		struct __has_default_traits : public std::false_type {};

		struct has_default_traits : public std::false_type
		{};

		template<typename T1>
		struct __has_default_traits<
		T1,
		void_t<decltype(DefaultTraits<T1>::getTraits())>
		> : public std::true_type {};


		struct has_default_traits<T1, void_t<decltype(DefaultTraits<T1>::getTraits())>>
		: public std::true_type
		{};

		template<typename T1, typename = void>
		struct __has_default_io_traits : public std::false_type {};

		struct has_default_io_traits : public std::false_type
		{};

		template<typename T1>
		struct __has_default_io_traits<
		T1,
		void_t<decltype(DefaultIOTraits<T1>::getTraits())>
		> : public std::true_type {};


		struct has_default_io_traits<T1, void_t<decltype(DefaultIOTraits<T1>::getTraits())>>
		: public std::true_type
		{};

		template<typename T1, typename VOID = void>
		struct __has_default_arithmetic_traits : public std::false_type {};

		struct has_default_arithmetic_traits : public std::false_type
		{};

		template<typename T1>
		struct __has_default_arithmetic_traits<
		T1,
		void_t<decltype(DefaultArithmeticTraits<T1>::getTraits())>
		> : public std::true_type {};

		} // Impl namespace
		struct has_default_arithmetic_traits<T1, void_t<decltype(DefaultArithmeticTraits<T1>::getTraits())>>
		: public std::true_type
		{};

		} // namespace Impl

		template<typename T1>
		struct IsExportable : public Impl::__is_exportable<T1>
		struct IsExportable : public Impl::is_exportable<T1>
		{};


		template<typename T1>
		struct IsIterable : public Impl::__is_iterable<T1>
		struct IsIterable : public Impl::is_iterable<T1>
		{};

		template<typename T1>
		struct IsIndexable : public Impl::__is_indexable<T1>
		struct IsIndexable : public Impl::is_indexable<T1>
		{};

		template<typename T1>
		struct IsTNLIndexable : public Impl::__is_tnl_indexable<T1>
		struct IsTNLIndexable : public Impl::is_tnl_indexable<T1>
		{};


		template<typename T>
		struct IsTraits : public Impl::__is_traits<T> {};
		struct IsTraits : public Impl::is_traits<T>
		{};

		template<typename T>
		struct HasDefaultTraits : public Impl::__has_default_traits<T> {};
		struct HasDefaultTraits : public Impl::has_default_traits<T>
		{};

		template<typename T>
		struct HasDefaultIOTraits : public Impl::__has_default_io_traits<T> {};
		struct HasDefaultIOTraits : public Impl::has_default_io_traits<T>
		{};

		template<typename T>
		struct HasDefaultArithmeticTraits : public Impl::__has_default_arithmetic_traits<T> {};
		struct HasDefaultArithmeticTraits : public Impl::has_default_arithmetic_traits<T>
		{};

		#endif // CUSTOMTRAITS_H

src/GTMesh/Traits/FunctionTraits.h

+31 −31

Original line number	Diff line number	Diff line
		@@ -50,13 +50,15 @@ using void_t = void;
		// body for functor is empty if the operator() ambiguos
		// This happens, for example, when the F is the result of std::bind
		template<class F, typename = void>
		struct function_traits_body{};
		struct function_traits_body
		{};

		template<class F>
		struct function_traits_body<F, void_t<decltype(&F::operator())>>
		{
		private:
		using call_type = function_traits<decltype(&F::operator())>;

		public:
		using return_type = typename call_type::return_type;

		@@ -73,7 +75,6 @@ struct function_traits_body<F, void_t<decltype(&F::operator())>>
		using argument_t = typename argument<N>::type;
		};


		// functor
		template<class F>
		struct function_traits : public function_traits_body<F>
		@@ -87,5 +88,4 @@ template<class F>
		struct function_traits<F &&> : public function_traits<F>
		{};


		#endif // FUNCTION_TRAITS_H

src/GTMesh/Traits/MemberAccess/GetSetAccess.h

+38 −37

Original line number	Diff line number	Diff line
		@@ -21,18 +21,18 @@ private:
		const _getterType get;
		public:

		GetAccess(_getterType& g): get(g){};
		constexpr GetAccess(const _getterType& g): get(g){};

		GetAccess(const GetAccess< GetFunctor, Class >&) = default;
		constexpr GetAccess(const GetAccess< GetFunctor, Class >&) = default;

		GetAccess(GetAccess< GetFunctor, Class >&&) = default;
		constexpr GetAccess(GetAccess< GetFunctor, Class >&&) = default;


		auto getValue(const Class* c) const {
		inline auto getValue(const Class* c) const {
		return get(*c);
		}

		auto getValue(const Class& c) const {
		inline auto getValue(const Class& c) const {
		return get(c);
		}
		};
		@@ -48,18 +48,18 @@ private:
		using _getClassRef = std::remove_reference_t<typename function_traits<GetFunctor>::template argument<0>::type>;
		public:

		GetAccess(_getterType& g): get(g){};
		constexpr GetAccess(const _getterType& g): get(g){};

		GetAccess(const GetAccess<GetFunctor, std::enable_if_t<!std::is_member_pointer<GetFunctor>::value && !std::is_bind_expression<GetFunctor>::value, void>>&) = default;
		constexpr GetAccess(const GetAccess<GetFunctor, std::enable_if_t<!std::is_member_pointer<GetFunctor>::value && !std::is_bind_expression<GetFunctor>::value, void>>&) = default;

		GetAccess(GetAccess<GetFunctor, std::enable_if_t<!std::is_member_pointer<GetFunctor>::value && !std::is_bind_expression<GetFunctor>::value, void>>&&) = default;
		constexpr GetAccess(GetAccess<GetFunctor, std::enable_if_t<!std::is_member_pointer<GetFunctor>::value && !std::is_bind_expression<GetFunctor>::value, void>>&&) = default;


		auto getValue(_getClassRef* c) const {
		inline auto getValue(_getClassRef* c) const {
		return get(*c);
		}

		auto getValue(_getClassRef& c) const {
		inline auto getValue(_getClassRef& c) const {
		return get(c);
		}
		};
		@@ -76,21 +76,21 @@ private:
		using _getClassRef = std::remove_reference_t<typename function_traits<GetFunctor>::template argument<0>::type>;
		public:

		GetAccess(_getterType& g): get(g){};
		constexpr GetAccess(const _getterType& g): get(g){};

		GetAccess(const GetAccess<GetFunctor, std::enable_if_t<std::is_member_pointer<GetFunctor>::value, void>>&) = default;
		constexpr GetAccess(const GetAccess<GetFunctor, std::enable_if_t<std::is_member_pointer<GetFunctor>::value, void>>&) = default;

		GetAccess(GetAccess<GetFunctor, std::enable_if_t<std::is_member_pointer<GetFunctor>::value, void>>&&) = default;
		constexpr GetAccess(GetAccess<GetFunctor, std::enable_if_t<std::is_member_pointer<GetFunctor>::value, void>>&&) = default;


		auto getValue(_getClassRef* c) const {
		inline auto getValue(_getClassRef* c) const {
		return (c->*get)();
		}

		/**
		* @brief Returns a value of a member of the object c.
		*/
		auto getValue(_getClassRef& c) const {
		inline auto getValue(_getClassRef& c) const {
		return (c.*get)();
		}
		};
		@@ -102,20 +102,20 @@ struct SetAccess{
		private:
		const _setterType set;
		public:
		SetAccess(const _setterType& s): set(s){}

		constexpr SetAccess(const _setterType& s): set(s){}

		SetAccess(const SetAccess<SetFunctor, Spec>&) = default;
		constexpr SetAccess(const SetAccess<SetFunctor, Spec>&) = default;

		SetAccess(SetAccess<SetFunctor, Spec>&&) = default;
		constexpr SetAccess(SetAccess<SetFunctor, Spec>&&) = default;

		template<typename typeClass, typename typeValue>
		void setValue(typeClass* c, const typeValue& val) const {
		inline void setValue(typeClass* c, const typeValue& val) const {
		set(c, val);
		}

		template<typename typeClass, typename typeValue>
		void setValue(typeClass& c, const typeValue& val) const {
		inline void setValue(typeClass& c, const typeValue& val) const {
		set(c, val);
		}
		};
		@@ -131,15 +131,15 @@ struct SetAccess<SetFunctor, std::enable_if_t<!std::is_member_pointer<SetFunctor
		private:
		const _setterType set;
		public:
		SetAccess(const _setterType& s): set(s){}

		constexpr SetAccess(const _setterType& s): set(s){}

		void setValue(_typeClass* c, const _typeValue& val) const {
		inline void setValue(_typeClass* c, const _typeValue& val) const {
		set(c, val);
		}


		void setValue(_typeClass& c, const _typeValue& val) const {
		inline void setValue(_typeClass& c, const _typeValue& val) const {
		set(c, val);
		}

		@@ -158,25 +158,24 @@ struct SetAccess<SetFunctor, std::enable_if_t<!std::is_member_pointer<SetFunctor
		private:
		const _setterType set;
		public:
		SetAccess(const _setterType& s): set(s){}

		constexpr SetAccess(const _setterType& s): set(s){}


		void setValue(_typeClass* c, const _typeValue& val) const {
		inline void setValue(_typeClass* c, const _typeValue& val) const {
		set(c) = val;
		}


		void setValue(_typeClass& c, const _typeValue& val) const {
		inline void setValue(_typeClass& c, const _typeValue& val) const {
		set(c) = val;
		}

		auto& getAttr(_typeClass* c) const {
		inline auto& getAttr(_typeClass* c) const {
		return set(c);
		}


		auto& getAttr(_typeClass& c) const {
		inline auto& getAttr(_typeClass& c) const {
		return set(c);
		}
		};
		@@ -191,14 +190,14 @@ private:
		private:
		const _setterType set;
		public:
		SetAccess(const _setterType& s): set(s){}
		constexpr SetAccess(const _setterType& s): set(s){}

		void setValue(_typeClass* c, const _typeValue& val) const {
		inline void setValue(_typeClass* c, const _typeValue& val) const {
		(c->*set)(val);
		}


		void setValue(_typeClass& c, const _typeValue& val) const {
		inline void setValue(_typeClass& c, const _typeValue& val) const {
		(c.*set)(val);
		}
		};
		@@ -214,25 +213,27 @@ private:
		private:
		const _setterType set;
		public:
		SetAccess(const _setterType& s): set(s){}


		constexpr SetAccess(const _setterType& s): set(s){}



		void setValue(_typeClass* c, const _typeValue& val) const {
		inline void setValue(_typeClass* c, const _typeValue& val) const {
		(c->*set)() = val;
		}


		void setValue(_typeClass& c, const _typeValue& val) const {
		inline void setValue(_typeClass& c, const _typeValue& val) const {
		(c.*set)() = val;
		}

		auto& getAttr(_typeClass* c) const {
		inline auto& getAttr(_typeClass* c) const {
		return (c->*set)();
		}


		auto& getAttr(_typeClass& c) const {
		inline auto& getAttr(_typeClass& c) const {
		return (c.*set)();
		}
		};

src/GTMesh/Traits/MemberAccess/MemberAccess.h

+23 −25

Original line number	Diff line number	Diff line
		@@ -11,7 +11,7 @@ class MemberAccess{
		"The type Ref must be reference to member (ValueType Class::*),"
		" member function or pointer to getter and setter");
		public:
		MemberAccess(Ref);
		constexpr MemberAccess(Ref);
		};


		@@ -23,40 +23,38 @@ public:
		using refType = ValueType Class::*;

		private:
		const refType ref;
		const refType mReference;

		public:

		MemberAccess(refType referenceToMember) : ref(referenceToMember){
		//ref = referenceToMember;
		}
		constexpr MemberAccess(const refType& referenceToMember) : mReference(referenceToMember) {}

		MemberAccess(const MemberAccess<Class, ValueType Class::*, void>&) = default;
		constexpr MemberAccess(const MemberAccess<Class, ValueType Class::*, void>&) = default;

		MemberAccess(MemberAccess<Class, ValueType Class::*, void>&&) = default;
		constexpr MemberAccess(MemberAccess<Class, ValueType Class::*, void>&&) = default;

		ValueType getValue(const Class* c) const {
		return c->*ref;
		inline ValueType getValue(const Class* c) const {
		return c->*mReference;
		}

		void setValue(Class* c, const ValueType& val) const {
		c->*ref = val;
		inline void setValue(Class* c, const ValueType& val) const {
		c->*mReference = val;
		}

		ValueType& getAttr(Class* c) const {
		return c->*ref;
		inline ValueType& getAttr(Class* c) const {
		return c->*mReference;
		}

		ValueType getValue(const Class& c) const {
		return c.*ref;
		inline ValueType getValue(const Class& c) const {
		return c.*mReference;
		}

		void setValue(Class& c, const ValueType& val) const {
		c.*ref = val;
		inline void setValue(Class& c, const ValueType& val) const {
		c.*mReference = val;
		}

		ValueType& getAttr(Class& c) const {
		return c.*ref;
		inline ValueType& getAttr(Class& c) const {
		return c.*mReference;
		}
		};

		@@ -72,13 +70,13 @@ public:

		public:

		MemberAccess(std::pair<GetFunctor, SetFunctor> getSet)
		constexpr MemberAccess(const std::pair<GetFunctor, SetFunctor>& getSet)
		: Impl::GetAccess<GetFunctor>(getSet.first), Impl::SetAccess<SetFunctor>(getSet.second)
		{}

		MemberAccess(const MemberAccess<Class, std::pair<GetFunctor, SetFunctor>, std::enable_if_t<!std::is_bind_expression<GetFunctor>::value>>&) = default;
		constexpr MemberAccess(const MemberAccess<Class, std::pair<GetFunctor, SetFunctor>, std::enable_if_t<!std::is_bind_expression<GetFunctor>::value>>&) = default;

		MemberAccess(MemberAccess<Class, std::pair<GetFunctor, SetFunctor>, std::enable_if_t<!std::is_bind_expression<GetFunctor>::value>>&&) = default;
		constexpr MemberAccess(MemberAccess<Class, std::pair<GetFunctor, SetFunctor>, std::enable_if_t<!std::is_bind_expression<GetFunctor>::value>>&&) = default;

		};

		@@ -93,13 +91,13 @@ public:

		public:

		MemberAccess(std::pair<GetFunctor, SetFunctor> getSet)
		constexpr MemberAccess(const std::pair<GetFunctor, SetFunctor>& getSet)
		: Impl::GetAccess<GetFunctor, Class>(getSet.first), Impl::SetAccess<SetFunctor>(getSet.second)
		{}

		MemberAccess(const MemberAccess<Class, std::pair<GetFunctor, SetFunctor>, std::enable_if_t<std::is_bind_expression<GetFunctor>::value> >&) = default;
		constexpr MemberAccess(const MemberAccess<Class, std::pair<GetFunctor, SetFunctor>, std::enable_if_t<std::is_bind_expression<GetFunctor>::value> >&) = default;

		MemberAccess(MemberAccess<Class, std::pair<GetFunctor, SetFunctor>, std::enable_if_t<std::is_bind_expression<GetFunctor>::value> >&&) = default;
		constexpr MemberAccess(MemberAccess<Class, std::pair<GetFunctor, SetFunctor>, std::enable_if_t<std::is_bind_expression<GetFunctor>::value> >&&) = default;

		};