Ready to make 3D VTK writer (62693a84) · Commits · Tomáš Jakubec / GTMesh

TemplateTest/.gitignore

0 → 100644

+73 −0

Original line number	Diff line number	Diff line
		# This file is used to ignore files which are generated
		# ----------------------------------------------------------------------------

		*~
		*.autosave
		*.a
		*.core
		*.moc
		*.o
		*.obj
		*.orig
		*.rej
		*.so
		.so.
		*_pch.h.cpp
		*_resource.rc
		*.qm
		.#*
		.#
		core
		!core/
		tags
		.DS_Store
		.directory
		*.debug
		Makefile*
		*.prl
		*.app
		moc_*.cpp
		ui_*.h
		qrc_*.cpp
		Thumbs.db
		*.res
		*.rc
		/.qmake.cache
		/.qmake.stash

		# qtcreator generated files
		.pro.user

		# xemacs temporary files
		*.flc

		# Vim temporary files
		.*.swp

		# Visual Studio generated files
		*.ib_pdb_index
		*.idb
		*.ilk
		*.pdb
		*.sln
		*.suo
		*.vcproj
		vcproj..*.user
		*.ncb
		*.sdf
		*.opensdf
		*.vcxproj
		vcxproj.

		# MinGW generated files
		*.Debug
		*.Release

		# Python byte code
		*.pyc

		# Binaries
		# --------
		*.dll
		*.exe

TemplateTest/TemplateTest.pro

0 → 100644

+8 −0

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

		SOURCES += \
		../debug/debug.cpp \
		main.cpp

TemplateTest/main.cpp

0 → 100644

+200 −0

Original line number	Diff line number	Diff line
		#include "../debug/Debug.h"
		#include "../Unstructured_mesh/UnstructuredMesh.h"
		#include <iostream>
		#include <list>
		#include <map>
		using namespace std;


		template <typename T1, typename T2 = void>
		struct has_public_member : public std::integral_constant<bool, false> {

		};

		template <typename T1>
		struct has_public_member<T1, typename std::enable_if<
		noexcept (T1::data) \|\| !noexcept (T1::data)>::type> : public std::integral_constant<bool, true> {

		};

		template <typename ResulType, typename ...ArgTypes>
		struct function_ptr {
		typedef ResulType(*type)(ArgTypes...);
		};


		template <typename Class,typename ResulType, typename ...ArgTypes>
		struct member_function_ptr {
		using type = ResulType (Class::*) (ArgTypes...);
		};

		template <typename Class,typename ResulType, typename ...ArgTypes>
		struct member_const_function_ptr {
		using type = ResulType (Class::*) (ArgTypes...) const;
		};


		template <typename Class,typename MemberType>
		struct member_ptr {
		typedef MemberType Class::* type;
		};



		struct Temp {
		double data;
		double fun(double d){return data;}
		};

		void testDebug() {
		double r = 42.15;
		int i = 15;
		char c = 42;
		bool b = false;
		std::list<int> list = {1,2,3};
		std::vector<std::list<int>> vec(5, list);
		std::map<std::string, size_t> m{
		{"prvni", 1},
		{"druhy", 2},
		{"treti", 3}
		};
		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});
		DBGVAR(r, i, c, list, vec, b, m);

		Vertex<7, double> vert;
		DBGVAR(vert, vert.getCoordinates());

		DBGVAR((Detail::is_exportable<decltype(vec)>::value));

		DBGVAR((Detail::is_exportable<double>::value));

		DBGVAR(Detail::is_indexable<double>::value);

		DBGVAR(Detail::is_indexable<decltype(vec)>::value);

		DBGVAR(Detail::is_indexable<decltype(vert)>::value);

		Subelement<size_t> s({1,true});
		DBGVAR(s);

		HTMLDBGVAR(r, i, c, list, vec, b, m);

		HTMLDBGVAR(r+1, i+1, char(c+1), list, vec[0], b, m["prvni"]);
		}



		//The concept implementation
		template<typename T>
		class NeedIterator{
		static_assert (Detail::is_iterable<T>::value, "The type must be iterable");
		public:
		NeedIterator(const T&){}
		};

		template <unsigned int ... Is>
		class ClassA
		{
		public:
		ClassA (std::integer_sequence<unsigned int,Is...>)
		{DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...})); }

		static void fun (std::index_sequence<Is...>)
		{DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...})); }

		};


		//template <typename ... t> class ClassB{};

		template<typename Tuple, unsigned int ... Is>
		class ClassB
		{
		public:
		ClassB (const std::integer_sequence<unsigned int, Is...>, Tuple t)
		{std::tuple_element_t<0,Tuple> typ = 0;
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), std::get<0>(t), typ); }

		};


		template <typename ... t> class ClassC{};

		template<unsigned int ... Is, typename ...Types>
		class ClassC<std::integer_sequence<unsigned int,Is...>, std::tuple<Types...>>
		{
		public:
		ClassC (const std::integer_sequence<unsigned int, Is...>, std::tuple<Types...>)
		{std::tuple_element_t<0,std::tuple<Types...>> typ = 0;
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ); }

		ClassC () {
		std::tuple_element_t<0,std::tuple<Types...>> typ = 42.15;
		std::tuple_element_t<1,std::tuple<Types...>> typ2 = 42.15;
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ, typ2);
		}
		};



		void testTemplate() {
		ClassA n(std::make_integer_sequence<unsigned int, 3>{});
		UnstructuredMesh<3,size_t, double,6> mesh3;
		//MeshDataContainer<Vertex<3, double>, 0,1,2> centers2(mesh3,std::make_integer_sequence<unsigned int, 3>{}, Vertex<3, double>{});
		//ComputeCenters(mesh3);

		ClassA p(make_custom_integer_sequence_t<unsigned int, 10, 0, -2>{});
		std::tuple<double, char> t{};
		t={1,2};
		ClassB u(make_custom_integer_sequence_t<unsigned int, 2, 0, -2>{}, t);

		ClassC<std::integer_sequence<unsigned int, 2,0>, std::tuple<double, char>> c(make_custom_integer_sequence_t<unsigned int, 2, 0, -2>{}, std::tuple<double, char>{});
		ClassC<std::integer_sequence<unsigned int, 2,0>, std::tuple<double, char>> cc;
		ClassC<std::integer_sequence<unsigned int, 2,0>, decltype(std::make_tuple(1.0, 'a'))> ccc;

		NeedIterator valid(mesh3.getCells());
		//NeedIterator invalid(0.0);
		}


		template<typename T, typename VOID = void>
		struct is_indexable : public integral_constant<bool, false>{};

		template<typename T>
		struct is_indexable<
		T,
		enable_if<
		is_same<decltype(&T::operator[]), typename member_const_function_ptr<vector<double>,const double&, size_t>::type>::value
		>

		> : public integral_constant<bool, false>{};


		int main()
		{

		Vertex<5, double> vert;
		vector<double> vec;
		DBGVAR(has_public_member<double>::value);
		DBGVAR(has_public_member<decltype (vert)>::value);
		DBGVAR(has_public_member<decltype(vec)>::value);
		DBGVAR(has_public_member<Temp>::value);

		Temp t;
		member_function_ptr<Temp, double, double>::type pom1 = &Temp::fun;
		member_ptr<Temp, double>::type pom = &Temp::data;
		DBGVAR(((&t)->*pom1)(0.0),pom);
		//auto op = &vector<double>::operator[];
		member_const_function_ptr<vector<double>,const double&, size_t>::type c_at = &vector<double>::at;

		member_function_ptr<vector<double>,double&, size_t>::type at = &vector<double>::at;

		member_const_function_ptr<vector<double>,const double&, size_t>::type op = &vector<double>::operator[];

		//DBGVAR(is_same<decltype(&vector<double>::operator[]), typename member_const_function_ptr<vector<double>,const double&, size_t>::type>::value);

		DBGVAR(is_indexable<const vector<double>>::value);
		cout << "Hello World!" << endl;
		return 0;
		}

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-10-08T12:10:37. -->
		<!-- Written by QtCreator 4.10.0, 2019-10-09T13:13:25. -->
		<qtcreator>
		<data>
		<variable>EnvironmentId</variable>

Unstructured_mesh/main.cpp

+8 −109

Original line number	Diff line number	Diff line
		@@ -622,113 +622,7 @@ void testMeshDataContainer() {
		}
		}

		template <unsigned int ... Is>
		class ClassA
		{
		public:
		ClassA (std::integer_sequence<unsigned int,Is...>)
		{DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...})); }

		static void fun (std::index_sequence<Is...>)
		{DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...})); }

		};


		//template <typename ... t> class ClassB{};

		template<typename Tuple, unsigned int ... Is>
		class ClassB
		{
		public:
		ClassB (const std::integer_sequence<unsigned int, Is...>, Tuple t)
		{std::tuple_element_t<0,Tuple> typ = 0;
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), std::get<0>(t), typ); }

		};


		template <typename ... t> class ClassC{};

		template<unsigned int ... Is, typename ...Types>
		class ClassC<std::integer_sequence<unsigned int,Is...>, std::tuple<Types...>>
		{
		public:
		ClassC (const std::integer_sequence<unsigned int, Is...>, std::tuple<Types...>)
		{std::tuple_element_t<0,std::tuple<Types...>> typ = 0;
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ); }

		ClassC () {
		std::tuple_element_t<0,std::tuple<Types...>> typ = 42.15;
		std::tuple_element_t<1,std::tuple<Types...>> typ2 = 42.15;
		DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ, typ2);
		}
		};

		//The concept implementation
		template<typename T>
		class NeedIterator{
		static_assert (Detail::is_iterable<T>::value, "The type must be iterable");
		public:
		NeedIterator(const T&){}
		};

		void testTemplate() {
		ClassA n(std::make_integer_sequence<unsigned int, 3>{});
		UnstructuredMesh<3,size_t, double,6> mesh3;
		//MeshDataContainer<Vertex<3, double>, 0,1,2> centers2(mesh3,std::make_integer_sequence<unsigned int, 3>{}, Vertex<3, double>{});
		//ComputeCenters(mesh3);

		ClassA p(make_custom_integer_sequence_t<unsigned int, 10, 0, -2>{});
		std::tuple<double, char> t{};
		t={1,2};
		ClassB u(make_custom_integer_sequence_t<unsigned int, 2, 0, -2>{}, t);

		ClassC<std::integer_sequence<unsigned int, 2,0>, std::tuple<double, char>> c(make_custom_integer_sequence_t<unsigned int, 2, 0, -2>{}, std::tuple<double, char>{});
		ClassC<std::integer_sequence<unsigned int, 2,0>, std::tuple<double, char>> cc;
		ClassC<std::integer_sequence<unsigned int, 2,0>, decltype(std::make_tuple(1.0, 'a'))> ccc;

		NeedIterator valid(mesh3.getCells());
		//NeedIterator invalid(0.0);
		}


		void testDebug() {
		double r = 42.15;
		int i = 15;
		char c = 42;
		bool b = false;
		std::list<int> list = {1,2,3};
		std::vector<std::list<int>> vec(5, list);
		std::map<std::string, size_t> m{
		{"prvni", 1},
		{"druhy", 2},
		{"treti", 3}
		};
		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});
		DBGVAR(r, i, c, list, vec, b, m);

		Vertex<7, double> vert;
		DBGVAR(vert, vert.getCoordinates());

		DBGVAR((Detail::is_exportable<decltype(vec)>::value));

		DBGVAR((Detail::is_exportable<double>::value));

		DBGVAR(Detail::is_indexable<double>::value);

		DBGVAR(Detail::is_indexable<decltype(vec)>::value);

		DBGVAR(Detail::is_indexable<decltype(vert)>::value);

		Subelement<size_t> s({1,true});
		DBGVAR(s);

		HTMLDBGVAR(r, i, c, list, vec, b, m);

		HTMLDBGVAR(r+1, i+1, char(c+1), list, vec[0], b, m["prvni"]);
		}


		void test3DMeshLoad() {
		@@ -772,17 +666,22 @@ DBGVAR(mesh.getVertices().size(),mesh.getEdges().size(), mesh.getFaces().size(),

		}







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


		}