Awesome

Pipet

Pipet is a lightweight c++17 headers-only library than can be used to build simple processing pipelines at compile time.

Features

Compile-time pipeline building from a set of user-defined filters
Compile-time or runtime pipeline execution
Creation of reversible pipelines (if all filters in the pipeline are reversible)
Creation of branches (handling of multiple input filters)

Supported Platforms

Tests have been performed on the following platforms:

g++-7 on linux (ci)
clang++-7 (ci)

Install

Clone project

    > git clone https://github.com/kenavolic/pipet.git

Generate build system

    > mkdir pipet_build
    > cd pipet_build
    > cmake -DCMAKE_INSTALL_PREFIX=$path_to_pipet_install_dir -DPIPET_BUILD_EXAMPLES=[ON|OFF] -DPIPET_BUILD_TESTS=[ON|OFF] ../pipet

Compilation

    > make
    > make install

+ /!\ On windows, open generated solution and build solution and install target

Usage

Examples

The projet include the following examples:

AES ciphering at compile time
String obfuscation at compile time
Mask generation at compile time

Import pipet to your project

In your CMakeLists.txt, import pipet

    find_package(pipet REQUIRED)
    ...
    target_link_libraries(my_proj pipet::pipet)

Configure your project to find pipet package

    > cmake -DCMAKE_PREFIX_PATH=$path_to_pipet_install_dir/cmake $path_to_your_proj_source_dir

Implement a pipeline

The example directory provide two examples of pipet usage. Basically, all you need to do is:

Create your filters with a static process and optionnaly static reverse function

    struct filter
    {
        static constexpr out_type process(in_type my_param)
        {
            // do processing
            return my_result;
        }
        
        static constexpr in_type reverse(out_type my_param)
        {
            // do processing
            return my_result;
        }
    };

Build your pipeline

    using my_processing_pipe = pipet::pipe<filter1, filter2, filter3>;

Run it

    constexpr auto res = my_processing_pipe::process(); // if filter 1 is a data generator (no input type)
    constexpr auto res = my_processing_pipe::process(var); // if filter 1 is processing filter

Create branches

  struct f1_proc_ct {
    static constexpr auto process(int a) { return a; }
  };

  // compute a*a
  struct f_square_ct {
    static constexpr auto process(int a) { return a * a; }
  };

  // compute a*a*a
  struct f_cube_ct {
    static constexpr auto process(int a) { return a * a * a; }
  };

  // add 3 different inputs
  struct f_add3_ct {
    static constexpr auto process(int a, int b, int c) { return a + b + c; }
  };

  using branch1_t = pipet::pipe<f1_proc_ct, f_square_ct>;
  using branch2_t = pipet::pipe<f_cube_ct, f1_proc_ct>;

  // y = x*x + x*x + x*x*x
  using pipe_with_branches_t =
      pipet::pipe<f1_proc_ct, pipet::branches<branch1_t, branch1_t, branch2_t>,
                  f_add3_ct>;
  
  static_assert(pipe_with_branches_t::process(2) == 16,
                "[-][pipet_test] pipe processing failed");

Create branches with a direct connection

  ... (see previous sample)

  // y = x + x*x + x*x*x
  using pipe_with_direct_branches_t = pipet::pipe<
      f1_proc_ct,
      pipet::branches<pipet::placeholders::self, branch1_t, branch2_t>,
      f_add3_ct>;
  static_assert(pipe_with_direct_branches_t::process(2) == 14,
                "[-][pipet_test] pipe processing failed");