Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/deepgrace/monster

The Art of Template MetaProgramming (TMP) in Modern C++♦️
https://github.com/deepgrace/monster

advanced algorithm c-plus-plus concept concepts cpp20 header-only metaprogram metaprogramming modern monster range search sequence sort template template-metaprogramming tmp tuple type-traits

Last synced: 28 days ago
JSON representation

The Art of Template MetaProgramming (TMP) in Modern C++♦️

Awesome Lists containing this project

README 

        
# Monster [![LICENSE](https://img.shields.io/github/license/deepgrace/monster.svg)](https://github.com/deepgrace/monster/blob/master/LICENSE_1_0.txt) [![Documentation](https://img.shields.io/badge/documentation-master-brightgreen.svg)](https://github.com/deepgrace/monster/blob/master/Guidelines.md) [![Language](https://img.shields.io/badge/language-C%2B%2B20-blue.svg)](https://en.cppreference.com/w/cpp/compiler_support) [![Platform](https://img.shields.io/badge/platform-Linux%20%7C%20MacOS%20%7C%20Windows-lightgrey.svg)](https://github.com/deepgrace/monster) [![Gitter Chat](https://img.shields.io/badge/gitter-join%20chat-red.svg)](https://gitter.im/taotmp/monster)



> **Advanced C++ Template MetaProgramming Framework**



## Overview

```cpp

#include 

#include 



using namespace monster;



int main(int argc, char* argv[])

{

    // arrange the same elements adjacent in a sequence, keep the relative order

    using a1 = adjacent_t>;

    using a2 = adjacent_t>;



    static_assert(std::is_same_v>);

    static_assert(std::is_same_v>);



    // Boyer-Moore-Horspool (BMH) algorithm searches for occurrences of a sequence within another sequence

    using b1 = bmh_t, std::tuple>;

    using b2 = bmh_t, std::integer_sequence>;



    static_assert(std::is_same_v>);

    static_assert(std::is_same_v>);



    // Knuth–Morris–Pratt (KMP) algorithm searches for occurrences of a sequence within another sequence

    using k1 = kmp_t, std::tuple>;

    using k2 = kmp_t, std::integer_sequence>;



    static_assert(std::is_same_v>);

    static_assert(std::is_same_v>);



    // find K-th smallest element in a sequence (k == 2)

    using min1 = select_t<2, std::tuple>;

    using min2 = select_t<2, std::integer_sequence>;



    static_assert(std::is_same_v);

    static_assert(std::is_same_v>);



    // find K-th greatest element in a sequence (k == 2)

    using max1 = select_t<2, std::tuple, greater_equal_t>;

    constexpr auto max2 = select_v<2, std::integer_sequence, greater_equal_t>;



    static_assert(std::is_same_v);

    static_assert(max2 == 3);



    // returns element at specific index of a sequence

    using e1 = element_t<1, std::tuple>;

    using e2 = element_t<3, std::integer_sequence>;



    constexpr auto e3 = element_v<3, std::integer_sequence>;



    static_assert(std::is_same_v);

    static_assert(std::is_same_v);



    static_assert(e3 == 4);



    // remove duplicate elements from a sequence, keep the first appearance

    using u1 = unique_t>;

    using u2 = unique_t>;



    static_assert(std::is_same_v>);

    static_assert(std::is_same_v>);



    // swap elements at specific index of a sequence

    using s1 = swap_t<1, 3, std::tuple>;

    using s2 = swap_t<0, 2, std::integer_sequence>;



    static_assert(std::is_same_v>);

    static_assert(std::is_same_v>);



    // sort elements by value in a sequence

    using s3 = quick_sort_t>;

    using s4 = quick_sort_t>;



    static_assert(std::is_same_v>);

    static_assert(std::is_same_v>);



    // sort elements by index in a sequence

    using s5 = sort_index_t>;

    using s6 = sort_index_t>;



    static_assert(std::is_same_v>);

    static_assert(std::is_same_v>);



    // reverses the order of the elements of a sequence

    using r1 = reverse_t>;

    using r2 = reverse_t>;



    static_assert(std::is_same_v>);

    static_assert(std::is_same_v>);



    // reverses the order of the elements of a sequence recursively

    using r3 = reverse_recursive_t>, char>>;

    using r4 = reverse_recursive_t, int>>;



    static_assert(std::is_same_v, int>, int>>);

    static_assert(std::is_same_v, char>>);



    // rotates the elements in the range [begin, middle, end) of a sequence

    using r5 = rotate_t<0, 2, 5, std::tuple>;

    using r6 = rotate_t<2, 4, 7, std::integer_sequence>;



    static_assert(std::is_same_v>);

    static_assert(std::is_same_v>);



    // returns the elements in the range [begin, end) of a sequence

    using r7 = range_t<1, 5, std::tuple>;

    using r8 = range_t<2, 6, std::integer_sequence>;



    static_assert(std::is_same_v>);

    static_assert(std::is_same_v>);



    return 0;

}

```



## Introduction

Monster is a metaprogramming library, which is header-only, extensible and modern C++ oriented.  

It exhibits a form of pure type programming of compile-time algorithms, sequences and Higher-Order Metafunctions.



Monster provides a conceptual foundation and an extensive set of powerful and coherent tools, that

makes doing explict advanced Template MetaProgramming (**TMP**) in modern C++ easy and enjoyable.



## Compiler requirements

The library relies on a C++20 compiler and standard library, but nothing else is required.



More specifically, Monster requires a compiler/standard library supporting the following C++20 features (non-exhaustively):

- concepts

- lambda templates

- All the C++20 type traits from the  header



## Building

Monster is header-only. To use it just add the necessary `#include` line to your source files, like this:

```cpp

#include 

```



To build the example with cmake, `cd` to the root of the project and setup the build directory:

```bash

mkdir build

cd build

cmake ..

```



Make and install the executables:

```

make -j4

make install

```

The executables are now located at the `bin` directory of the root of the project.  

The example can also be built with the script `build.sh`, just run it, the executables will be put at the `/tmp` directory.



## Documentation

You can browse the documentation online at [Guidelines.md](Guidelines.md).  

The documentation covers everything you should need including installing the library,

a table of contents, and an extensive reference section with examples.



## Full example

Please see [Tutorial.md](Tutorial.md).



## License

Monster is licensed as [Boost Software License 1.0](LICENSE_1_0.txt).