Commit 8a27c638 authored by Tomáš Jakubec's avatar Tomáš Jakubec
Browse files

Class Traits is optimized its performance is the same as any other 

constexpr reference like cls.attr.
The tellg does not work as expected in text mode. There is problem with
CRLF on windows. Thus, the file must be opened in binary mode.
parent 3bb78eba

TemplateTest/main.cpp

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


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



    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});

    Traits<tempData>::tr.getReference<0>().setValue(&d, 0.0);

    DBGVAR(Traits<tempData>::tr.getReference<0>().getValue(&d));

    Traits<tempData>::tr.getReference<0>().setValue(d, 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);



    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{

    template <unsigned int index = 0, typename Dummy = void>

    struct StructOfArrays : public StructOfArrays<index + 1>{
@@ -340,7 +340,7 @@ struct Container{ 


    template <unsigned int pos>

    const std::string& name() {

        return DataTypeTrait::template getName<pos>();

        return Traits<DataType>::tr.template getName<pos>();

    }



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







void testStructTransposition() {

    Container<ExportTest, Traits<ExportTest>::ttype> data;
@@ -360,6 +359,7 @@ void testStructTransposition() { 
};







/**

  Test TraitApply

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

*/





/*

template < unsigned int index>

class TraitApply {

public:
@@ -505,6 +505,7 @@ public: 
        Functor<ExportTest, Traits<ExportTest>::ttype::type<0>>()(0, Traits<ExportTest>::ttype::getReference<0>(), Traits<ExportTest>::ttype::getName<0>());

    }

};

*/



struct Depth {

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



    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

    {

        DBGVAR(Singleton<Depth>::getInstance().value,index, name);

    }



    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

    {

        DBGVAR(Singleton<Depth>::getInstance().value,index, name);

        Singleton<Depth>::getInstance().value++;

        Traits<T>::ttype::template apply<Func>();

        Traits<T>::tr.template apply<Func>();

        Singleton<Depth>::getInstance().value--;

    }

};
@@ -540,18 +541,18 @@ void testTraitApply() { 


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



    TraitApply<5>::apply(lambda);

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



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



    TraitApply<5>::apply(lambda1);

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

DBGMSG("Tady");

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

    Traits<ExportTest>::tr.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>();
@@ -561,7 +562,7 @@ DBGMSG("Tady"); 


/*

 *

 * Compile time traits

 * Compile time traits DONE

 */



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

    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;



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


    template<typename 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;



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




    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;

    }
@@ -1145,7 +1146,7 @@ void testTraitPerformance() { 
    res = 0;

    for(int rep = 0; rep < maxRep; rep++){

        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();

        deviation += (clock.now() - start).count() * (clock.now() - start).count();
@@ -1300,7 +1301,7 @@ MAKE_NAMED_ATTRIBUTE_TRAIT(privateAttr, "str_attr", attr); 
void testPrivateTrait(){

    privateAttr a;

    DBGVAR(a);

    Traits<privateAttr>::ttype::setValue<0>(a, "new value");

    Traits<privateAttr>::tr.setValue<0>(a, "new value");

    DBGVAR(a);



}
@@ -1471,7 +1472,7 @@ int main() 
    //testStructTransposition();

    //testTraitApply();

    //testCompileTimeTraits();

    testTraitPerformance();

    //testTraitPerformance();

    //testCustomUnorderedMap();

    //testPrivateTrait();

    //testJson();

Unstructured_mesh/main.cpp

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

};



MAKE_ATTRIBUTE_TRAIT(colourData, colour, firstEdgeNormal);

MAKE_ATTRIBUTE_TRAIT(colourData, firstEdgeNormal, colour);



void testMeshRefine() {

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




    ifstream in3D;

    in3D.open("mesh_refine_1.vtk");

    in3D.open("mesh_refine_1.vtk", std::ios::binary);

    VTKMeshReader<3> reader;

    reader.loadFromStream(in3D, mesh);
@@ -1019,9 +1019,9 @@ int main() 
    //meshSize();

    //testMesh2D();

    //testMesh2DLoadAndWrite();

    testMesh3D();

    //testMesh3D();

    //test3DMeshDeformedPrisms();

    //testMeshRefine();

    testMeshRefine();

    //testMeshDataContainer();

    //UnstructuredMesh<5, size_t, double, 6,5,4> m;

    //m.ComputeElementMeasures();

src/Debug/VariableExport.h

+10 −10
Original line number Diff line number Diff line
@@ -153,8 +153,8 @@ struct VariableExport { 
    template<typename T,unsigned int Index = 0, typename Void = void>

    struct PrintClass{

        static void print(std::ostream& ost, const T &traitedClass){

            ost << '"' << Traits<T>::ttype::template getName<Index>() << "\" : ";

            VariableExport::exportVariable(ost, Traits<T>::ttype::template getReference<Index>()->getValue(traitedClass));

            ost << '"' << Traits<T>::tr.template getName<Index>() << "\" : ";

            VariableExport::exportVariable(ost, Traits<T>::tr.template getValue<Index>(traitedClass));

            ost << ", ";

            PrintClass<T, Index + 1>::print(ost, traitedClass);
@@ -163,9 +163,9 @@ struct VariableExport { 


    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>{

        static void print(std::ostream& ost, const T &traitedClass){

            ost << '"' << Traits<T, Types...>::template getName<Index>() << "\" : ";

            VariableExport::exportVariable(ost, Traits<T, Types...>::template getReference<Index>()->getValue(traitedClass));

        static void print(std::ostream& ost, const T &traitedClass, const Traits<T, Types...>& trait = Traits<T>::tr){

            ost << '"' << trait.template getName<Index>() << "\" : ";

            VariableExport::exportVariable(ost, trait.template getValue<Index>(traitedClass));

            ost << ", ";

            PrintClass<Traits<T, Types...>, Index + 1>::print(ost, traitedClass);
@@ -174,17 +174,17 @@ struct VariableExport { 


    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>{

        static void print(std::ostream& ost, const T &traitedClass){

            ost << '"' << Traits<T, Types...>::template getName<Traits<T, Types...>::size() - 1>() << "\" : ";

            VariableExport::exportVariable(ost, Traits<T, Types...>::template getReference<Traits<T, Types...>::size() - 1>()->getValue(traitedClass));

        static void print(std::ostream& ost, const T &traitedClass, const Traits<T, Types...>& trait = Traits<T>::tr){

            ost << '"' << trait.template getName<Traits<T, Types...>::size() - 1>() << "\" : ";

            VariableExport::exportVariable(ost, trait.template getValue<Traits<T, Types...>::size() - 1>(traitedClass));

        }

    };



    template<typename T, unsigned int Index>

    struct PrintClass<T, Index, typename std::enable_if<Index == Traits<T>::ttype::size() - 1>::type>{

        static void print(std::ostream& ost, const T &traitedClass){

            ost << '"' << Traits<T>::ttype::template getName<Traits<T>::ttype::size() - 1>() << "\" : ";

            VariableExport::exportVariable(ost, Traits<T>::ttype::template getReference<Traits<T>::ttype::size() - 1>()->getValue(traitedClass));

            ost << '"' << Traits<T>::tr.template getName<Traits<T>::ttype::size() - 1>() << "\" : ";

            VariableExport::exportVariable(ost, Traits<T>::tr.template getValue<Traits<T>::tr.size() - 1>(traitedClass));

        }

    };

src/Traits/Traits.h

+59 −84
Original line number Diff line number Diff line
@@ -6,112 +6,86 @@ 
#include "../Singleton/Singleton.h"

#include <functional>



template<typename Class, typename...Types>

template<typename Class, typename...RefTypes>

class Traits {

public:

    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:

    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;

    template<unsigned int Index = 0, typename Dummy = void>

    struct MemRefs: public MemRefs<Index + 1> {



        const MemberReference<Class, type<Index>, refType<Index>> ref;

        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>

    struct MemRefs<0, Dummy>{

        friend class Singleton<MemRefs<0, void>>;

        std::unique_ptr<MemberApproach<Class, type<0>>> ref = nullptr;

    struct MemRefs<sizeof...(RefTypes) - 1, Dummy>{

        const MemberReference<Class, type<sizeof...(RefTypes) - 1>, refType<sizeof...(RefTypes) - 1>> ref;

        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>>;



    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));

    }



    const MemRefs<0, void> refs;



public:







    static constexpr unsigned int size(){

        return sizeof... (Types);

        return sizeof... (RefTypes);

    }





    template<unsigned int Index>

    static const std::unique_ptr<MemberApproach<Class, type<Index>>>& getReference(){

        return refs::getInstance().MemRefs<Index, void>::ref;

    const MemberReference<Class, type<Index>, refType<Index>>& getReference() const {

        return refs.MemRefs<Index, void>::ref;

    }



    template<unsigned int Index>

    static type<Index> getValue(const Class* c){

    type<Index> getValue(const Class* c) const {

        return getReference<Index>()->getValue(c);

    }



    template<unsigned int Index>

    static type<Index> getValue(const Class& c){

        return getReference<Index>()->getValue(c);

    type<Index> getValue(const Class& c) const {

        return getReference<Index>().getValue(c);

    }



    template<unsigned int Index>

    static void setValue(Class* c, const type<Index>& val){

        getReference<Index>()->setValue(c, val);

    void setValue(Class* c, const type<Index>& val) const {

        getReference<Index>().setValue(c, val);

    }



    template<unsigned int Index>

    static void setValue(Class& c, const type<Index>& val){

        getReference<Index>()->setValue(c, val);

    void setValue(Class& c, const type<Index>& val) const {

        getReference<Index>().setValue(c, val);

    }





    template<unsigned int Index>

    static const std::string& getName(){

        return refs::getInstance().MemRefs<Index, void>::name;

    const std::string& getName() const {

        return refs.MemRefs<Index, void>::name;

    }





    template<typename...Refs>

    Traits(Refs... refsAndNames){

        makeReferences(refsAndNames...);

    }



    template<typename...Refs>

    static void makeReferences(Refs... refsAndNames) {

        _makeReferences<0>(refsAndNames...);

    }





    Traits(Refs... refsAndNames) : refs(refsAndNames...){}

private:



    template<unsigned int Index = 0, typename Dummy = void>

    struct Apply {

        using ThisTrait = Traits<Class, Types...>;

        using ThisTrait = Traits<Class, RefTypes...>;



        template <class Functor>

        static auto apply (Functor f,...)

        static auto apply (const ThisTrait& trait, Functor f,...)

        -> typename std::enable_if<std::is_assignable<

        std::function<

            void(unsigned int,
@@ -137,14 +111,14 @@ private: 
                             )

                    >, Functor>::value, "");



            f(Index, ThisTrait::getReference<Index>(), ThisTrait::getName<Index>());

            Apply<Index + 1>::apply(f);

            f(Index, trait.template getReference<Index>(), trait.template getName<Index>());

            Apply<Index + 1>::apply(trait, f);

        }







        template <class Functor>

        static auto apply (Functor f)

        static auto apply (const ThisTrait& trait, Functor f)

        -> typename std::enable_if<std::is_assignable<

        std::function<

            void(std::unique_ptr<
@@ -168,40 +142,40 @@ private: 
                             )

                    >, Functor>::value, "");



            f(ThisTrait::getReference<Index>(), ThisTrait::getName<Index>());

            Apply<Index + 1>::apply(f);

            f(trait.template getReference<Index>(), trait.template getName<Index>());

            Apply<Index + 1>::apply(trait, f);

        }



        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

        {



            static_assert (std::is_assignable<

                    std::function<

                        void(unsigned int,

                             std::unique_ptr<

                                MemberApproach<

                             MemberReference<

                                    Class,

                                    typename ThisTrait::template type<Index>

                                >>&,

                                    typename ThisTrait::template type<Index>,

                                    typename ThisTrait::template refType<Index>

                                >&,

                             const std::string&

                             )

                    >, Functor<Class, typename ThisTrait::template type<Index>>>::value, "");





            Functor<Class, typename ThisTrait::template type<Index>>()(Index, ThisTrait::getReference<Index>(), ThisTrait::getName<Index>());

            Apply<Index + 1>::template apply<Functor>();

            Functor<Class, typename ThisTrait::template type<Index>>()(Index, trait.template getReference<Index>(), trait.template getName<Index>());

            Apply<Index + 1>::template apply<Functor>(trait);

        }



    };



    template<typename Dummy>

    struct Apply<size() - 1, Dummy> {

        using ThisTrait = Traits<Class, Types...>;

        using ThisTrait = Traits<Class, RefTypes...>;



        template <class Functor>

        static auto apply (Functor f,...)

        static auto apply (const ThisTrait& trait, Functor f,...)

        -> typename std::enable_if<std::is_assignable<

        std::function<

            void(unsigned int,
@@ -227,14 +201,14 @@ private: 
                             )

                    >, 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>

        static auto apply (Functor f)

        static auto apply (const ThisTrait& trait, Functor f)

        -> typename std::enable_if<std::is_assignable<

        std::function<

            void(std::unique_ptr<
@@ -258,29 +232,30 @@ private: 
                             )

                    >, 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>

        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

        {



            static_assert (std::is_assignable<

                    std::function<

                        void(unsigned int,

                             std::unique_ptr<

                                MemberApproach<



                                MemberReference<

                                    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&

                             )

                    >, 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&)

     */

    template<typename Functor>

        static void apply(Functor f) {

            Apply<>::apply(f);

        void apply(Functor f) const {

            Apply<>::apply(*this,f);

        }



    template<template <typename, typename>class Functor>

        static void apply() {

            Apply<>::template apply<Functor>();

        void apply() const {

            Apply<>::template apply<Functor>(*this);

        }

};
@@ -320,7 +295,7 @@ public: 
#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,...)\

template<>                              \

class Traits<Class>{                 \

src/UnstructuredMesh/MeshDataContainer/MeshDataIO/VTKMeshDataReader.h

+20 −9
Original line number Diff line number Diff line
@@ -29,15 +29,18 @@ class VTKMeshDataReader { 
       >::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;



        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];

            }

            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;



        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 >> 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;



        for (IndexType i = 0; i < data.size(); i++){

            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){

            DBGVAR(IsIndexable<typename Traits<T>::ttype::template type<Index>>::value);



            readColumn<T, Index>(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) {



        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;

        ist.seekg(ist.beg);

        while(getline(ist, line)) {

        while(std::getline(ist, line, '\n')) {



            int flag = (line.find("SCALARS")!= line.npos ? 1

                             : line.find("VECTORS") != line.npos ? 2

                                   : 0 );
@@ -139,7 +148,9 @@ public: 
                    ist.ignore(500, '\n');

                }





                dataPositions.insert(std::make_pair(dataName, ist.tellg()));

                //ist.seekg(ist.tellg());

            }

        }

        ist.clear();