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

Moved macro FOR_EACH into its headder.

parent b1e44885

Macros/MacroForEach.h

0 → 100644
+92 −0
Original line number Diff line number Diff line 
#ifndef MACROFOREACH_H

#define MACROFOREACH_H



#define FOR_EACH_NARG(...) FOR_EACH_NARG_(__VA_ARGS__, FOR_EACH_RSEQ_N())

#define FOR_EACH_NARG_(...) FOR_EACH_ARG_N(__VA_ARGS__)

#define FOR_EACH_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, N, ...) N

#define FOR_EACH_RSEQ_N() 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 09, 08, 07, 06, 05, 04, 03, 02, 01, 00





#define CONCATENATE(arg1, arg2)   CONCATENATE1(arg1, arg2)

#define CONCATENATE1(arg1, arg2)  CONCATENATE2(arg1, arg2)

#define CONCATENATE2(arg1, arg2)  arg1##arg2



#define FOR_EACH_00(what, ...)

#define FOR_EACH_01(what, x, ...)   what(x)

#define FOR_EACH_02(what, x, ...)   what(x), FOR_EACH_01(what, __VA_ARGS__)

#define FOR_EACH_03(what, x, ...)   what(x), FOR_EACH_02(what, __VA_ARGS__)

#define FOR_EACH_04(what, x, ...)   what(x), FOR_EACH_03(what, __VA_ARGS__)

#define FOR_EACH_05(what, x, ...)   what(x), FOR_EACH_04(what, __VA_ARGS__)

#define FOR_EACH_06(what, x, ...)   what(x), FOR_EACH_05(what, __VA_ARGS__)

#define FOR_EACH_07(what, x, ...)   what(x), FOR_EACH_06(what, __VA_ARGS__)

#define FOR_EACH_08(what, x, ...)   what(x), FOR_EACH_07(what, __VA_ARGS__)

#define FOR_EACH_09(what, x, ...)   what(x), FOR_EACH_08(what, __VA_ARGS__)

#define FOR_EACH_10(what, x, ...)   what(x), FOR_EACH_09(what, __VA_ARGS__)

#define FOR_EACH_11(what, x, ...)   what(x), FOR_EACH_10(what, __VA_ARGS__)

#define FOR_EACH_12(what, x, ...)   what(x), FOR_EACH_11(what, __VA_ARGS__)

#define FOR_EACH_13(what, x, ...)   what(x), FOR_EACH_12(what, __VA_ARGS__)

#define FOR_EACH_14(what, x, ...)   what(x), FOR_EACH_13(what, __VA_ARGS__)

#define FOR_EACH_15(what, x, ...)   what(x), FOR_EACH_14(what, __VA_ARGS__)

#define FOR_EACH_16(what, x, ...)   what(x), FOR_EACH_15(what, __VA_ARGS__)

#define FOR_EACH_17(what, x, ...)   what(x), FOR_EACH_16(what, __VA_ARGS__)

#define FOR_EACH_18(what, x, ...)   what(x), FOR_EACH_17(what, __VA_ARGS__)

#define FOR_EACH_19(what, x, ...)   what(x), FOR_EACH_18(what, __VA_ARGS__)

#define FOR_EACH_20(what, x, ...)   what(x), FOR_EACH_19(what, __VA_ARGS__)

#define FOR_EACH_21(what, x, ...)   what(x), FOR_EACH_20(what, __VA_ARGS__)

#define FOR_EACH_22(what, x, ...)   what(x), FOR_EACH_21(what, __VA_ARGS__)

#define FOR_EACH_23(what, x, ...)   what(x), FOR_EACH_22(what, __VA_ARGS__)

#define FOR_EACH_24(what, x, ...)   what(x), FOR_EACH_23(what, __VA_ARGS__)

#define FOR_EACH_25(what, x, ...)   what(x), FOR_EACH_24(what, __VA_ARGS__)

#define FOR_EACH_26(what, x, ...)   what(x), FOR_EACH_25(what, __VA_ARGS__)

#define FOR_EACH_27(what, x, ...)   what(x), FOR_EACH_26(what, __VA_ARGS__)

#define FOR_EACH_28(what, x, ...)   what(x), FOR_EACH_27(what, __VA_ARGS__)

#define FOR_EACH_29(what, x, ...)   what(x), FOR_EACH_28(what, __VA_ARGS__)

#define FOR_EACH_30(what, x, ...)   what(x), FOR_EACH_29(what, __VA_ARGS__)

#define FOR_EACH_31(what, x, ...)   what(x), FOR_EACH_30(what, __VA_ARGS__)

#define FOR_EACH_32(what, x, ...)   what(x), FOR_EACH_31(what, __VA_ARGS__)

#define FOR_EACH_33(what, x, ...)   what(x), FOR_EACH_32(what, __VA_ARGS__)

#define FOR_EACH_34(what, x, ...)   what(x), FOR_EACH_33(what, __VA_ARGS__)

#define FOR_EACH_35(what, x, ...)   what(x), FOR_EACH_34(what, __VA_ARGS__)

#define FOR_EACH_36(what, x, ...)   what(x), FOR_EACH_35(what, __VA_ARGS__)

#define FOR_EACH_37(what, x, ...)   what(x), FOR_EACH_36(what, __VA_ARGS__)

#define FOR_EACH_38(what, x, ...)   what(x), FOR_EACH_37(what, __VA_ARGS__)

#define FOR_EACH_39(what, x, ...)   what(x), FOR_EACH_38(what, __VA_ARGS__)

#define FOR_EACH_40(what, x, ...)   what(x), FOR_EACH_39(what, __VA_ARGS__)





#define FOR_EACH_(N, what, ...) CONCATENATE(FOR_EACH_, N)(what, __VA_ARGS__)

#define FOR_EACH(what, ...) FOR_EACH_(FOR_EACH_NARG(__VA_ARGS__), what, __VA_ARGS__)







#define FOR_EACH_EVEN_00(what, ...)

#define FOR_EACH_EVEN_02(what, x_odd, x_even, ...)   what(x_even)

#define FOR_EACH_EVEN_04(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_02(what, __VA_ARGS__)

#define FOR_EACH_EVEN_06(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_04(what, __VA_ARGS__)

#define FOR_EACH_EVEN_08(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_06(what, __VA_ARGS__)

#define FOR_EACH_EVEN_10(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_08(what, __VA_ARGS__)

#define FOR_EACH_EVEN_12(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_10(what, __VA_ARGS__)

#define FOR_EACH_EVEN_14(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_12(what, __VA_ARGS__)

#define FOR_EACH_EVEN_16(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_14(what, __VA_ARGS__)

#define FOR_EACH_EVEN_18(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_16(what, __VA_ARGS__)

#define FOR_EACH_EVEN_20(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_18(what, __VA_ARGS__)

#define FOR_EACH_EVEN_22(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_20(what, __VA_ARGS__)

#define FOR_EACH_EVEN_24(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_22(what, __VA_ARGS__)

#define FOR_EACH_EVEN_26(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_24(what, __VA_ARGS__)

#define FOR_EACH_EVEN_28(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_26(what, __VA_ARGS__)

#define FOR_EACH_EVEN_30(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_28(what, __VA_ARGS__)

#define FOR_EACH_EVEN_32(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_30(what, __VA_ARGS__)

#define FOR_EACH_EVEN_34(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_32(what, __VA_ARGS__)

#define FOR_EACH_EVEN_36(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_34(what, __VA_ARGS__)

#define FOR_EACH_EVEN_38(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_36(what, __VA_ARGS__)

#define FOR_EACH_EVEN_40(what, x_odd, x_even, ...)   what(x_even), FOR_EACH_EVEN_38(what, __VA_ARGS__)



#define FOR_EACH_EVEN_(N, what, ...) CONCATENATE(FOR_EACH_EVEN_, N)(what, __VA_ARGS__)

#define FOR_EACH_EVEN(what, ...) FOR_EACH_EVEN_(FOR_EACH_NARG(__VA_ARGS__), what, __VA_ARGS__)

/*

#define DUMMY

#define FOR_EACH_ODD_(N, what, ...) CONCATENATE(FOR_EACH_EVEN_, N)(what, __VA_ARGS__)

#define FOR_EACH_ODD(what, ...) FOR_EACH_EVEN_(FOR_EACH_NARG( , __VA_ARGS__), what, , __VA_ARGS__)

*/



#endif // MACROFOREACH_H

TemplateTest/main.cpp

+41 −18
Original line number Diff line number Diff line
@@ -47,7 +47,7 @@ struct member_ptr { 


struct Temp {

    double data;

    double fun(double d){return data;}

    double fun(double d [[maybe_unused]]){return data;}

};



void testDebug() {
@@ -261,35 +261,58 @@ struct tempData { 
    }



};

MAKE_ATRIBUTE_TRAITS(tempData,"density"s, &tempData::density, "momentum"s, std::make_pair(&tempData::getMomentum, &tempData::setMomentum));

/*

template<>

class Traits<tempData>{

public:

    static Traits<tempData, double, Vector<3,double>> tr;

};



Traits<tempData, double, Vector<3,double>> Traits<tempData>::tr("density"s, &tempData::density, "momentum"s, std::make_pair(&tempData::getMomentum, &tempData::setMomentum));

*/



void testMemberRef(){

using tempDataTraits = Traits<tempData, double, Vector<3,double>>;



    MemberApproach<tempData, double>* app;



    //MemberReference<tempData, double, bool> invalid;

void testMemberRef(){



    MemberReference<tempData, double>::SuperRef<double tempData::*> ref(&tempData::density);

    MemberReference<tempData, double>::SuperRef<double& (tempData::*)()> ref1(&tempData::getData);

     auto temp = MemberReferenceType<decltype (&tempData::getData)>::type(42.15);

     auto temp2 = MemberReferenceType<std::pair<decltype (&tempData::getMomentum), decltype (&tempData::setMomentum)>>::type();



    MemberReference<tempData, Vector<3,double>>::SuperRef ref2(std::make_pair(&tempData::getMomentum, &tempData::setMomentum));



    app = &ref;

    app = &ref1;

    tempData d;

    app->setValue(&d, 42.15);

    DBGVAR(app->getValue(&d));

     DBGVAR(temp,temp2);



    MemberApproach<tempData, Vector<3,double>>* app2 = &ref2;

    app2->setValue(&d, {42.15,84.30,42.15});

    DBGVAR(app2->getValue(&d), d.velocity);

    static tempDataTraits tr("density"s, &tempData::density, "momentum"s, std::make_pair(&tempData::getMomentum, &tempData::setMomentum));

    tempData d;



    Traits<tempData, double, Vector<3,double>> r;

    Traits<tempData, double, Vector<3,double>>::getReference<0>() = &ref; //new MemberReference<tempData, double>::SuperRef<double tempData::*>(&tempData::density);

    /*Traits<tempData, double, Vector<3,double>>::getReference<0>() = &ref; //new MemberReference<tempData, double>::SuperRef<double tempData::*>(&tempData::density);

    Traits<tempData, double, Vector<3,double>>::getReference<1>() = new MemberReference<tempData, Vector<3, double>>::SuperRef(std::make_pair(&tempData::getMomentum, &tempData::setMomentum));

    DBGVAR(r.refs.MemRefs<0>::ref->getValue(&d), (Traits<tempData, double, Vector<3,double>>::getReference<1>()->getValue(&d)));

    */

    tr.getReference<0>()->setValue(&d, 0.0);

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

    tempDataTraits::getReference<0>()->setValue(&d, 42.15);

    tempDataTraits::getReference<1>()->setValue(&d, {42.15,84.30,42.15});



    DBGVAR((tempDataTraits::getReference<0>()->getValue(&d)), (Traits<tempData, double, Vector<3,double>>::getReference<1>()->getValue(&d)), d.velocity);

}



































void testOrig() {

    Vertex<5, double> vert;

    vector<double> vec;

Unstructured_mesh/UnstructuredMesh/MeshDataContainer/MemberApproach.h

+0 −1
Original line number Diff line number Diff line
@@ -62,7 +62,6 @@ public: 


       Reference(Ref referenceToMember){

           ref = referenceToMember;

           DBGVAR((std::is_same<Ref, ValueType Class::*>::value));

       }



       virtual ValueType getValue(Class* c) override {

Unstructured_mesh/UnstructuredMesh/MeshDataContainer/Traits.h

+83 −20
Original line number Diff line number Diff line
@@ -2,11 +2,7 @@ 
#define TRAITS_H

#include "MemberApproach.h"

#include <string>



namespace Detail {





}

#include <memory>





template<typename Class, typename...Types>
@@ -17,48 +13,115 @@ class Traits { 


    template<unsigned int Index = sizeof...(Types) - 1, typename Dummy = void>

    struct MemRefs: public MemRefs<Index - 1>{

        MemberApproach<Class, type<Index>>* ref = nullptr;

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

        std::string name;

    };



    template<typename Dummy>

    struct MemRefs<0, Dummy>{

        MemberApproach<Class, type<0>>* ref = nullptr;

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

        std::string name;

    };







    template<unsigned int Pos = 0, typename ref, typename...Refs>

    static void _makeReferences(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(std::string name, ref member) {

        refs.MemRefs<Pos, void>::name = name;

        getReference<Pos>() = std::unique_ptr<MemberApproach<Class, type<Pos>>>(new typename MemberReference<Class, type<Pos>>::template SuperRef<ref>(member));

    }





public:

    static MemRefs<sizeof... (Types) - 1, void> refs;





    static constexpr unsigned int size(){

        return sizeof... (Types);

    }





    template<unsigned int Index>

    static MemberApproach<Class, type<Index>>*& getReference(){

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

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

    }





    template<typename...Refs>

    Traits(Refs... refsAndNames){

        makeReferences(refsAndNames...);

    }



    template<typename...Refs>

    static void makeReferences(Refs... refsAndNames) {

        _makeReferences<0>(refsAndNames...);

    }



    template<unsigned int Pos = 0, typename ref, typename...Refs>

    static void _makeReferences(std::string name, ref member,Refs... refsAndNames) {

        _makeReferences<Pos, ref>(name, member);

        _makeReferences<Pos+1, Refs...>(refsAndNames...);

    }

};



    template<unsigned int Pos, typename ref>

    static void _makeReferences(std::string name, ref member) {

        refs.MemRefs<Pos, void>::name = name;

        refs.MemRefs<Pos, void>::ref = new typename MemberReference<Class, type<Pos>>::Reference(member);

    }

template<typename Class, typename... Types>

typename Traits<Class, Types...>::template MemRefs<sizeof... (Types) - 1> Traits<Class,Types...>::refs;









template <typename Ref>

struct MemberReferenceType {

    static_assert (std::is_trivial_v<Ref>, "The Ref must be a type of member reference (MemberType Class::*) or reference getter (MemberType& (Class::*)()) into class \

or a pair of getter and setter (std::pair<MemberType (Class::*)(), void (Class::*)(const MemberType&))");

};



template<typename Class, typename... Types>

typename Traits<Class, Types...>::template MemRefs<sizeof... (Types) - 1> Traits<Class,Types...>::refs;

template <typename Class, typename MemberType>

struct MemberReferenceType <MemberType Class::*>{

    using type = MemberType;

};





template <typename Class, typename MemberType>

struct MemberReferenceType <MemberType& (Class::*)()>{

    using type = MemberType;

};





template <typename Class, typename MemberType>

struct MemberReferenceType <std::pair<MemberType (Class::*)(), void (Class::*)(const MemberType&)>>{

    using type = MemberType;

};





template<typename Class>

class Traits<Class>{

    static_assert (true, "The Traits template must be specialized for given type and must contain Traits references using variadic Traits.");

};









#define _MAKE_ATRIBUTE_TRAITS(Class, ...)    \

template<>                              \

class Traits<Class>{                 \

public:                                 \

    static Traits<Class, double, Vector<3,double>> tr;   \

};                                      \

Traits<Class, double, Vector<3,double>> Traits<Class>::   \

tr(__VA_ARGS__); \







#define MAKE_ATRIBUTE_TRAITS(Class, ...)    \

template<>                              \

class Traits<Class>{                 \

public:                                 \

    static Traits<Class, double, Vector<3,double>> tr;   \

};                                      \

Traits<Class, double, Vector<3,double>> Traits<Class>::   \

tr(__VA_ARGS__); \





#endif // TRAITS_H

Unstructured_mesh/UnstructuredMesh/MeshFunctions/MeshFunctions.h

+17 −0
Original line number Diff line number Diff line
@@ -782,10 +782,12 @@ struct MeshColouring <FromDim, ToDim, false> { 
    static MeshDataContainer<unsigned int, FromDim> colour(

            MeshElements<MeshDimension, IndexType, Real, Reserve...>& mesh

            ) {

        // resulting container of colours

        MeshDataContainer<unsigned int, FromDim> result(mesh);



        DBGMSG("starting the coloring procedure");

        unsigned int reserve = 16;

        // allocates memory to the given dimension

        MeshDataContainer<std::valarray<bool>, ToDim> attachedColours(mesh, std::valarray<bool>(false, reserve));



        auto connections = MeshConnections<FromDim, ToDim>::connections(mesh);
@@ -798,9 +800,24 @@ struct MeshColouring <FromDim, ToDim, false> { 


            }



            // Select the first possible colour

            unsigned int selectedColour = 0;

            while (!possibleColours[selectedColour]) {

                selectedColour++;

                if (selectedColour == possibleColours.size()){

                    reserve *= 2;



                    // If the number of colours exceeds the number of

                    // allocated bits, then allocate twice as much memory

                    for (std::valarray<bool>& attColour : attachedColours.template getDataByPos<0>()){

                        std::valarray<bool> newAttColour(false, reserve);

                        for (size_t i = 0; i < attColour.size(); i++){

                            newAttColour[i] = attColour[i];

                        }

                        attColour.swap(newAttColour);

                    }

                    break;

                }

            }



            result.template getDataByPos<0>().at(startElement.getIndex()) = selectedColour;