oe::util::Pipeline< Request, Response > Class Template Reference

#include <OxygenEngine/util/pipeline.h>

Public Member Functions
template<class... Args>
	Pipeline (Args &&... args)
template<typename T , typename ... Args>
Pipeline &	addPipe (const std::string &name, Args &&...args)
void	init ()
void	clean ()
Response	run (const Request &request)
Response	getDefaultResponse ()
template<class... Types>
void	generateDefaultResponse (Types... args)
template<typename T >
T *	getPipeByName (const std::string &name)
void	enableStepByStepMode ()
void	disableStepByStepMode ()
bool	isStepByStepMode ()
std::pair< Response, bool >	step (const Request &request)

Protected Member Functions
void	_rebuildPipeOrder ()

Protected Attributes
std::vector< std::unique_ptr< PipeHandler > >	_pipes
Response	_default_response
std::map< std::string, PipeHandler * >	_pipes_by_name
std::optional< int32_t >	_last_step_pipe = std::nullopt

Detailed Description

template<typename Request, typename Response>
class oe::util::Pipeline< Request, Response >

Send a request through multiple handlers

Each pipe has a choice to handle the request and/or send it to sucessive stages

Can be used as a chain of responsibility or like HTTP middleware to process a request

Example usage:

Pipeline<SomeType, MyType> pipeline;
 
pipeline
  .addPipe(A)
  .addPipe(B)
  .addPipe(C)
  .addPipe(D)
  .addPipe(E)
;
 
SomeType gabuzomeu = ...;
 
MyType result = pipeline.run(gabuzomeu);

This example will run the pipeline to convert gabuzomeu to result in following order : A->B->C->D->E

Note

if the order E->D->C->B->A feels more natural for your usecase, define OE_UTIL_PIPELINE_RUN_BOTTOM_TO_TOP before including this file

Constructor & Destructor Documentation

Pipeline()

template<typename Request , typename Response >

template<class... Args>

oe::util::Pipeline< Request, Response >::Pipeline ( Args &&...  args )

inline

Create the pipeline and init the default response

Parameters

args	value constructor params

Member Function Documentation

addPipe()

template<typename Request , typename Response >

template<typename T , typename ... Args>

Pipeline & oe::util::Pipeline< Request, Response >::addPipe ( const std::string &  name, Args &&...  args  )

inline

Add a new handler in the pipeline

Parameters

name	Name of the pipe, used for getPipeByName
...	Handler constructor

clean()

template<typename Request , typename Response >

void oe::util::Pipeline< Request, Response >::clean ( )

inline

Clean pipeline handlers

Note

should be used instead custom destructors in pipe to give more control (pipes might be destroyed/copied more than once)

generateDefaultResponse()

template<typename Request , typename Response >

template<class... Types>

void oe::util::Pipeline< Request, Response >::generateDefaultResponse ( Types...  args )

inline

Change the pipeline's the default value

Parameters

args	value constructor params

init()

template<typename Request , typename Response >

void oe::util::Pipeline< Request, Response >::init ( )

inline

Init pipeline handlers

Note

should be used instead custom constructors in pipe to give more control (pipes might be constructed/copied more than once)

run()

template<typename Request , typename Response >

Response oe::util::Pipeline< Request, Response >::run ( const Request &  request )

inline

Send a Request through a pipeline to generate a Response

---

The documentation for this class was generated from the following file:

• OxygenEngine/util/pipeline.h