Class Traits is optimized its performance is the same as any other (8a27c638) · Commits · Tomáš Jakubec / GTMesh

TemplateTest/main.cpp

+25 −24

Original line number	Original line	Diff line number	Diff line
	@@ -298,12 +298,12 @@ void testMemberRef(){

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

	Traits<tempData>::ttype::getReference<0>()->setValue(&d, 0.0);		Traits<tempData>::tr.getReference<0>().setValue(&d, 0.0);
	DBGVAR(Traits<tempData>::ttype::getReference<0>()->getValue(&d));		DBGVAR(Traits<tempData>::tr.getReference<0>().getValue(&d));
	Traits<tempData>::ttype::getReference<0>()->setValue(d, 42.15);		Traits<tempData>::tr.getReference<0>().setValue(d, 42.15);
	Traits<tempData>::ttype::getReference<1>()->setValue(&d, {42.15,84.30,42.15});		Traits<tempData>::tr.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>::tr.getName<0>(),(Traits<tempData>::tr.getReference<0>().getValue(&d)), Traits<tempData>::tr.getName<1>(), d.velocity);
	DBGVAR(Traits<tempData>::is_specialized,HasDefaultTraits<tempData>::value, d);		DBGVAR(Traits<tempData>::is_specialized,HasDefaultTraits<tempData>::value, d);

	ExportTest e;		ExportTest e;
	@@ -319,7 +319,7 @@ Test of trasposing vector of struct to struct of vectors
	*/		*/


	template <typename DataType, typename DataTypeTrait = typename Traits<DataType>::ttype>		template <typename DataType, typename DataTypeTrait = Traits<DataType>>
	struct Container{		struct Container{
	template <unsigned int index = 0, typename Dummy = void>		template <unsigned int index = 0, typename Dummy = void>
	struct StructOfArrays : public StructOfArrays<index + 1>{		struct StructOfArrays : public StructOfArrays<index + 1>{
	@@ -340,7 +340,7 @@ struct Container{

	template <unsigned int pos>		template <unsigned int pos>
	const std::string& name() {		const std::string& name() {
	return DataTypeTrait::template getName<pos>();		return Traits<DataType>::tr.template getName<pos>();
	}		}

	template <unsigned int pos>		template <unsigned int pos>
	@@ -350,7 +350,6 @@ struct Container{
	};		};



	void testStructTransposition() {		void testStructTransposition() {
	Container<ExportTest, Traits<ExportTest>::ttype> data;		Container<ExportTest, Traits<ExportTest>::ttype> data;

	@@ -360,6 +359,7 @@ void testStructTransposition() {
	};		};



	/**		/**
	Test TraitApply		Test TraitApply
	*/		*/
	@@ -370,7 +370,7 @@ struct TraitApply {
	};		};
	*/		*/

			/*
	template < unsigned int index>		template < unsigned int index>
	class TraitApply {		class TraitApply {
	public:		public:
	@@ -505,6 +505,7 @@ public:
	Functor<ExportTest, Traits<ExportTest>::ttype::type<0>>()(0, Traits<ExportTest>::ttype::getReference<0>(), Traits<ExportTest>::ttype::getName<0>());		Functor<ExportTest, Traits<ExportTest>::ttype::type<0>>()(0, Traits<ExportTest>::ttype::getReference<0>(), Traits<ExportTest>::ttype::getName<0>());
	}		}
	};		};
			*/

	struct Depth {		struct Depth {
	int value = 0;		int value = 0;
	@@ -515,19 +516,19 @@ class Func {
	public:		public:

	template <typename U = T>		template <typename U = T>
	auto operator()(unsigned int index, const std::unique_ptr<MemberApproach<Class, T>>&, const std::string& name)		auto operator()(unsigned int index, const MemberApproach<Class, T>&, const std::string& name)
	-> typename std::enable_if<!(HasDefaultTraits<U>::value)>::type		-> typename std::enable_if<!(HasDefaultTraits<U>::value)>::type
	{		{
	DBGVAR(Singleton<Depth>::getInstance().value,index, name);		DBGVAR(Singleton<Depth>::getInstance().value,index, name);
	}		}

	template <typename U = T>		template <typename U = T>
	auto operator()(unsigned int index, const std::unique_ptr<MemberApproach<Class, T>>&, const std::string& name)		auto operator()(unsigned int index, const MemberApproach<Class, T>&, const std::string& name)
	-> typename std::enable_if<HasDefaultTraits<U>::value>::type		-> typename std::enable_if<HasDefaultTraits<U>::value>::type
	{		{
	DBGVAR(Singleton<Depth>::getInstance().value,index, name);		DBGVAR(Singleton<Depth>::getInstance().value,index, name);
	Singleton<Depth>::getInstance().value++;		Singleton<Depth>::getInstance().value++;
	Traits<T>::ttype::template apply<Func>();		Traits<T>::tr.template apply<Func>();
	Singleton<Depth>::getInstance().value--;		Singleton<Depth>::getInstance().value--;
	}		}
	};		};
	@@ -540,18 +541,18 @@ void testTraitApply() {

	DBGVAR(std::is_function<decltype (lambda)>::value);		DBGVAR(std::is_function<decltype (lambda)>::value);

	TraitApply<5>::apply(lambda);		//TraitApply<5>::apply(lambda);

	auto lambda1 = []( auto& , const std::string& name){DBGVAR(name);};		auto lambda1 = []( auto& , const std::string& name){DBGVAR(name);};

	TraitApply<5>::apply(lambda1);		//TraitApply<5>::apply(lambda1);
	DBGMSG("Tady");		DBGMSG("Tady");
	Traits<ExportTest>::ttype::apply<Func>();		Traits<ExportTest>::tr.apply<Func>();
	//TraitApply<5>::apply<Func>();		//TraitApply<5>::apply<Func>();

	Traits<ExportTest>::ttype::apply(lambda);		Traits<ExportTest>::tr.apply(lambda);

	Traits<ExportTest>::ttype::apply(lambda1);		Traits<ExportTest>::tr.apply(lambda1);

	//Traits<ExportTest>::ttype::apply<Func>();		//Traits<ExportTest>::ttype::apply<Func>();

	@@ -561,7 +562,7 @@ DBGMSG("Tady");

	/*		/*
	*		*
	* Compile time traits		* Compile time traits DONE
	*/		*/

	#include <cstdio>		#include <cstdio>
	@@ -863,7 +864,7 @@ private:
	template<unsigned int Index = 0, typename Dummy = void>		template<unsigned int Index = 0, typename Dummy = void>
	struct MemRefs: public MemRefs<Index + 1> {		struct MemRefs: public MemRefs<Index + 1> {

	const TestMemberReference<Class, type<Index>, refType<Index>> ref;		const MemberReference<Class, type<Index>, refType<Index>> ref;
	std::string name;		std::string name;

	template <typename ... REST>		template <typename ... REST>
	@@ -872,7 +873,7 @@ private:

	template<typename Dummy>		template<typename Dummy>
	struct MemRefs<sizeof...(RefTypes) - 1, Dummy>{		struct MemRefs<sizeof...(RefTypes) - 1, Dummy>{
	const TestMemberReference<Class, type<sizeof...(RefTypes) - 1>, refType<sizeof...(RefTypes) - 1>> ref;		const MemberReference<Class, type<sizeof...(RefTypes) - 1>, refType<sizeof...(RefTypes) - 1>> ref;
	std::string name;		std::string name;

	MemRefs(std::string n, refType<sizeof...(RefTypes) - 1> r) : ref(r), name(n){}		MemRefs(std::string n, refType<sizeof...(RefTypes) - 1> r) : ref(r), name(n){}
	@@ -912,7 +913,7 @@ public:


	template<unsigned int Index>		template<unsigned int Index>
	const TestMemberReference<Class, type<Index>, refType<Index>>& getReference(){		const MemberReference<Class, type<Index>, refType<Index>>& getReference(){
	return refs.MemRefs<Index, void>::ref;		return refs.MemRefs<Index, void>::ref;
	}		}

	@@ -1145,7 +1146,7 @@ void testTraitPerformance() {
	res = 0;		res = 0;
	for(int rep = 0; rep < maxRep; rep++){		for(int rep = 0; rep < maxRep; rep++){
	for(size_t i = 0; i < vec.size(); i++) {		for(size_t i = 0; i < vec.size(); i++) {
	res += Traits<ExportTest>::ttype::getValue<1>(vec[i]);		res += Traits<ExportTest>::tr.getValue<1>(vec[i]);
	}		}
	duration += (clock.now() - start).count();		duration += (clock.now() - start).count();
	deviation += (clock.now() - start).count() * (clock.now() - start).count();		deviation += (clock.now() - start).count() * (clock.now() - start).count();
	@@ -1300,7 +1301,7 @@ MAKE_NAMED_ATTRIBUTE_TRAIT(privateAttr, "str_attr", attr);
	void testPrivateTrait(){		void testPrivateTrait(){
	privateAttr a;		privateAttr a;
	DBGVAR(a);		DBGVAR(a);
	Traits<privateAttr>::ttype::setValue<0>(a, "new value");		Traits<privateAttr>::tr.setValue<0>(a, "new value");
	DBGVAR(a);		DBGVAR(a);

	}		}
	@@ -1471,7 +1472,7 @@ int main()
	//testStructTransposition();		//testStructTransposition();
	//testTraitApply();		//testTraitApply();
	//testCompileTimeTraits();		//testCompileTimeTraits();
	testTraitPerformance();		//testTraitPerformance();
	//testCustomUnorderedMap();		//testCustomUnorderedMap();
	//testPrivateTrait();		//testPrivateTrait();
	//testJson();		//testJson();

Unstructured_mesh/main.cpp

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -661,7 +661,7 @@ struct colourData {
	Vector<3, double> firstEdgeNormal;		Vector<3, double> firstEdgeNormal;
	};		};

	MAKE_ATTRIBUTE_TRAIT(colourData, colour, firstEdgeNormal);		MAKE_ATTRIBUTE_TRAIT(colourData, firstEdgeNormal, colour);

	void testMeshRefine() {		void testMeshRefine() {
	UnstructuredMesh<3, size_t, double, 6> mesh;		UnstructuredMesh<3, size_t, double, 6> mesh;
	@@ -722,7 +722,7 @@ void testMeshRefine() {


	ifstream in3D;		ifstream in3D;
	in3D.open("mesh_refine_1.vtk");		in3D.open("mesh_refine_1.vtk", std::ios::binary);
	VTKMeshReader<3> reader;		VTKMeshReader<3> reader;
	reader.loadFromStream(in3D, mesh);		reader.loadFromStream(in3D, mesh);

	@@ -1019,9 +1019,9 @@ 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/VariableExport.h

+10 −10

src/Traits/Traits.h

+59 −84

Original line number	Original line	Diff line number	Diff line
	@@ -6,112 +6,86 @@
	#include "../Singleton/Singleton.h"		#include "../Singleton/Singleton.h"
	#include <functional>		#include <functional>

	template<typename Class, typename...Types>		template<typename Class, typename...RefTypes>
	class Traits {		class Traits {
	public:		public:
	template<unsigned int Index>		template<unsigned int Index>
	using type = typename std::tuple_element<Index,std::tuple<Types...>>::type;		using refType = typename std::tuple_element<Index,std::tuple<RefTypes...>>::type;

			template <unsigned int Index>
			using type = typename MemberReferenceType<refType<Index>>::type;
	private:		private:
	template<unsigned int Index = sizeof...(Types) - 1, typename Dummy = void>		template<unsigned int Index = 0, typename Dummy = void>
	struct MemRefs: public MemRefs<Index - 1> {		struct MemRefs: public MemRefs<Index + 1> {
	friend class Singleton<MemRefs<1, void>>;
	std::unique_ptr<MemberApproach<Class, type<Index>>> ref = nullptr;		const MemberReference<Class, type<Index>, refType<Index>> ref;
	std::string name;		std::string name;

	MemRefs(){}		template <typename ... REST>
			MemRefs(std::string n, refType<Index> r, REST... rest) : MemRefs<Index + 1> (rest...), ref(r), name(n){}
	};		};

	template<typename Dummy>		template<typename Dummy>
	struct MemRefs<0, Dummy>{		struct MemRefs<sizeof...(RefTypes) - 1, Dummy>{
	friend class Singleton<MemRefs<0, void>>;		const MemberReference<Class, type<sizeof...(RefTypes) - 1>, refType<sizeof...(RefTypes) - 1>> ref;
	std::unique_ptr<MemberApproach<Class, type<0>>> ref = nullptr;
	std::string name;		std::string name;

	MemRefs(){}		MemRefs(std::string n, refType<sizeof...(RefTypes) - 1> r) : ref(r), name(n){}
	};		};

	using refs = Singleton<MemRefs<sizeof... (Types) - 1, void>>;		const MemRefs<0, void> refs;

	template<unsigned int Pos = 0, typename ref, typename...Refs>
	static void _makeReferences(const std::string& name, ref member,Refs... refsAndNames) {
	_makeReferences<Pos, ref>(name, member);
	_makeReferences<Pos+1>(refsAndNames...);
	}

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


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


	public:		public:



	static constexpr unsigned int size(){		static constexpr unsigned int size(){
	return sizeof... (Types);		return sizeof... (RefTypes);
	}		}


	template<unsigned int Index>		template<unsigned int Index>
	static const std::unique_ptr<MemberApproach<Class, type<Index>>>& getReference(){		const MemberReference<Class, type<Index>, refType<Index>>& getReference() const {
	return refs::getInstance().MemRefs<Index, void>::ref;		return refs.MemRefs<Index, void>::ref;
	}		}

	template<unsigned int Index>		template<unsigned int Index>
	static type<Index> getValue(const Class* c){		type<Index> getValue(const Class* c) const {
	return getReference<Index>()->getValue(c);		return getReference<Index>()->getValue(c);
	}		}

	template<unsigned int Index>		template<unsigned int Index>
	static type<Index> getValue(const Class& c){		type<Index> getValue(const Class& c) const {
	return getReference<Index>()->getValue(c);		return getReference<Index>().getValue(c);
	}		}

	template<unsigned int Index>		template<unsigned int Index>
	static void setValue(Class* c, const type<Index>& val){		void setValue(Class* c, const type<Index>& val) const {
	getReference<Index>()->setValue(c, val);		getReference<Index>().setValue(c, val);
	}		}

	template<unsigned int Index>		template<unsigned int Index>
	static void setValue(Class& c, const type<Index>& val){		void setValue(Class& c, const type<Index>& val) const {
	getReference<Index>()->setValue(c, val);		getReference<Index>().setValue(c, val);
	}		}


	template<unsigned int Index>		template<unsigned int Index>
	static const std::string& getName(){		const std::string& getName() const {
	return refs::getInstance().MemRefs<Index, void>::name;		return refs.MemRefs<Index, void>::name;
	}		}


	template<typename...Refs>		template<typename...Refs>
	Traits(Refs... refsAndNames){		Traits(Refs... refsAndNames) : refs(refsAndNames...){}
	makeReferences(refsAndNames...);
	}

	template<typename...Refs>
	static void makeReferences(Refs... refsAndNames) {
	_makeReferences<0>(refsAndNames...);
	}


	private:		private:

	template<unsigned int Index = 0, typename Dummy = void>		template<unsigned int Index = 0, typename Dummy = void>
	struct Apply {		struct Apply {
	using ThisTrait = Traits<Class, Types...>;		using ThisTrait = Traits<Class, RefTypes...>;

	template <class Functor>		template <class Functor>
	static auto apply (Functor f,...)		static auto apply (const ThisTrait& trait, Functor f,...)
	-> typename std::enable_if<std::is_assignable<		-> typename std::enable_if<std::is_assignable<
	std::function<		std::function<
	void(unsigned int,		void(unsigned int,
	@@ -137,14 +111,14 @@ private:
	)		)
	>, Functor>::value, "");		>, Functor>::value, "");

	f(Index, ThisTrait::getReference<Index>(), ThisTrait::getName<Index>());		f(Index, trait.template getReference<Index>(), trait.template getName<Index>());
	Apply<Index + 1>::apply(f);		Apply<Index + 1>::apply(trait, f);
	}		}



	template <class Functor>		template <class Functor>
	static auto apply (Functor f)		static auto apply (const ThisTrait& trait, Functor f)
	-> typename std::enable_if<std::is_assignable<		-> typename std::enable_if<std::is_assignable<
	std::function<		std::function<
	void(std::unique_ptr<		void(std::unique_ptr<
	@@ -168,40 +142,40 @@ private:
	)		)
	>, Functor>::value, "");		>, Functor>::value, "");

	f(ThisTrait::getReference<Index>(), ThisTrait::getName<Index>());		f(trait.template getReference<Index>(), trait.template getName<Index>());
	Apply<Index + 1>::apply(f);		Apply<Index + 1>::apply(trait, f);
	}		}

	template <template <typename, typename>class Functor>		template <template <typename, typename>class Functor>
	static auto apply ()		static auto apply (const ThisTrait& trait)
	-> typename std::enable_if<std::is_class<Functor<Class, typename ThisTrait::template type<Index>>>::value>::type		-> typename std::enable_if<std::is_class<Functor<Class, typename ThisTrait::template type<Index>>>::value>::type
	{		{

	static_assert (std::is_assignable<		static_assert (std::is_assignable<
	std::function<		std::function<
	void(unsigned int,		void(unsigned int,
	std::unique_ptr<		MemberReference<
	MemberApproach<
	Class,		Class,
	typename ThisTrait::template type<Index>		typename ThisTrait::template type<Index>,
	>>&,		typename ThisTrait::template refType<Index>
			>&,
	const std::string&		const std::string&
	)		)
	>, Functor<Class, typename ThisTrait::template type<Index>>>::value, "");		>, Functor<Class, typename ThisTrait::template type<Index>>>::value, "");


	Functor<Class, typename ThisTrait::template type<Index>>()(Index, ThisTrait::getReference<Index>(), ThisTrait::getName<Index>());		Functor<Class, typename ThisTrait::template type<Index>>()(Index, trait.template getReference<Index>(), trait.template getName<Index>());
	Apply<Index + 1>::template apply<Functor>();		Apply<Index + 1>::template apply<Functor>(trait);
	}		}

	};		};

	template<typename Dummy>		template<typename Dummy>
	struct Apply<size() - 1, Dummy> {		struct Apply<size() - 1, Dummy> {
	using ThisTrait = Traits<Class, Types...>;		using ThisTrait = Traits<Class, RefTypes...>;

	template <class Functor>		template <class Functor>
	static auto apply (Functor f,...)		static auto apply (const ThisTrait& trait, Functor f,...)
	-> typename std::enable_if<std::is_assignable<		-> typename std::enable_if<std::is_assignable<
	std::function<		std::function<
	void(unsigned int,		void(unsigned int,
	@@ -227,14 +201,14 @@ private:
	)		)
	>, Functor>::value, "");		>, Functor>::value, "");

	f(ThisTrait::size() - 1, ThisTrait::getReference<ThisTrait::size() - 1>(), ThisTrait::getName<ThisTrait::size() - 1>());		f(trait.size() - 1, trait.template getReference<ThisTrait::size() - 1>(), trait.template getName<ThisTrait::size() - 1>());

	}		}



	template <class Functor>		template <class Functor>
	static auto apply (Functor f)		static auto apply (const ThisTrait& trait, Functor f)
	-> typename std::enable_if<std::is_assignable<		-> typename std::enable_if<std::is_assignable<
	std::function<		std::function<
	void(std::unique_ptr<		void(std::unique_ptr<
	@@ -258,29 +232,30 @@ private:
	)		)
	>, Functor>::value, "");		>, Functor>::value, "");

	f(ThisTrait::getReference<ThisTrait::size() - 1>(), ThisTrait::getName<ThisTrait::size() - 1>());		f(trait.template getReference<ThisTrait::size() - 1>(), trait.template getName<ThisTrait::size() - 1>());

	}		}

	template <template <typename, typename>class Functor>		template <template <typename, typename>class Functor>
	static auto apply ()		static auto apply (const ThisTrait& trait)
	-> typename std::enable_if<std::is_class<Functor<Class, typename ThisTrait::template type<ThisTrait::size() - 1>>>::value>::type		-> typename std::enable_if<std::is_class<Functor<Class, typename ThisTrait::template type<ThisTrait::size() - 1>>>::value>::type
	{		{

	static_assert (std::is_assignable<		static_assert (std::is_assignable<
	std::function<		std::function<
	void(unsigned int,		void(unsigned int,
	std::unique_ptr<
	MemberApproach<		MemberReference<
	Class,		Class,
	typename ThisTrait::template type<ThisTrait::size() - 1>		typename ThisTrait::template type<ThisTrait::size() - 1>,
	>>&,		typename ThisTrait::template refType<ThisTrait::size() - 1>
			>&,
	const std::string&		const std::string&
	)		)
	>, Functor<Class, typename ThisTrait::template type<ThisTrait::size() - 1>>>::value, "");		>, Functor<Class, typename ThisTrait::template type<ThisTrait::size() - 1>>>::value, "");


	Functor<Class, typename ThisTrait::template type<ThisTrait::size() - 1>>()(ThisTrait::size() - 1, ThisTrait::getReference<ThisTrait::size() - 1>(), ThisTrait::getName<ThisTrait::size() - 1>());		Functor<Class, typename ThisTrait::template type<ThisTrait::size() - 1>>()(ThisTrait::size() - 1, trait.template getReference<ThisTrait::size() - 1>(), trait.template getName<ThisTrait::size() - 1>());
	}		}

	};		};
	@@ -294,13 +269,13 @@ public:
	* const std::string&)		* const std::string&)
	*/		*/
	template<typename Functor>		template<typename Functor>
	static void apply(Functor f) {		void apply(Functor f) const {
	Apply<>::apply(f);		Apply<>::apply(*this,f);
	}		}

	template<template <typename, typename>class Functor>		template<template <typename, typename>class Functor>
	static void apply() {		void apply() const {
	Apply<>::template apply<Functor>();		Apply<>::template apply<Functor>(*this);
	}		}
	};		};

	@@ -320,7 +295,7 @@ public:
	#include "../Macros/MacroForEach.h"		#include "../Macros/MacroForEach.h"


	#define MEMREF_TYPE_CUSTOM(name, memberRef) typename MemberReferenceType<decltype(memberRef)>::type		#define MEMREF_TYPE_CUSTOM(name, memberRef) decltype(memberRef)
	#define MAKE_CUSTOM_ATTRIBUTE_TRAIT(Class,...)\		#define MAKE_CUSTOM_ATTRIBUTE_TRAIT(Class,...)\
	template<> \		template<> \
	class Traits<Class>{ \		class Traits<Class>{ \

src/UnstructuredMesh/MeshDataContainer/MeshDataIO/VTKMeshDataReader.h

+20 −9

Original line number	Original line	Diff line number	Diff line
	@@ -29,15 +29,18 @@ class VTKMeshDataReader {
	>::type		>::type
	{		{

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

	typename Traits<T>::ttype::template type<Index> value;		typename Traits<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>::ttype::template getValue<Index>(data.at(i)).size(); j++){		for (unsigned int j = 0; j < Traits<T>::tr.template getValue<Index>(data.at(i)).size(); j++){
	ist >> value[j];		ist >> value[j];
	}		}
	Traits<T>::ttype::template setValue<Index>(data.at(i), value);		Traits<T>::tr.template setValue<Index>(data.at(i), value);
	}		}

	}		}
	@@ -57,13 +60,13 @@ class VTKMeshDataReader {
	typename Traits<T>::ttype::template type<Index> dummy;		typename Traits<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>::ttype::template getValue<Index>(data.at(i)).size(); j++){		for (unsigned int j = 0; j < Traits<T>::tr.template getValue<Index>(data.at(i)).size(); j++){
	ist >> value[j];		ist >> value[j];
	}		}

	ist >> dummy[0];		ist >> dummy[0];

	Traits<T>::ttype::template setValue<Index>(data.at(i), value);		Traits<T>::tr.template setValue<Index>(data.at(i), value);
	}		}

	}		}
	@@ -77,13 +80,13 @@ class VTKMeshDataReader {
	{		{


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

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

	for (IndexType i = 0; i < data.size(); i++){		for (IndexType i = 0; i < data.size(); i++){
	ist >> value;		ist >> value;
	Traits<T>::ttype::template setValue<Index>(data.at(i), value);		Traits<T>::tr.template setValue<Index>(data.at(i), value);
	}		}

	}		}
	@@ -98,7 +101,7 @@ private:


	static void read(std::istream& ist, DataContainer<T, MeshDimension> &data, std::map<std::string, std::istream::pos_type>& dataPositions){		static void read(std::istream& ist, DataContainer<T, MeshDimension> &data, std::map<std::string, std::istream::pos_type>& dataPositions){
	DBGVAR(IsIndexable<typename Traits<T>::ttype::template type<Index>>::value);
	readColumn<T, Index>(ist, data, dataPositions);		readColumn<T, Index>(ist, data, dataPositions);
	readCellData<Traits<T, Types...>, Index + 1>::read(ist, data, dataPositions);		readCellData<Traits<T, Types...>, Index + 1>::read(ist, data, dataPositions);

	@@ -122,10 +125,16 @@ public:
	static std::map<std::string, std::istream::pos_type> indexData(std::istream& ist) {		static std::map<std::string, std::istream::pos_type> indexData(std::istream& ist) {

	std::map<std::string, std::istream::pos_type> dataPositions;		std::map<std::string, std::istream::pos_type> dataPositions;
			/*
			if ((ist.flags() & std::ios::binary) != 0) {
			std::runtime_error("open the file stream as binary to ensure correct behaviour of tellg");
			}
			*/

	std::string line;		std::string line;
	ist.seekg(ist.beg);		ist.seekg(ist.beg);
	while(getline(ist, line)) {		while(std::getline(ist, line, '\n')) {

	int flag = (line.find("SCALARS")!= line.npos ? 1		int flag = (line.find("SCALARS")!= line.npos ? 1
	: line.find("VECTORS") != line.npos ? 2		: line.find("VECTORS") != line.npos ? 2
	: 0 );		: 0 );
	@@ -139,7 +148,9 @@ public:
	ist.ignore(500, '\n');		ist.ignore(500, '\n');
	}		}


	dataPositions.insert(std::make_pair(dataName, ist.tellg()));		dataPositions.insert(std::make_pair(dataName, ist.tellg()));
			//ist.seekg(ist.tellg());
	}		}
	}		}
	ist.clear();		ist.clear();

Original line number	Original line	Diff line number	Diff line
	@@ -153,8 +153,8 @@ struct VariableExport {
	template<typename T,unsigned int Index = 0, typename Void = void>		template<typename T,unsigned int Index = 0, typename Void = void>
	struct PrintClass{		struct PrintClass{
	static void print(std::ostream& ost, const T &traitedClass){		static void print(std::ostream& ost, const T &traitedClass){
	ost << '"' << Traits<T>::ttype::template getName<Index>() << "\" : ";		ost << '"' << Traits<T>::tr.template getName<Index>() << "\" : ";
	VariableExport::exportVariable(ost, Traits<T>::ttype::template getReference<Index>()->getValue(traitedClass));		VariableExport::exportVariable(ost, Traits<T>::tr.template getValue<Index>(traitedClass));
	ost << ", ";		ost << ", ";
	PrintClass<T, Index + 1>::print(ost, traitedClass);		PrintClass<T, Index + 1>::print(ost, traitedClass);

	@@ -163,9 +163,9 @@ 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){		static void print(std::ostream& ost, const T &traitedClass, const Traits<T, Types...>& trait = Traits<T>::tr){
	ost << '"' << Traits<T, Types...>::template getName<Index>() << "\" : ";		ost << '"' << trait.template getName<Index>() << "\" : ";
	VariableExport::exportVariable(ost, Traits<T, Types...>::template getReference<Index>()->getValue(traitedClass));		VariableExport::exportVariable(ost, trait.template getValue<Index>(traitedClass));
	ost << ", ";		ost << ", ";
	PrintClass<Traits<T, Types...>, Index + 1>::print(ost, traitedClass);		PrintClass<Traits<T, Types...>, Index + 1>::print(ost, traitedClass);

	@@ -174,17 +174,17 @@ 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){		static void print(std::ostream& ost, const T &traitedClass, const Traits<T, Types...>& trait = Traits<T>::tr){
	ost << '"' << Traits<T, Types...>::template getName<Traits<T, Types...>::size() - 1>() << "\" : ";		ost << '"' << trait.template getName<Traits<T, Types...>::size() - 1>() << "\" : ";
	VariableExport::exportVariable(ost, Traits<T, Types...>::template getReference<Traits<T, Types...>::size() - 1>()->getValue(traitedClass));		VariableExport::exportVariable(ost, trait.template getValue<Traits<T, Types...>::size() - 1>(traitedClass));
	}		}
	};		};

	template<typename T, unsigned int Index>		template<typename T, unsigned int Index>
	struct PrintClass<T, Index, typename std::enable_if<Index == Traits<T>::ttype::size() - 1>::type>{		struct PrintClass<T, Index, typename std::enable_if<Index == Traits<T>::ttype::size() - 1>::type>{
	static void print(std::ostream& ost, const T &traitedClass){		static void print(std::ostream& ost, const T &traitedClass){
	ost << '"' << Traits<T>::ttype::template getName<Traits<T>::ttype::size() - 1>() << "\" : ";		ost << '"' << Traits<T>::tr.template getName<Traits<T>::ttype::size() - 1>() << "\" : ";
	VariableExport::exportVariable(ost, Traits<T>::ttype::template getReference<Traits<T>::ttype::size() - 1>()->getValue(traitedClass));		VariableExport::exportVariable(ost, Traits<T>::tr.template getValue<Traits<T>::tr.size() - 1>(traitedClass));
	}		}
	};		};