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

adding files

parent 74ac0d38

TemplateTest/.gitignore

0 → 100644
+73 −0
Original line number Original line Diff line number Diff line 
# This file is used to ignore files which are generated

# ----------------------------------------------------------------------------



*~

*.autosave

*.a

*.core

*.moc

*.o

*.obj

*.orig

*.rej

*.so

*.so.*

*_pch.h.cpp

*_resource.rc

*.qm

.#*

*.*#

core

!core/

tags

.DS_Store

.directory

*.debug

Makefile*

*.prl

*.app

moc_*.cpp

ui_*.h

qrc_*.cpp

Thumbs.db

*.res

*.rc

/.qmake.cache

/.qmake.stash



# qtcreator generated files

*.pro.user*



# xemacs temporary files

*.flc



# Vim temporary files

.*.swp



# Visual Studio generated files

*.ib_pdb_index

*.idb

*.ilk

*.pdb

*.sln

*.suo

*.vcproj

*vcproj.*.*.user

*.ncb

*.sdf

*.opensdf

*.vcxproj

*vcxproj.*



# MinGW generated files

*.Debug

*.Release



# Python byte code

*.pyc



# Binaries

# --------

*.dll

*.exe

TemplateTest/TemplateTest.pro

0 → 100644
+8 −0
Original line number Original line Diff line number Diff line 
TEMPLATE = app

CONFIG += console c++17

CONFIG -= app_bundle

CONFIG -= qt



SOURCES += \

        ../debug/debug.cpp \

        main.cpp

TemplateTest/main.cpp

0 → 100644
+200 −0
Original line number Original line Diff line number Diff line 
#include "../debug/Debug.h"

#include "../Unstructured_mesh/UnstructuredMesh.h"

#include <iostream>

#include <list>

#include <map>

using namespace std;





template <typename T1, typename T2 = void>

struct has_public_member : public std::integral_constant<bool, false> {



};



template <typename T1>

struct has_public_member<T1, typename std::enable_if<

        noexcept (T1::data) || !noexcept (T1::data)>::type> : public std::integral_constant<bool, true> {



};



template <typename ResulType, typename ...ArgTypes>

struct function_ptr {

    typedef ResulType(*type)(ArgTypes...);

};





template <typename Class,typename ResulType, typename ...ArgTypes>

struct member_function_ptr {

    using type = ResulType (Class::*) (ArgTypes...);

};



template <typename Class,typename ResulType, typename ...ArgTypes>

struct member_const_function_ptr {

    using type = ResulType (Class::*) (ArgTypes...) const;

};





template <typename Class,typename MemberType>

struct member_ptr {

    typedef MemberType Class::* type;

};







struct Temp {

    double data;

    double fun(double d){return data;}

};



void testDebug() {

    double r = 42.15;

    int i = 15;

    char c = 42;

    bool b = false;

    std::list<int> list = {1,2,3};

    std::vector<std::list<int>> vec(5, list);

    std::map<std::string, size_t> m{

        {"prvni", 1},

        {"druhy", 2},

        {"treti", 3}

    };

    ConsoleLogger::writeVar(__LINE__, __FILE__, "r", r, "i", i, "c", c, "list", list, "vec", vec, "b", b, "map", m);

    ConsoleLogger::writeVar(__LINE__, __FILE__,"---", {5,4,3,2});

    DBGVAR(r, i, c, list, vec, b, m);



    Vertex<7, double> vert;

    DBGVAR(vert, vert.getCoordinates());



    DBGVAR((Detail::is_exportable<decltype(vec)>::value));



    DBGVAR((Detail::is_exportable<double>::value));



    DBGVAR(Detail::is_indexable<double>::value);



    DBGVAR(Detail::is_indexable<decltype(vec)>::value);



    DBGVAR(Detail::is_indexable<decltype(vert)>::value);



    Subelement<size_t> s({1,true});

    DBGVAR(s);



    HTMLDBGVAR(r, i, c, list, vec, b, m);



    HTMLDBGVAR(r+1, i+1, char(c+1), list, vec[0], b, m["prvni"]);

}







//The concept implementation

template<typename T>

class NeedIterator{

    static_assert (Detail::is_iterable<T>::value, "The type must be iterable");

public:

    NeedIterator(const T&){}

};



template <unsigned int ... Is>

class ClassA

 {

   public:

      ClassA (std::integer_sequence<unsigned int,Is...>)

      {DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...})); }



      static void fun (std::index_sequence<Is...>)

      {DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...})); }



 };





//template <typename ... t> class ClassB{};



template<typename  Tuple, unsigned int ... Is>

class ClassB

 {

   public:

      ClassB (const std::integer_sequence<unsigned int, Is...>, Tuple t)

      {std::tuple_element_t<0,Tuple> typ = 0;

          DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), std::get<0>(t), typ); }



 };





template <typename ... t> class ClassC{};



template<unsigned int ... Is, typename ...Types>

class ClassC<std::integer_sequence<unsigned int,Is...>, std::tuple<Types...>>

 {

   public:

      ClassC (const std::integer_sequence<unsigned int, Is...>, std::tuple<Types...>)

      {std::tuple_element_t<0,std::tuple<Types...>> typ = 0;

          DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ); }



      ClassC () {

          std::tuple_element_t<0,std::tuple<Types...>> typ = 42.15;

          std::tuple_element_t<1,std::tuple<Types...>> typ2 = 42.15;

          DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ, typ2);

      }

 };







void testTemplate() {

    ClassA n(std::make_integer_sequence<unsigned int, 3>{});

    UnstructuredMesh<3,size_t, double,6> mesh3;

    //MeshDataContainer<Vertex<3, double>, 0,1,2> centers2(mesh3,std::make_integer_sequence<unsigned int, 3>{}, Vertex<3, double>{});

    //ComputeCenters(mesh3);



    ClassA p(make_custom_integer_sequence_t<unsigned int, 10, 0, -2>{});

    std::tuple<double, char> t{};

    t={1,2};

    ClassB u(make_custom_integer_sequence_t<unsigned int, 2, 0, -2>{}, t);



    ClassC<std::integer_sequence<unsigned int, 2,0>, std::tuple<double, char>> c(make_custom_integer_sequence_t<unsigned int, 2, 0, -2>{}, std::tuple<double, char>{});

    ClassC<std::integer_sequence<unsigned int, 2,0>, std::tuple<double, char>> cc;

    ClassC<std::integer_sequence<unsigned int, 2,0>, decltype(std::make_tuple(1.0, 'a'))> ccc;



    NeedIterator valid(mesh3.getCells());

    //NeedIterator invalid(0.0);

}





template<typename T, typename VOID = void>

struct is_indexable : public integral_constant<bool, false>{};



template<typename T>

struct is_indexable<

        T,

        enable_if<

        is_same<decltype(&T::operator[]), typename member_const_function_ptr<vector<double>,const double&, size_t>::type>::value

        >



        > : public integral_constant<bool, false>{};





int main()

{



    Vertex<5, double> vert;

    vector<double> vec;

    DBGVAR(has_public_member<double>::value);

    DBGVAR(has_public_member<decltype (vert)>::value);

    DBGVAR(has_public_member<decltype(vec)>::value);

    DBGVAR(has_public_member<Temp>::value);



    Temp t;

    member_function_ptr<Temp, double, double>::type pom1 = &Temp::fun;

    member_ptr<Temp, double>::type pom = &Temp::data;

    DBGVAR(((&t)->*pom1)(0.0),pom);

    //auto op = &vector<double>::operator[];

    member_const_function_ptr<vector<double>,const double&, size_t>::type c_at = &vector<double>::at;



    member_function_ptr<vector<double>,double&, size_t>::type at = &vector<double>::at;



    member_const_function_ptr<vector<double>,const double&, size_t>::type op = &vector<double>::operator[];



    //DBGVAR(is_same<decltype(&vector<double>::operator[]), typename member_const_function_ptr<vector<double>,const double&, size_t>::type>::value);



    DBGVAR(is_indexable<const vector<double>>::value);

    cout << "Hello World!" << endl;

    return 0;

}

debug/VariableExport.h

0 → 100644
+184 −0
Original line number Original line Diff line number Diff line 
#ifndef VARIABLEEXPORT_H

#define VARIABLEEXPORT_H

#include <iostream>

#include <fstream>

#include <string>





namespace Detail {







template <typename T1, typename T2 = void>

struct __is_exportable : public std::integral_constant<bool, false> {



};



template <typename T1>

struct __is_exportable<T1, typename std::enable_if<std::is_class<

        typename std::remove_reference<decltype(std::cerr << std::declval<const T1&>())>::type

        >::value>::type> : public std::integral_constant<bool, true> {



};





template <typename T1>

struct is_exportable : public __is_exportable<T1>

{};





template <typename T1, typename T2 = void>

struct __is_iterable : public std::integral_constant<bool, false> {



};



template <typename T1>

struct __is_iterable<T1, typename std::enable_if<!std::is_same<

        decltype(std::declval<const T1&>().begin()),

        void

     >::value>::type> : public std::integral_constant<bool, true> {



};

template <typename T1>

struct is_iterable : public __is_iterable<T1>

{};





template <typename T1, typename T2 = void>

struct __is_indexable : public std::integral_constant<bool, false> {



};



template <typename T1>

struct __is_indexable<T1, typename std::enable_if<

            !std::is_same<

                decltype (std::declval<const T1&>()[0]), void

            >::value &&

            !std::is_same<

                decltype (std::declval<const T1&>().size()), void

            >::value

    >::type> : public std::integral_constant<bool, true> {



};

template <typename T1>

struct is_indexable : public __is_indexable<T1>

{};



}



struct VariableExport {





    static void _writeWar(std::ostream& ost, ...)

    {

        ost << "\"variable is not exportable\"" << std::endl;

    }





    template<typename T>

    static auto _writeWar(std::ostream& ost, const T& b)

      -> typename std::enable_if<std::is_class<

            typename std::remove_reference<decltype(ost << b)>::type>::value &&

            !std::is_same<T, bool>::value &&

            !std::is_same<T, std::string>::value &&

            !std::is_same<T, const char*>::value &&

            !std::is_same<T, const char>::value

         >::type

    {

        ost << b;

    }







    static void _writeWar(std::ostream& ost, const bool& b)

    {

        ost << (b == true ? "true" : "false");

    }



    static void _writeWar(std::ostream& ost, const std::string& str)

    {

        ost << '"' << str << '"';

    }





    static void _writeWar(std::ostream& ost, const char* str)

    {

        ost << '"' << str << '"';

    }





    static void _writeWar(std::ostream& ost, const char str)

    {

        ost << '"' << str << '"';

    }





    template<typename T1, typename T2>

    static auto _writeWar(std::ostream& ost, const std::pair<T1,T2>& b) -> void

    {

        ost << "{ ";

        _writeWar(ost, b.first);

        ost << ": ";

        _writeWar(ost, b.second);

        ost << "}";

    }



    template<typename T>

    static auto _writeWar(std::ostream& ost, const T &list)

      -> typename std::enable_if<

              Detail::is_iterable<T>::value &&

             !Detail::is_exportable<T>::value

         >::type

    {

        auto it = list.begin();

        ost << "[ ";

        while (it != list.end()){

            _writeWar(ost, *it);

            if (++it == list.end()){

                ost << " ]";

            } else {

                ost << ", ";

            }

        }

    }







    template<typename T>

    static auto _writeWar(std::ostream& ost, const T &list)

      -> typename std::enable_if<

              Detail::is_indexable<T>::value &&

             !Detail::is_iterable<T>::value &&

             !Detail::is_exportable<T>::value

         >::type

    {

        ost << "[ ";

        for (decltype (list.size())i = 0; i < list.size(); i++){

            _writeWar(ost, list[i]);

            if (i == list.size() - 1){

                ost << " ]";

            } else {

                ost << ", ";

            }

        }

    }



    template<typename T>

    static void _writeWar(std::ostream& ost, const std::initializer_list<T> &list)

    {

        auto it = list.begin();

        ost << "[ ";

        while (it != list.end()){

            _writeWar(ost, *it);

            if (++it == list.end()){

                ost << " ]";

            } else {

                ost << ", ";

            }

        }

    }



};





#endif // VARIABLEEXPORT_H