IOTraits and ArithmeticTraits developed (d2a1f3b3) · Commits · Tomáš Jakubec / GTMesh

Unstructured_mesh/main.cpp

+8 −6

Original line number	Original line	Diff line number	Diff line
	@@ -656,12 +656,14 @@ DBGMSG("tessellated cell volume");
	}		}


	struct colourData {		struct colorData {
	unsigned int colour;		unsigned int color;
	Vector<3, double> firstEdgeNormal;		Vector<3, double> firstEdgeNormal;
	};		};

	MAKE_ATTRIBUTE_TRAIT(colourData, firstEdgeNormal, colour);		MAKE_ATTRIBUTE_TRAIT(colorData, firstEdgeNormal, color);
			//MAKE_ATTRIBUTE_TRAIT_IO(colorData, firstEdgeNormal);
			//MAKE_ATTRIBUTE_TRAIT_ARITHMETIC(colorData, color);

	void testMeshRefine() {		void testMeshRefine() {
	UnstructuredMesh<3, size_t, double, 6> mesh;		UnstructuredMesh<3, size_t, double, 6> mesh;
	@@ -692,11 +694,11 @@ void testMeshRefine() {
	writer1.writeToStream(out3D, mesh, types1);		writer1.writeToStream(out3D, mesh, types1);
	auto colours1 = MeshColoring<3,0>::color(mesh);		auto colours1 = MeshColoring<3,0>::color(mesh);

	MeshDataContainer<colourData, 3> cd(mesh);		MeshDataContainer<colorData, 3> cd(mesh);
	auto normals = mesh.computeFaceNormals();		auto normals = mesh.computeFaceNormals();

	for(auto& cell : mesh.getCells()){		for(auto& cell : mesh.getCells()){
	cd.at(cell).colour = colours1.at(cell);		cd.at(cell).color = colours1.at(cell);
	cd.at(cell).firstEdgeNormal = normals.getDataByDim<2>().at(mesh.getFaces().at(cell.getBoundaryElementIndex()).getNextBElem(cell.getIndex()));		cd.at(cell).firstEdgeNormal = normals.getDataByDim<2>().at(mesh.getFaces().at(cell.getBoundaryElementIndex()).getNextBElem(cell.getIndex()));
	}		}
	DBGVAR(cd.getDataByDim<3>());		DBGVAR(cd.getDataByDim<3>());
	@@ -726,7 +728,7 @@ void testMeshRefine() {
	VTKMeshReader<3> reader;		VTKMeshReader<3> reader;
	reader.loadFromStream(in3D, mesh);		reader.loadFromStream(in3D, mesh);

	MeshDataContainer<colourData, 3> cd1(mesh);		MeshDataContainer<colorData, 3> cd1(mesh);
	VTKMeshDataReader<3, size_t>::readData(in3D, cd1.getDataByPos<0>());		VTKMeshDataReader<3, size_t>::readData(in3D, cd1.getDataByPos<0>());

	DBGVAR(cd1.getDataByDim<3>());		DBGVAR(cd1.getDataByDim<3>());

src/Debug/VariableExport.h

+6 −6

Original line number	Original line	Diff line number	Diff line
	@@ -163,7 +163,7 @@ struct VariableExport {

	template<typename T,unsigned int Index, typename... Types>		template<typename T,unsigned int Index, typename... Types>
	struct PrintClass <Traits<T, Types...>, Index, typename std::enable_if<Index < Traits<T, Types...>::size() - 1>::type>{		struct PrintClass <Traits<T, Types...>, Index, typename std::enable_if<Index < Traits<T, Types...>::size() - 1>::type>{
	static void print(std::ostream& ost, const T &traitedClass, const Traits<T, Types...>& trait = Traits<T>::tr){		static void print(std::ostream& ost, const T &traitedClass, const Traits<T, Types...>& trait = DefaultIOTraits<T>::getTraits()){
	ost << '"' << trait.template getName<Index>() << "\" : ";		ost << '"' << trait.template getName<Index>() << "\" : ";
	VariableExport::exportVariable(ost, trait.template getValue<Index>(traitedClass));		VariableExport::exportVariable(ost, trait.template getValue<Index>(traitedClass));
	ost << ", ";		ost << ", ";
	@@ -174,7 +174,7 @@ struct VariableExport {

	template<typename T,unsigned int Index, typename ... Types>		template<typename T,unsigned int Index, typename ... Types>
	struct PrintClass <Traits<T, Types...>, Index, typename std::enable_if<Index == Traits<T, Types...>::size() - 1>::type>{		struct PrintClass <Traits<T, Types...>, Index, typename std::enable_if<Index == Traits<T, Types...>::size() - 1>::type>{
	static void print(std::ostream& ost, const T &traitedClass, const Traits<T, Types...>& trait = Traits<T>::tr){		static void print(std::ostream& ost, const T &traitedClass, const Traits<T, Types...>& trait = DefaultIOTraits<T>::getTraits()){
	ost << '"' << trait.template getName<Traits<T, Types...>::size() - 1>() << "\" : ";		ost << '"' << trait.template getName<Traits<T, Types...>::size() - 1>() << "\" : ";
	VariableExport::exportVariable(ost, trait.template getValue<Traits<T, Types...>::size() - 1>(traitedClass));		VariableExport::exportVariable(ost, trait.template getValue<Traits<T, Types...>::size() - 1>(traitedClass));
	}		}
	@@ -192,11 +192,11 @@ struct VariableExport {
	template<typename T>		template<typename T>
	static auto exportVariable(std::ostream& ost, const T &traitedClass)		static auto exportVariable(std::ostream& ost, const T &traitedClass)
	-> typename std::enable_if<		-> typename std::enable_if<
	HasDefaultTraits<T>::value		HasDefaultIOTraits<T>::value
	>::type		>::type
	{		{
	ost << "{ ";		ost << "{ ";
	PrintClass<typename Traits<T>::ttype>::print(ost, traitedClass);		PrintClass<typename DefaultIOTraits<T>::ttype>::print(ost, traitedClass);
	ost << " }";		ost << " }";
	}		}

	@@ -403,13 +403,13 @@ struct VariableExport<VARIABLE_EXPORT_METHOD::stdio> {
	template<typename T>		template<typename T>
	static auto exportVariable(const T &traitedClass)		static auto exportVariable(const T &traitedClass)
	-> typename std::enable_if<		-> typename std::enable_if<
	HasDefaultTraits<T>::value,		HasDefaultIOTraits<T>::value,
	std::string		std::string
	>::type		>::type
	{		{
	std::string res;		std::string res;
	res += "{ ";		res += "{ ";
	res += PrintClass<typename Traits<T>::ttype>::print(traitedClass);		res += PrintClass<typename DefaultIOTraits<T>::ttype>::print(traitedClass);
	res += " }";		res += " }";
	return res;		return res;
	}		}

src/Traits/CustomTypeTraits.h

+36 −1

Original line number	Original line	Diff line number	Diff line
	@@ -85,6 +85,35 @@ struct __has_default_traits<
	Traits<T1>::is_specialized		Traits<T1>::is_specialized
	>::type		>::type
	> : public std::integral_constant<bool, true> {};		> : public std::integral_constant<bool, true> {};



			template <typename T1, typename VOID = void>
			struct __has_default_io_traits : public std::integral_constant<bool, false> {};


			template <typename T1>
			struct __has_default_io_traits<
			T1,
			typename std::enable_if<
			DefaultIOTraits<T1>::is_specialized
			>::type
			> : public std::integral_constant<bool, true> {};



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


			template <typename T1>
			struct __has_default_arithmetic_traits<
			T1,
			typename std::enable_if<
			DefaultArithmeticTraits<T1>::is_specialized
			>::type
			> : public std::integral_constant<bool, true> {};

	}		}


	@@ -106,6 +135,12 @@ struct IsTNLIndexable : public Detail::__is_tnl_indexable<T1>
	{};		{};

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

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

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

	#endif // CUSTOMTRAITS_H		#endif // CUSTOMTRAITS_H

src/Traits/Traits.h

+35 −11

Original line number	Original line	Diff line number	Diff line
	@@ -286,34 +286,58 @@ public:


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


			template<typename Class>
			class DefaultIOTraits : public Traits<Class> {};

			template<typename Class>
			class DefaultArithmeticTraits : public Traits<Class> {};

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

			#define IMPL_MEMREF_TYPE_CUSTOM(name, memberRef) decltype(memberRef)
			#define IMPL_NAME_AND_REF(Class, name, member) name, &Class::member
			#define IMPL_NAME_ATT(attribute) #attribute, attribute

	#define MEMREF_TYPE_CUSTOM(name, memberRef) decltype(memberRef)		#define IMPL_MAKE_CUSTOM_ATTRIBUTE_TRAIT(TraitName,Class,...)\
	#define MAKE_CUSTOM_ATTRIBUTE_TRAIT(Class,...)\
	template<> \		template<> \
	class Traits<Class>{ \		class TraitName<Class>{ \
	public: \		public: \
	static constexpr std::true_type is_specialized{}; \		static constexpr std::true_type is_specialized{}; \
	using ttype = Traits<Class, FOR_EACH_2ARGS(MEMREF_TYPE_CUSTOM, __VA_ARGS__)>; \		using ttype = ::Traits<Class, FOR_EACH_2ARGS(IMPL_MEMREF_TYPE_CUSTOM, __VA_ARGS__)>; \
	const static ttype tr; \		const static ttype tr; \
	Traits(){DBGMSG("TRAITS");}\		TraitName() = delete; \
			static const ttype& getTraits() {return tr;} \
			static constexpr unsigned int size() {return ttype::size();}\
	}; \		}; \
	const Traits<Class>::ttype Traits<Class>::tr(__VA_ARGS__); \		const TraitName<Class>::ttype TraitName<Class>::tr(__VA_ARGS__); \



			#define MAKE_CUSTOM_ATTRIBUTE_TRAIT(Class,...) IMPL_MAKE_CUSTOM_ATTRIBUTE_TRAIT(Traits, Class, __VA_ARGS__) // defining specialization for Traits

			#define MAKE_NAMED_ATTRIBUTE_TRAIT(Class, ...) MAKE_CUSTOM_ATTRIBUTE_TRAIT(Class, FOR_EACH_3ARGS_1STAT(IMPL_NAME_AND_REF, Class, __VA_ARGS__))

			#define MAKE_ATTRIBUTE_TRAIT(Class, ...) MAKE_NAMED_ATTRIBUTE_TRAIT(Class, FOR_EACH(IMPL_NAME_ATT, __VA_ARGS__))


			#define MAKE_CUSTOM_ATTRIBUTE_TRAIT_IO(Class,...) IMPL_MAKE_CUSTOM_ATTRIBUTE_TRAIT(DefaultIOTraits, Class,__VA_ARGS__) // defining specialization for DefaultIOTraits

			#define MAKE_NAMED_ATTRIBUTE_TRAIT_IO(Class, ...) MAKE_CUSTOM_ATTRIBUTE_TRAIT_IO(Class, FOR_EACH_3ARGS_1STAT(IMPL_NAME_AND_REF, Class, __VA_ARGS__))

	#define NAME_AND_REF(Class, name, member) name, &Class::member		#define MAKE_ATTRIBUTE_TRAIT_IO(Class, ...) MAKE_NAMED_ATTRIBUTE_TRAIT_IO(Class, FOR_EACH(IMPL_NAME_ATT, __VA_ARGS__))

	#define MAKE_NAMED_ATTRIBUTE_TRAIT(Class, ...) MAKE_CUSTOM_ATTRIBUTE_TRAIT(Class, FOR_EACH_3ARGS_1STAT(NAME_AND_REF, Class, __VA_ARGS__))

	#define NAME_ATT(attribute) #attribute, attribute		#define MAKE_CUSTOM_ATTRIBUTE_TRAIT_ARITHMETIC(Class,...) IMPL_MAKE_CUSTOM_ATTRIBUTE_TRAIT(DefaultArithmeticTraits, Class,__VA_ARGS__) // defining specialization for Traits
	#define MAKE_ATTRIBUTE_TRAIT(Class, ...) MAKE_NAMED_ATTRIBUTE_TRAIT(Class, FOR_EACH(NAME_ATT, __VA_ARGS__))

			#define MAKE_NAMED_ATTRIBUTE_TRAIT_ARITHMETIC(Class, ...) MAKE_CUSTOM_ATTRIBUTE_TRAIT_ARITHMETIC(Class, FOR_EACH_3ARGS_1STAT(IMPL_NAME_AND_REF, Class, __VA_ARGS__))

			#define MAKE_ATTRIBUTE_TRAIT_ARITHMETIC(Class, ...) MAKE_NAMED_ATTRIBUTE_TRAIT_ARITHMETIC(Class, FOR_EACH(IMPL_NAME_ATT, __VA_ARGS__))

	#endif // TRAITS_H		#endif // TRAITS_H

src/UnstructuredMesh/MeshDataContainer/MeshDataIO/VTKMeshDataReader.h

+17 −17

Original line number	Original line	Diff line number	Diff line
	@@ -24,23 +24,23 @@ class VTKMeshDataReader {
	template<typename T, unsigned int Index>		template<typename T, unsigned int Index>
	static auto readColumn(std::istream& ist, DataContainer<T, MeshDimension> &data,std::map<std::string, std::istream::pos_type>& dataPositions)		static auto readColumn(std::istream& ist, DataContainer<T, MeshDimension> &data,std::map<std::string, std::istream::pos_type>& dataPositions)
	-> typename std::enable_if<		-> typename std::enable_if<
	IsIndexable<typename Traits<T>::ttype::template type<Index>>::value &&		IsIndexable<typename DefaultIOTraits<T>::ttype::template type<Index>>::value &&
	MeshDimension == 3		MeshDimension == 3
	>::type		>::type
	{		{

	ist.seekg(dataPositions[Traits<T>::tr.template getName<Index>()]);		ist.seekg(dataPositions[DefaultIOTraits<T>::tr.template getName<Index>()]);
	std::string line;		std::string line;
	std::getline(ist, line);		std::getline(ist, line);
	ist.seekg(dataPositions[Traits<T>::tr.template getName<Index>()]);		ist.seekg(dataPositions[DefaultIOTraits<T>::tr.template getName<Index>()]);

	typename Traits<T>::ttype::template type<Index> value;		typename DefaultIOTraits<T>::ttype::template type<Index> value;

	for (IndexType i = 0; i < data.size(); i++) {		for (IndexType i = 0; i < data.size(); i++) {
	for (unsigned int j = 0; j < Traits<T>::tr.template getValue<Index>(data.at(i)).size(); j++){		for (unsigned int j = 0; j < DefaultIOTraits<T>::tr.template getValue<Index>(data.at(i)).size(); j++){
	ist >> value[j];		ist >> value[j];
	}		}
	Traits<T>::tr.template setValue<Index>(data.at(i), value);		DefaultIOTraits<T>::tr.template setValue<Index>(data.at(i), value);
	}		}

	}		}
	@@ -49,24 +49,24 @@ class VTKMeshDataReader {
	template<typename T, unsigned int Index>		template<typename T, unsigned int Index>
	static auto readColumn(std::istream& ist, DataContainer<T, MeshDimension> &data,std::map<std::string, std::istream::pos_type>& dataPositions)		static auto readColumn(std::istream& ist, DataContainer<T, MeshDimension> &data,std::map<std::string, std::istream::pos_type>& dataPositions)
	-> typename std::enable_if<		-> typename std::enable_if<
	IsIndexable<typename Traits<T>::ttype::template type<Index>>::value &&		IsIndexable<typename DefaultIOTraits<T>::ttype::template type<Index>>::value &&
	MeshDimension == 2		MeshDimension == 2
	>::type		>::type
	{		{

	ist.seekg(dataPositions[Traits<T>::ttype::template getName<Index>()]);		ist.seekg(dataPositions[DefaultIOTraits<T>::ttype::template getName<Index>()]);

	typename Traits<T>::ttype::template type<Index> value;		typename DefaultIOTraits<T>::ttype::template type<Index> value;
	typename Traits<T>::ttype::template type<Index> dummy;		typename DefaultIOTraits<T>::ttype::template type<Index> dummy;

	for (IndexType i = 0; i < data.size(); i++) {		for (IndexType i = 0; i < data.size(); i++) {
	for (unsigned int j = 0; j < Traits<T>::tr.template getValue<Index>(data.at(i)).size(); j++){		for (unsigned int j = 0; j < DefaultIOTraits<T>::tr.template getValue<Index>(data.at(i)).size(); j++){