tf::DataPipe class | Taskflow QuickStart

#
template<typename Input, typename Output, typename C>
tf::DataPipe class

class to create a stage in a data-parallel pipeline

A data pipe represents a stage of a data-parallel pipeline. A data pipe can be either parallel direction or serial direction (specified by tf::PipeType) and is associated with a callable to invoke by the pipeline scheduler.

You need to use the template function, tf::make_data_pipe, to create a data pipe. The input and output types of a tf::DataPipe should be decayed types (though the library will always decay them for you using `std::decay`) to allow internal storage to work. The data will be passed by reference to your callable, at which you can take it by copy or reference.

    tf::make_data_pipe<int, std::string>(
      tf::PipeType::SERIAL,
      [](int& input) {return std::to_string(input + 100);}
    );

In addition to the data, you callable can take an additional reference of tf::Pipeflow in the second argument to probe the runtime information for a stage task, such as its line number and token number:

    tf::make_data_pipe<int, std::string>(
      tf::PipeType::SERIAL,
      [](int& input, tf::Pipeflow& pf) {
        printf("token=%lu, line=%lu\n", pf.token(), pf.line());
        return std::to_string(input + 100);
      }
    );

## Public types

using callable_t = C
  callable type of the data pipe
using input_t = Input
  input type of the data pipe
using output_t = Output
  output type of the data pipe

## Constructors, destructors, conversion operators

DataPipe() defaulted
  default constructor
DataPipe(PipeType d, callable_t&& callable)
  constructs a data pipe

## Public functions

auto type() const -> PipeType
  queries the type of the data pipe
void type(PipeType type)
  assigns a new type to the data pipe
template<typename U>
void callable(U&& callable)
  assigns a new callable to the data pipe

## Function documentation

###
template<typename Input, typename Output, typename C>
tf::DataPipe<Input, Output, C>::DataPipe(PipeType d, callable_t&& callable)

constructs a data pipe

You should use the helper function, tf::make_data_pipe, to create a DataPipe object, especially when you need tf::DataPipe to automatically deduct the lambda type.

###
template<typename Input, typename Output, typename C>
PipeType tf::DataPipe<Input, Output, C>::type() const

queries the type of the data pipe

A data pipe can be either parallel (tf::PipeType::PARALLEL) or serial (tf::PipeType::SERIAL).

###
template<typename Input, typename Output, typename C> template<typename U>
void tf::DataPipe<Input, Output, C>::callable(U&& callable)

assigns a new callable to the data pipe

Template parameters
U | callable type
Parameters
callable | a callable object constructible from the callable type of this data pipe

Assigns a new callable to the pipe using universal forwarding.

Tab / T to search, Esc to close
…

Search for symbols, directories, files, pages or modules. You can omit any prefix from the symbol or file path; adding a `:` or `/` suffix lists all members of given symbol or directory.

Use ↓ / ↑ to navigate through the list, Enter to go. Tab autocompletes common prefix, you can copy a link to the result using ⌘ L while ⌘ M produces a Markdown link.

Sorry, nothing was found.