JSON integration, maybe any smaller library would be enough. (c9bdd18f) · Commits · Tomáš Jakubec / GTMesh

TemplateTest/main.cpp

+241 −3

Original line number	Original line	Diff line number	Diff line
	@@ -6,6 +6,8 @@
	#include <type_traits>		#include <type_traits>
	#include <iostream>		#include <iostream>
	#include <list>		#include <list>
			#include <unordered_map>
			#include <functional>
	#include <map>		#include <map>
	using namespace std;		using namespace std;

	@@ -62,8 +64,8 @@ void testDebug() {
	{"druhy", 2},		{"druhy", 2},
	{"treti", 3}		{"treti", 3}
	};		};
	ConsoleLogger::writeVar(__LINE__, __FILE__, "r", r, "i", i, "c", c, "list", list, "vec", vec, "b", b, "map", m);		ConsoleLogger<>::writeVar(__LINE__, __FILE__, "r", r, "i", i, "c", c, "list", list, "vec", vec, "b", b, "map", m);
	ConsoleLogger::writeVar(__LINE__, __FILE__,"---", {5,4,3,2});		ConsoleLogger<>::writeVar(__LINE__, __FILE__,"---", {5,4,3,2});
	DBGVAR(r, i, c, list, vec, b, m);		DBGVAR(r, i, c, list, vec, b, m);

	Vertex<7, double> vert;		Vertex<7, double> vert;
	@@ -991,6 +993,239 @@ void testCalcCent() {
	calcCent<0,3, TESSELLATED>::run();		calcCent<0,3, TESSELLATED>::run();
	}		}


			/*
			test of custom hash
			*/
			namespace std {
			template<typename IndexType>
			class hash<std::vector<IndexType>>{
			public:
			size_t operator()(const std::vector<IndexType>& v) const {

			std::string_view sv(reinterpret_cast<const char>(v.data()), sizeof(IndexType) v.size());
			return std::hash<std::string_view>{}(sv);
			}
			};

			template<unsigned int Dim, typename Real>
			class hash<Vertex<Dim, Real>>{
			public:
			size_t operator()(const Vertex<Dim, Real>& vert) const {

			std::string_view sv(reinterpret_cast<const char>(&vert), sizeof(Real) vert.size());
			return std::hash<std::string_view>{}(sv);
			}

			};
			}

			void testCustomUnorderedMap() {
			std::unordered_map<std::vector<size_t>, size_t> m;

			std::vector<size_t> v = {1,2,3};
			std::vector<size_t> v2 = {3,2,1};

			std::sort(v2.begin(), v2.end());
			DBGVAR(v == v2, sizeof(std::vector<size_t>), sizeof(std::string));


			DBGVAR(m[v] = 1, m[v2]);

			Vertex<3, double> vert1 = {1,2,3};

			std::unordered_map<Vertex<3,double>, size_t> mm;

			DBGVAR(mm[vert1] = 3);
			DBGVAR(*mm.begin(), sizeof(decltype(vert1)));


			std::set<int> s = {1,15,6,8};

			std::vector<int> vec(4);
			std::vector<int> vec2;

			std::copy(s.begin(), s.end(), vec.begin());

			//std::copy(s.begin(), s.end(), std::inserter(vec2, vec2.begin()));

			vec2.insert(vec2.begin(),s.begin(), s.end());

			std::vector<int> vec3(s.begin(), s.end());

			DBGVAR(vec,s, vec2, vec.capacity(), vec2.capacity(), vec3);
			}


			struct privateAttr{
			private:
			std::string attr = "attr";
			public:
			const std::string& getAttr(){return attr;}
			friend Traits<privateAttr>;
			};

			MAKE_NAMED_ATTRIBUTE_TRAIT(privateAttr, "str_attr", attr);

			//#include <ciso646>
			void testPrivateTrait(){
			privateAttr a;
			DBGVAR(a);
			Traits<privateAttr>::ttype::setValue<0>(a, "new value");
			DBGVAR(a);

			}

			#include "json.hpp"


			struct person{
			std::string name, surname;

			struct address {
			std::string address;
			int num;
			} addr;
			};

			MAKE_ATTRIBUTE_TRAIT(person::address, address, num);
			MAKE_ATTRIBUTE_TRAIT(person, name, surname, addr);

			using json = nlohmann::json;

			template <unsigned int Index>
			struct TraitToJson {
			template<typename traitedClass>
			static
			typename enable_if<
			(Traits<traitedClass>::ttype::size() - 1 > Index)
			>::type
			to_json(json& j, const traitedClass& t) {

			// j.at(Traits<traitedClass>::ttype::template getName<Index>()) = Traits<traitedClass>::ttype::template getValue<Index>(t);
			j.push_back({Traits<traitedClass>::ttype::template getName<Index>(), Traits<traitedClass>::ttype::template getValue<Index>(t)});
			TraitToJson<Index + 1>::to_json(j, t);
			}


			template<typename traitedClass>
			static
			typename enable_if<
			(Traits<traitedClass>::ttype::size() - 1 == Index)
			>::type
			to_json(json& j, const traitedClass& t) {

			j.push_back({Traits<traitedClass>::ttype::template getName<Index>(), Traits<traitedClass>::ttype::template getValue<Index>(t)});
			//j.at(Traits<traitedClass>::ttype::template getName<Index>()) = Traits<traitedClass>::ttype::template getValue<Index>(t);

			}
			};

			template<typename traitedClass>
			typename
			std::enable_if<
			HasDefaultTraits<traitedClass>::value
			>::type
			to_json(json& j, const traitedClass& t){
			j = json::object();
			TraitToJson<0>::to_json(j, t);
			}


			template <unsigned int Index>
			struct JsonToTrait {
			template<typename traitedClass>
			static
			typename enable_if<
			(Traits<traitedClass>::ttype::size() - 1 > Index)
			>::type
			from_json(const json& j, traitedClass& t) {

			Traits<traitedClass>::ttype::template setValue<Index>(
			t,
			j.at(Traits<traitedClass>::ttype::template getName<Index>()).template get<typename Traits<traitedClass>::ttype::template type<Index>>()
			);
			JsonToTrait<Index + 1>::from_json(j, t);
			}


			template<typename traitedClass>
			static
			typename enable_if<
			(Traits<traitedClass>::ttype::size() - 1 == Index)
			>::type
			from_json(const json& j, traitedClass& t) {

			Traits<traitedClass>::ttype::template setValue<Index>(
			t,
			j.at(Traits<traitedClass>::ttype::template getName<Index>()).template get<typename Traits<traitedClass>::ttype::template type<Index>>()
			);

			}
			};

			template<typename traitedClass>
			typename
			std::enable_if<
			HasDefaultTraits<traitedClass>::value
			>::type
			from_json(const json& j, traitedClass& t) {
			JsonToTrait<0>::from_json(j,t);
			}

			namespace ns {
			// a simple struct to model a person
			struct person {
			std::string name;
			std::string address;
			int age;
			};
			}
			namespace ns {
			void to_json(json& j, const person& p) {
			j = json{{"name", p.name}, {"address", p.address}, {"age", p.age}};
			}

			void from_json(const json& j, person& p) {
			j.at("name").get_to(p.name);
			j.at("address").get_to(p.address);
			j.at("age").get_to(p.age);
			}
			} // namespace ns


			void testJson() {

			auto js = R"({"name":"Tomik","surname":"Jakubec"})"_json;


			// create a person
			ns::person p {"Ned Flanders", "744 Evergreen Terrace", 60};

			// conversion: person -> json
			json j = p;

			std::cout << j << std::endl;
			// {"address":"744 Evergreen Terrace","age":60,"name":"Ned Flanders"}

			// conversion: json -> person
			auto p2 = j.get<ns::person>();

			person p_test = {"tomik","...", {"MS", 334}};

			json j_test = p_test;


			j_test.at("name") = "Ivisek";

			p_test = j_test;

			std::cout << j_test << std::endl;
			DBGVAR(j, p_test, j_test);

			}


	int main()		int main()
	{		{
	//testDebug();		//testDebug();
	@@ -1002,7 +1237,10 @@ int main()
	//testStructTransposition();		//testStructTransposition();
	//testTraitApply();		//testTraitApply();
	//testCompileTimeTraits();		//testCompileTimeTraits();
	testTraitPerformance();		//testTraitPerformance();
			//testCustomUnorderedMap();
			//testPrivateTrait();
			testJson();
	return 0;		return 0;
	}		}

Unstructured_mesh/Unstructured_mesh.pro

+1 −1

Original line number	Original line	Diff line number	Diff line
	TEMPLATE = app		TEMPLATE = app
	CONFIG += console c++14		CONFIG += console c++17
	CONFIG -= app_bundle		CONFIG -= app_bundle
	CONFIG -= qt		CONFIG -= qt

Unstructured_mesh/main.cpp

+5 −5

Original line number	Original line	Diff line number	Diff line
	@@ -1010,12 +1010,12 @@ void testFPMA_poly(){

	int main()		int main()
	{		{
	meshSize();		//meshSize();
	//testMesh2D();		//testMesh2D();
	//testMesh2DLoadAndWrite();		testMesh2DLoadAndWrite();
	//testMesh3D();		testMesh3D();
	//test3DMeshDeformedPrisms();		test3DMeshDeformedPrisms();
	//testMeshRefine();		testMeshRefine();
	//testMeshDataContainer();		//testMeshDataContainer();
	//UnstructuredMesh<5, size_t, double, 6,5,4> m;		//UnstructuredMesh<5, size_t, double, 6,5,4> m;
	//m.ComputeElementMeasures();		//m.ComputeElementMeasures();

src/Debug/CSVLogger.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -91,7 +91,7 @@ public:
	if (!logFile) create(logFileName.c_str());		if (!logFile) create(logFileName.c_str());

	(*logFile) << groupIndex << ';' << line << ";\"" << cppFile << "\";\"" << name << "\";";		(*logFile) << groupIndex << ';' << line << ";\"" << cppFile << "\";\"" << name << "\";";
	VariableExport::exportVariable(*logFile,value);		VariableExport<>::exportVariable(*logFile,value);
	(*logFile) << "\n";		(*logFile) << "\n";
	writeVar(line, cppFile, rest...);		writeVar(line, cppFile, rest...);
	}		}
	@@ -104,7 +104,7 @@ public:
	if (!logFile) create(logFileName.c_str());		if (!logFile) create(logFileName.c_str());

	(*logFile) << groupIndex << ';' << line << ";\"" << cppFile << "\";\"" << name << "\";";		(*logFile) << groupIndex << ';' << line << ";\"" << cppFile << "\";\"" << name << "\";";
	VariableExport::exportVariable(*logFile,value);		VariableExport<>::exportVariable(*logFile,value);
	(*logFile) << "\n";		(*logFile) << "\n";

	groupIndex++;		groupIndex++;

src/Debug/ConsoleLogger.h

+83 −10

Original line number	Original line	Diff line number	Diff line
	@@ -3,13 +3,14 @@
	#include "VariableExport.h"		#include "VariableExport.h"

	#ifdef _WIN32		#ifdef _WIN32
	#ifdef CONSOLE_COLOURED_OUTPUT		#ifdef CONSOLE_COLORED_OUTPUT
	#include <windows.h>		#include <windows.h>
	#endif		#endif
	#endif		#endif
	/**		/**
	* @brief The ConsoleLogger class		* @brief The ConsoleLogger class
	*/		*/
			template <VARIABLE_EXPORT_METHOD method = VARIABLE_EXPORT_METHOD::ostream>
	class ConsoleLogger {		class ConsoleLogger {

	public:		public:
	@@ -25,7 +26,7 @@ public:
	static void writeMessage(const char* prefix, int line, const char* sourceFile, const MSGTYPE& message) {		static void writeMessage(const char* prefix, int line, const char* sourceFile, const MSGTYPE& message) {

	std::cerr << prefix << " " << sourceFile << " << " << line << " >> ==> ";		std::cerr << prefix << " " << sourceFile << " << " << line << " >> ==> ";
	VariableExport::exportVariable(std::cerr, message);		VariableExport<>::exportVariable(std::cerr, message);
	std::cerr << " <==\n";		std::cerr << " <==\n";
	}		}

	@@ -57,7 +58,7 @@ public:



	#ifdef CONSOLE_COLOURED_OUTPUT		#ifdef CONSOLE_COLORED_OUTPUT
	#ifdef _WIN32		#ifdef _WIN32
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);		HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	std::cerr << "== " << cppFile << " << " << line << " >> [[ ";		std::cerr << "== " << cppFile << " << " << line << " >> [[ ";
	@@ -66,18 +67,18 @@ public:
	SetConsoleTextAttribute(hConsole, FOREGROUND_RED \| FOREGROUND_GREEN \| FOREGROUND_BLUE);		SetConsoleTextAttribute(hConsole, FOREGROUND_RED \| FOREGROUND_GREEN \| FOREGROUND_BLUE);
	std::cerr << " ]] ==> ";		std::cerr << " ]] ==> ";
	SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN);		SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN);
	VariableExport::exportVariable(std::cerr, value);		VariableExport<>::exportVariable(std::cerr, value);
	SetConsoleTextAttribute(hConsole, FOREGROUND_RED \| FOREGROUND_GREEN \| FOREGROUND_BLUE);		SetConsoleTextAttribute(hConsole, FOREGROUND_RED \| FOREGROUND_GREEN \| FOREGROUND_BLUE);
	std::cerr << "\n";		std::cerr << "\n";
	#else		#else
	std::cerr << "== " << cppFile << " << " << line << " >> [[ \033[0;33m" << name << "\033[0m ]] ==> \033[0;32m";		std::cerr << "== " << cppFile << " << " << line << " >> [[ \033[0;33m" << name << "\033[0m ]] ==> \033[0;32m";
	VariableExport::exportVariable(std::cerr, value);		VariableExport<>::exportVariable(std::cerr, value);
	std::cerr << "\033[0m\n";		std::cerr << "\033[0m\n";

	#endif		#endif
	#else		#else
	std::cerr << "== " << cppFile << " << " << line << " >> [[ " << name << " ]] ==> ";		std::cerr << "== " << cppFile << " << " << line << " >> [[ " << name << " ]] ==> ";
	VariableExport::exportVariable(std::cerr, value);		VariableExport<>::exportVariable(std::cerr, value);
	std::cerr << "\n";		std::cerr << "\n";
	#endif		#endif
	}		}
	@@ -85,7 +86,7 @@ public:
	template<typename VAR>		template<typename VAR>
	static void writeVar(int line, const char* cppFile, const char* name,const std::initializer_list<VAR>& value){		static void writeVar(int line, const char* cppFile, const char* name,const std::initializer_list<VAR>& value){

	#ifdef CONSOLE_COLOURED_OUTPUT		#ifdef CONSOLE_COLORED_OUTPUT
	#ifdef _WIN32		#ifdef _WIN32
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);		HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	std::cerr << "== " << cppFile << " << " << line << " >> [[ ";		std::cerr << "== " << cppFile << " << " << line << " >> [[ ";
	@@ -94,22 +95,94 @@ public:
	SetConsoleTextAttribute(hConsole, FOREGROUND_RED \| FOREGROUND_GREEN \| FOREGROUND_BLUE);		SetConsoleTextAttribute(hConsole, FOREGROUND_RED \| FOREGROUND_GREEN \| FOREGROUND_BLUE);
	std::cerr << " ]] ==> ";		std::cerr << " ]] ==> ";
	SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN);		SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN);
	VariableExport::exportVariable(std::cerr, value);		VariableExport<>::exportVariable(std::cerr, value);
	SetConsoleTextAttribute(hConsole, FOREGROUND_RED \| FOREGROUND_GREEN \| FOREGROUND_BLUE);		SetConsoleTextAttribute(hConsole, FOREGROUND_RED \| FOREGROUND_GREEN \| FOREGROUND_BLUE);
	std::cerr << "\n";		std::cerr << "\n";
	#else		#else
	std::cerr << "== " << cppFile << " << " << line << " >> [[ \033[0;33m" << name << "\033[0m ]] ==> \033[0;32m";		std::cerr << "== " << cppFile << " << " << line << " >> [[ \033[0;33m" << name << "\033[0m ]] ==> \033[0;32m";
	VariableExport::exportVariable(std::cerr, value);		VariableExport<>::exportVariable(std::cerr, value);
	std::cerr << "\033[0m\n";		std::cerr << "\033[0m\n";

	#endif		#endif
	#else		#else
	std::cerr << "== " << cppFile << " << " << line << " >> [[ " << name << " ]] ==> ";		std::cerr << "== " << cppFile << " << " << line << " >> [[ " << name << " ]] ==> ";
	VariableExport::exportVariable(std::cerr, value);		VariableExport<>::exportVariable(std::cerr, value);
	std::cerr << "\n";		std::cerr << "\n";
	#endif		#endif
	}		}

	};		};




			template <>
			class ConsoleLogger<VARIABLE_EXPORT_METHOD::stdio> {

			public:

			template<typename MSGTYPE, typename... MSGTYPES>
			static void writeMessage(const char* prefix, int line, const char* sourceFile, const MSGTYPE& message, const MSGTYPES&... rest) {
			writeMessage(prefix, line, sourceFile, message);
			writeMessage(prefix, line, sourceFile, rest...);
			}


			template<typename MSGTYPE>
			static void writeMessage(const char* prefix, int line, const char* sourceFile, const MSGTYPE& message) {

			printf("%s %s << %i >> ==> %s <==\n",
			prefix,
			sourceFile,
			line,
			VariableExport<VARIABLE_EXPORT_METHOD::stdio>::exportVariable(message));


			}

			template<typename VAR_NAME, typename VAR, typename ... REST>
			static void writeVar(VAR_NAME name, VAR value, REST ... rest){

			writeVar(name, value);
			writeVar(rest...);
			}


			template<typename VAR_NAME, typename VAR>
			static void writeVar(VAR_NAME name, VAR value){

			std::cerr << "variable " << name << " has value: " << value;
			}



			template<typename VAR_NAME, typename VAR, typename ... REST>
			static void writeVar(int line, const char* cppFile, const VAR_NAME& name,const VAR& value,const REST& ... rest){

			writeVar(line, cppFile, name, value);
			writeVar(line, cppFile, rest...);
			}

			template<typename VAR>
			static void writeVar(int line, const char* cppFile, const char* name,const VAR& value){

			printf("== %s << %i >> [[ %s ]] ==> %s\n",
			cppFile,
			line,
			name,
			VariableExport<VARIABLE_EXPORT_METHOD::stdio>::exportVariable(value));

			}

			template<typename VAR>
			static void writeVar(int line, const char* cppFile, const char* name,const std::initializer_list<VAR>& value){

			printf("== %s << %i >> [[ %s ]] ==> %s\n",
			cppFile,
			line,
			name,
			VariableExport<VARIABLE_EXPORT_METHOD::stdio>::exportVariable(value));
			}

			};
	#endif // CONSOLELOGGER_H		#endif // CONSOLELOGGER_H