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

IOTraits and ArithmeticTraits developed

parent 8a27c638

Unstructured_mesh/main.cpp

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





struct colourData {

    unsigned int colour;

struct colorData {

    unsigned int color;

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

    UnstructuredMesh<3, size_t, double, 6> mesh;
@@ -692,11 +694,11 @@ void testMeshRefine() { 
    writer1.writeToStream(out3D, mesh, types1);

    auto colours1 = MeshColoring<3,0>::color(mesh);



    MeshDataContainer<colourData, 3> cd(mesh);

    MeshDataContainer<colorData, 3> cd(mesh);

    auto normals = mesh.computeFaceNormals();



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

    }

    DBGVAR(cd.getDataByDim<3>());
@@ -726,7 +728,7 @@ void testMeshRefine() { 
    VTKMeshReader<3> reader;

    reader.loadFromStream(in3D, mesh);



    MeshDataContainer<colourData, 3> cd1(mesh);

    MeshDataContainer<colorData, 3> cd1(mesh);

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



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

src/Debug/VariableExport.h

+6 −6
Original line number Diff line number Diff line
@@ -163,7 +163,7 @@ 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, 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>() << "\" : ";

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

            ost << ", ";
@@ -174,7 +174,7 @@ 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, 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>() << "\" : ";

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

        }
@@ -192,11 +192,11 @@ struct VariableExport { 
    template<typename T>

    static auto exportVariable(std::ostream& ost, const T &traitedClass)

      -> typename std::enable_if<

             HasDefaultTraits<T>::value

             HasDefaultIOTraits<T>::value

         >::type

    {

        ost << "{ ";

        PrintClass<typename Traits<T>::ttype>::print(ost, traitedClass);

        PrintClass<typename DefaultIOTraits<T>::ttype>::print(ost, traitedClass);

        ost << " }";

    }
@@ -403,13 +403,13 @@ struct VariableExport<VARIABLE_EXPORT_METHOD::stdio> { 
    template<typename T>

    static auto exportVariable(const T &traitedClass)

      -> typename std::enable_if<

             HasDefaultTraits<T>::value,

             HasDefaultIOTraits<T>::value,

             std::string

         >::type

    {

        std::string res;

        res += "{ ";

        res += PrintClass<typename Traits<T>::ttype>::print(traitedClass);

        res += PrintClass<typename DefaultIOTraits<T>::ttype>::print(traitedClass);

        res += " }";

        return res;

    }

src/Traits/CustomTypeTraits.h

+36 −1
Original line number Diff line number Diff line
@@ -85,6 +85,35 @@ struct __has_default_traits< 
            Traits<T1>::is_specialized

        >::type

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

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

src/Traits/Traits.h

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




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

public:

    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"



#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 MAKE_CUSTOM_ATTRIBUTE_TRAIT(Class,...)\

#define IMPL_MAKE_CUSTOM_ATTRIBUTE_TRAIT(TraitName,Class,...)\

template<>                              \

class Traits<Class>{                 \

class TraitName<Class>{                 \

public:                             \

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

    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_ATTRIBUTE_TRAIT(Class, ...) MAKE_NAMED_ATTRIBUTE_TRAIT(Class, FOR_EACH(NAME_ATT, __VA_ARGS__))

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



#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

src/UnstructuredMesh/MeshDataContainer/MeshDataIO/VTKMeshDataReader.h

+17 −17
Original line number Diff line number Diff line
@@ -24,23 +24,23 @@ class VTKMeshDataReader { 
    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)

    -> typename std::enable_if<

        IsIndexable<typename Traits<T>::ttype::template type<Index>>::value &&

        IsIndexable<typename DefaultIOTraits<T>::ttype::template type<Index>>::value &&

        MeshDimension == 3

       >::type

    {



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

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

    std::string 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 (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];

            }

            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>

    static auto readColumn(std::istream& ist, DataContainer<T, MeshDimension> &data,std::map<std::string, std::istream::pos_type>& dataPositions)

    -> typename std::enable_if<

        IsIndexable<typename Traits<T>::ttype::template type<Index>>::value &&

        IsIndexable<typename DefaultIOTraits<T>::ttype::template type<Index>>::value &&

        MeshDimension == 2

       >::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 Traits<T>::ttype::template type<Index> dummy;

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

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



        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 >> dummy[0];



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

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

        }



    }
@@ -75,18 +75,18 @@ class VTKMeshDataReader { 
    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)

    -> typename std::enable_if<

        !IsIndexable<typename Traits<T>::ttype::template type<Index>>::value

        !IsIndexable<typename DefaultIOTraits<T>::ttype::template type<Index>>::value

    >::type

    {





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

            ist >> value;

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

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

        }



    }
@@ -162,7 +162,7 @@ public: 


        std::map<std::string, std::istream::pos_type> dataPositions = indexData(ist);



        readCellData<typename Traits<T>::ttype>::read(ist, data, dataPositions);

        readCellData<typename DefaultIOTraits<T>::ttype>::read(ist, data, dataPositions);

    }

};