The print to jsonlike debug works well. (43895b00) · Commits · Tomáš Jakubec / GTMesh

TemplateTest/main.cpp

+25 −15

Original line number	Diff line number	Diff line
		@@ -252,7 +252,7 @@ struct tempData {
		return density;
		}

		Vector<3,double> getMomentum(){
		Vector<3,double> getMomentum()const{
		return velocity*density;
		}

		@@ -262,11 +262,6 @@ struct tempData {

		};


		//MAKE_NAMED_ATRIBUTE_TRAIT(tempData, "density", density, "velocity", velocity);
		//MAKE_ATRIBUTE_TRAIT(tempData, density, velocity);

		MAKE_CUSTOM_ATTRIBUTE_TRAIT(tempData, "density", &tempData::density, "momentum", std::make_pair(&tempData::getMomentum, &tempData::setMomentum))
		/*
		template<>
		class Traits<tempData>{
		@@ -278,9 +273,21 @@ public:
		const Traits<tempData>::ttype Traits<tempData>::tr("density", &tempData::density, "momentum"s, std::make_pair(&tempData::getMomentum, &tempData::setMomentum));
		*/

		#define STR(x) #x
		#define CATTR(Class, attr) STR(typename MemberReferenceType<decltype(&Class::attr)>::type)
		#define TEST_M(Class, name, attr) name, CATTR(Class, attr)
		//MAKE_NAMED_ATRIBUTE_TRAIT(tempData, "density", density, "velocity", velocity);
		//MAKE_ATRIBUTE_TRAIT(tempData, density, velocity);

		MAKE_CUSTOM_ATTRIBUTE_TRAIT(tempData, "density", &tempData::density, "momentum", std::make_pair(&tempData::getMomentum, &tempData::setMomentum))

		struct ExportTest {
		int attrInt = 1;
		double attrDouble = 42.15;
		char attrChar = 42;
		std::string attrStr = "Ahojky";
		std::vector<std::string> attrVec = {"tohle", "je", "nejlepsi", "debugovaci", "system"};
		tempData attrTempData{42.15, {1,2,1}};
		};
		MAKE_ATRIBUTE_TRAIT(ExportTest, attrInt, attrDouble, attrChar, attrStr, attrVec, attrTempData);

		void testMemberRef(){


		@@ -288,13 +295,16 @@ void testMemberRef(){

		//DBGVAR(Traits<tempData>::ttype::getName<0>());

		Traits<tempData>::tr.getReference<0>()->setValue(&d, 0.0);
		DBGVAR(Traits<tempData>::tr.getReference<0>()->getValue(&d));
		Traits<tempData>::ttype::getReference<0>()->setValue(&d, 42.15);
		Traits<tempData>::ttype::getReference<0>()->setValue(&d, 0.0);
		DBGVAR(Traits<tempData>::ttype::getReference<0>()->getValue(&d));
		Traits<tempData>::ttype::getReference<0>()->setValue(d, 42.15);
		Traits<tempData>::ttype::getReference<1>()->setValue(&d, {42.15,84.30,42.15});

		DBGVAR(Traits<tempData>::ttype::getName<0>(),(Traits<tempData>::ttype::getReference<0>()->getValue(&d)), Traits<tempData>::ttype::getName<1>(),(Traits<tempData, double, Vector<3,double>>::getReference<1>()->getValue(&d)), d.velocity);
		DBGVAR(Traits<tempData>::is_specialized,Detail::has_default_traits<tempData>::value, d);

		ExportTest e;
		DBGVAR(e);
		}


		@@ -306,7 +316,7 @@ void testMemberRef(){
		/*
		Test of order of constructors
		*/

		/*
		struct mem{
		std::string s;
		mem(){DBGVAR(s);}
		@@ -397,7 +407,7 @@ void testConstrucorOrder() {
		C2<void> c1;
		DBGVAR(C2_::c.s1.s, C2<void>::c.getS(), C::getS(), C2_wrong<void>::c.getS());
		}

		*/

		void testOrig() {
		Vertex<5, double> vert;
		@@ -474,7 +484,7 @@ int main()
		DBGVAR(b2.first,b2.second);
		*/
		testMemberRef();
		testConstrucorOrder();
		//testConstrucorOrder();
		/*
		std::function<int(int)> fce = [&b1](int i){return b1.data + 42 + i;};

Unstructured_mesh/UnstructuredMesh/MeshDataContainer/MemberApproach.h

+230 −90

Original line number	Diff line number	Diff line
		@@ -3,142 +3,282 @@
		#include <type_traits>
		#include <utility>

		template<typename Class, typename MA>
		class MemberApproachBase{

		auto getValue(Class* c){
		return static_cast<MA*>(this)->getValue(c);
		}

		template<typename ValueType>
		void setValue(Class* c, const ValueType& val) {
		static_cast<MA*>(this)->setValue(c, val);
		}
		};


		/**
		* @brief The MemberApproach class
		* Generic abstract class providing the
		*/
		template <typename Class, typename ValueType>
		class MemberApproach{
		public:
		virtual ValueType getValue(Class*) = 0;
		virtual ValueType getValue(const Class*) = 0;
		virtual void setValue(Class*, const ValueType&) = 0;

		virtual ValueType getValue(const Class&) = 0;
		virtual void setValue(Class&, const ValueType&) = 0;
		};


		template<typename Class, typename ValueType, typename Ref>
		class MemberReference{
		static_assert (std::is_same<Ref, ValueType Class::*>::value,
		"The type MemberRef must be reference to member ValueType Class::* or pointer to getter and setter");
		MemberReference(Ref);
		};


		template <typename Class, typename ValueType>
		class MemberReference{
		class MemberReference<Class, ValueType, ValueType Class::*> : public MemberApproach<Class, ValueType>{

		public:
		template<typename Ref, typename VOID = void>
		class Reference{
		static_assert (std::is_same<Ref, ValueType Class::>::value, "The type MemberRef must be reference to member ValueType Class:: or pointer to getter and setter");
		using refType = ValueType Class::*;
		refType ref;

		public:
		Reference(Ref){}

		MemberReference(refType referenceToMember){
		ref = referenceToMember;
		}

		virtual ValueType getValue(const Class* c) override {
		return c->*ref;
		}

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

		virtual ValueType getValue(const Class& c) override {
		return c.*ref;
		}

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


		template<typename Ref>
		class SuperRef: public Reference<Ref, void>{
		template <typename Class, typename ValueType>
		class MemberReference<Class, ValueType, ValueType& (Class::*)()> : public MemberApproach<Class, ValueType>{

		using refType = ValueType& (Class::*)();

		refType ref;

		public:
		SuperRef(Ref ref): Reference<Ref, void> (ref){}

		MemberReference(refType referenceToMember){
		ref = referenceToMember;
		}

		virtual ValueType getValue(const Class* c) override {
		return (c->*ref)();
		}

		virtual void setValue(Class* c, const ValueType& val) override {
		(c->*ref)() = val;
		}
		virtual ValueType getValue(const Class& c) override {
		return (c.*ref)();
		}

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

		};


		template<typename Ref>
		class Reference<
		Ref,
		// enable if MemberRef is pointer to member
		typename std::enable_if<
		std::is_same<Ref, ValueType Class::*>::value
		>::type


		template <typename Class, typename ValueType>
		class MemberReference<
		Class,
		ValueType,
		std::pair<ValueType (Class::)(), void (Class::)(const ValueType&)>
		>
		: public MemberApproach<Class, ValueType>{

		Ref ref;
		using getter = ValueType (Class::*)();
		getter refGet;
		using setter = void (Class::*)(const ValueType&);
		setter refSet;

		public:

		Reference(Ref referenceToMember){
		ref = referenceToMember;
		MemberReference(std::pair<getter, setter> getSet){
		refGet = getSet.first;
		refSet = getSet.second;
		}

		virtual ValueType getValue(Class* c) override {
		return c->*ref;
		virtual ValueType getValue(const Class* c) override {
		return (c->*refGet)();
		}

		virtual void setValue(Class* c, const ValueType& val) override {
		c->*ref = val;
		(c->*refSet)(val);
		}

		virtual ValueType getValue(const Class& c) override {
		return (c.*refGet)();
		}

		virtual void setValue(Class& c, const ValueType& val) override {
		(c.*refSet)(val);
		}
		};


		template <typename Class, typename ValueType>
		class MemberReference<
		Class,
		ValueType,
		std::pair<ValueType (Class::)() const, void (Class::)(const ValueType&)>
		>
		: public MemberApproach<Class, ValueType>{

		using getter = ValueType (Class::*)() const;
		getter refGet;
		using setter = void (Class::*)(const ValueType&);
		setter refSet;

		public:

		MemberReference(std::pair<getter, setter> getSet){
		refGet = getSet.first;
		refSet = getSet.second;
		}

		virtual ValueType getValue(const Class* c) override {
		return (c->*refGet)();
		}

		template<typename Ref>
		class Reference<
		Ref,
		// enable if MemberRef is pointer to member
		typename std::enable_if<
		std::is_same<Ref, ValueType& (Class::*)()>::value
		>::type
		virtual void setValue(Class* c, const ValueType& val) override {
		(c->*refSet)(val);
		}

		virtual ValueType getValue(const Class& c) override {
		return (c.*refGet)();
		}

		virtual void setValue(Class& c, const ValueType& val) override {
		(c.*refSet)(val);
		}
		};


		template <typename Class, typename ValueType>
		class MemberReference<
		Class,
		ValueType,
		std::pair<const ValueType& (Class::)() const, void (Class::)(const ValueType&)>
		>
		: public MemberApproach<Class, ValueType>{

		Ref ref;
		using getter = const ValueType& (Class::*)() const;
		getter refGet;
		using setter = void (Class::*)(const ValueType&);
		setter refSet;

		public:

		Reference(Ref referenceToMember){
		ref = referenceToMember;
		DBGVAR((std::is_same<Ref, ValueType Class::*>::value));
		MemberReference(std::pair<getter, setter> getSet){
		refGet = getSet.first;
		refSet = getSet.second;
		}

		virtual ValueType getValue(Class* c) override {
		return (c->*ref)();
		virtual ValueType getValue(const Class* c) override {
		return (c->*refGet)();
		}

		virtual void setValue(Class* c, const ValueType& val) override {
		(c->*ref)() = val;
		(c->*refSet)(val);
		}
		};

		virtual ValueType getValue(const Class& c) override {
		return (c.*refGet)();
		}

		virtual void setValue(Class& c, const ValueType& val) override {
		(c.*refSet)(val);
		}
		};


		template<typename MemberRefGet, typename MemberRefSet>
		class Reference<
		std::pair<MemberRefGet, MemberRefSet>,
		// enable if MemberRef is pointer to member
		typename std::enable_if<
		std::is_same<MemberRefGet, ValueType (Class::*)()>::value &&
		std::is_same<MemberRefSet, void (Class::*)(const ValueType&)>::value
		>::type
		template <typename Class, typename ValueType>
		class MemberReference<
		Class,
		ValueType,
		std::pair<const ValueType& (Class::)(), void (Class::)(const ValueType&)>
		>
		: public MemberApproach<Class, ValueType>{

		MemberRefGet refGet;
		MemberRefSet refSet;
		using getter = const ValueType& (Class::*)();
		getter refGet;
		using setter = void (Class::*)(const ValueType&);
		setter refSet;

		public:

		Reference(std::pair<MemberRefGet, MemberRefSet> getSet){
		MemberReference(std::pair<getter, setter> getSet){
		refGet = getSet.first;
		refSet = getSet.second;
		}

		virtual ValueType getValue(Class* c) override {
		virtual ValueType getValue(const Class* c) override {
		return (c->*refGet)();
		}

		virtual void setValue(Class* c, const ValueType& val) override {
		(c->*refSet)(val);
		}

		virtual ValueType getValue(const Class& c) override {
		return (c.*refGet)();
		}

		virtual void setValue(Class& c, const ValueType& val) override {
		(c.*refSet)(val);
		}
		};



		template <typename Ref>
		struct MemberReferenceType {
		static_assert (std::is_trivial_v<Ref>, "The Ref must be a type of member reference (MemberType Class::) or reference getter (MemberType& (Class::)()) into class \
		or a pair of getter and setter (std::pair<MemberType (Class::)(), void (Class::)(const MemberType&))");
		};

		template <typename Class, typename MemberType>
		struct MemberReferenceType <MemberType Class::*>{
		using type = MemberType;
		};


		template <typename Class, typename MemberType>
		struct MemberReferenceType <MemberType& (Class::*)()>{
		using type = MemberType;
		};


		template <typename Class, typename MemberType>
		struct MemberReferenceType <std::pair<MemberType (Class::)(), void (Class::)(const MemberType&)>>{
		using type = MemberType;
		};

		template <typename Class, typename MemberType>
		struct MemberReferenceType <std::pair<MemberType (Class::)()const, void (Class::)(const MemberType&)>>{
		using type = MemberType;
		};

		template <typename Class, typename MemberType>
		struct MemberReferenceType <std::pair<const MemberType& (Class::)()const, void (Class::)(const MemberType&)>>{
		using type = MemberType;
		};

		template <typename Class, typename MemberType>
		struct MemberReferenceType <std::pair<const MemberType& (Class::)(), void (Class::)(const MemberType&)>>{
		using type = MemberType;
		};

		#endif // MEMBERAPPROACH_H

Unstructured_mesh/UnstructuredMesh/MeshDataContainer/Singleton.h

+5 −5

Original line number	Diff line number	Diff line
		#ifndef SINGLETON_H
		#define SINGLETON_H
		#include <type_traits>
		#include <memory>



		template<class Class>
		/**
		* @brief The Singleton class
		*/
		template<class Class>
		class Singleton {
		//static_assert (std::is_trivially_constructible<Class>::value, "The class in singleton must be trivially constructible.");
		public:
		static Class& getInstance(){
		if (p == nullptr) {
		p = new Class; // the class must be trivially constructible
		p = std::unique_ptr<Class>(new Class); // the class must be trivially constructible
		}
		return *p;
		}
		protected:
		static Class* p;
		static std::unique_ptr<Class> p;
		Singleton() {}
		private:
		// disable move and copy options
		@@ -28,7 +28,7 @@ private:
		Singleton& operator=(Singleton const&&) = delete;

		};
		template <class Class> Class* Singleton<Class>::p = nullptr;
		template <class Class> std::unique_ptr<Class> Singleton<Class>::p = nullptr;

Unstructured_mesh/UnstructuredMesh/MeshDataContainer/Traits.h

+13 −39

Original line number	Diff line number	Diff line
		#ifndef TRAITS_H
		#define TRAITS_H
		#include "MemberApproach.h"
		#include "../debug/Debug.h"
		#include <string>
		#include <memory>
		#include "Singleton.h"
		@@ -14,20 +13,20 @@ class Traits {

		template<unsigned int Index = sizeof...(Types) - 1, typename Dummy = void>
		struct MemRefs: public MemRefs<Index - 1>{
		friend class Singleton<MemRefs<1, void>>;
		std::unique_ptr<MemberApproach<Class, type<Index>>> ref = nullptr;
		std::string name;
		MemRefs(){
		DBGVAR(this->name, Index);
		}
		// private:
		MemRefs(){}
		};

		template<typename Dummy>
		struct MemRefs<0, Dummy>{
		friend class Singleton<MemRefs<0, void>>;
		std::unique_ptr<MemberApproach<Class, type<0>>> ref = nullptr;
		std::string name;
		MemRefs(){
		DBGVAR(this->name, 0);
		}
		//private:
		MemRefs(){}
		};

		using refs = Singleton<MemRefs<sizeof... (Types) - 1, void>>;
		@@ -41,16 +40,14 @@ class Traits {
		template<unsigned int Pos, typename ref>
		static void _makeReferences(const std::string& name, ref member) {
		refs::getInstance().MemRefs<Pos, void>::name = name;
		DBGVAR((refs::getInstance().MemRefs<Pos, void>::name));
		getReference<Pos>() = std::unique_ptr<MemberApproach<Class, type<Pos>>>(new typename MemberReference<Class, type<Pos>>::template SuperRef<ref>(member));
		getReference<Pos>() = std::unique_ptr<MemberApproach<Class, type<Pos>>>(new MemberReference<Class, type<Pos>, decltype(member)>(member));
		}


		template<unsigned int Pos, typename ref>
		static void _makeReferences(const char* name, ref member) {
		refs::getInstance().MemRefs<Pos, void>::name = name;
		DBGVAR((refs::getInstance().MemRefs<Pos, void>::name));
		getReference<Pos>() = std::unique_ptr<MemberApproach<Class, type<Pos>>>(new typename MemberReference<Class, type<Pos>>::template SuperRef<ref>(member));
		getReference<Pos>() = std::unique_ptr<MemberApproach<Class, type<Pos>>>(new MemberReference<Class, type<Pos>, decltype(member)>(member));
		}


		@@ -76,9 +73,7 @@ public:

		template<typename...Refs>
		Traits(Refs... refsAndNames){
		DBGMSG("making refs");
		makeReferences(refsAndNames...);
		DBGVAR(getName<0>(), getName<1>());
		}

		template<typename...Refs>
		@@ -92,50 +87,29 @@ public:



		template <typename Ref>
		struct MemberReferenceType {
		static_assert (std::is_trivial_v<Ref>, "The Ref must be a type of member reference (MemberType Class::) or reference getter (MemberType& (Class::)()) into class \
		or a pair of getter and setter (std::pair<MemberType (Class::)(), void (Class::)(const MemberType&))");
		};

		template <typename Class, typename MemberType>
		struct MemberReferenceType <MemberType Class::*>{
		using type = MemberType;
		};


		template <typename Class, typename MemberType>
		struct MemberReferenceType <MemberType& (Class::*)()>{
		using type = MemberType;
		};


		template <typename Class, typename MemberType>
		struct MemberReferenceType <std::pair<MemberType (Class::)(), void (Class::)(const MemberType&)>>{
		using type = MemberType;
		};


		template<typename Class>
		class Traits<Class>: public std::false_type{
		static_assert (true, "The Traits template must be specialized for given type and must contain Traits references using variadic Traits.");
		public:
		static constexpr std::false_type is_specialized{};
		};



		#include "../../../Macros/MacroForEach.h"


		#define MEMREF_TYPE_CUSTOM(name, memberRef) typename MemberReferenceType<decltype(memberRef)>::type
		#define MAKE_CUSTOM_ATTRIBUTE_TRAIT(Class,...)\
		template<> \
		class Traits<Class>: public std::true_type{ \
		class Traits<Class>{ \
		public: \
		static constexpr std::true_type is_specialized{}; \
		using ttype = Traits<Class, FOR_EACH_2ARGS(MEMREF_TYPE_CUSTOM, __VA_ARGS__)>; \
		const static ttype tr; \
		Traits(){DBGMSG("TRAITS");}\
		}; \
		const Traits<Class>::ttype Traits<Class>::tr(__VA_ARGS__);
		const Traits<Class>::ttype Traits<Class>::tr(__VA_ARGS__); \

		#define NAME_AND_REF(Class, name, member) name, &Class::member

Unstructured_mesh/Unstructured_mesh.pro.user

+1 −1

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="UTF-8"?>
		<!DOCTYPE QtCreatorProject>
		<!-- Written by QtCreator 4.10.0, 2019-11-03T13:07:04. -->
		<!-- Written by QtCreator 4.10.0, 2019-11-03T16:14:20. -->
		<qtcreator>
		<data>
		<variable>EnvironmentId</variable>