Logo ROOT  
Reference Guide
ROOT::TSequentialExecutor Class Reference

Definition at line 26 of file TSequentialExecutor.hxx.

Public Member Functions

 TSequentialExecutor ()=default
 
 TSequentialExecutor (const TSequentialExecutor &)=delete
 
template<class F , class T >
void Foreach (F func, const std::vector< T > &args)
 Execute a function over the elements of an immutable vector, dividing the execution in nChunks. More...
 
template<class F , class INTEGER >
void Foreach (F func, ROOT::TSeq< INTEGER > args)
 Execute a function over a sequence of indexes, dividing the execution in nChunks. More...
 
template<class F , class T >
void Foreach (F func, std::initializer_list< T > args)
 Execute a function over the elements of an initializer_list, dividing the execution in nChunks. More...
 
template<class F , class T >
void Foreach (F func, std::vector< T > &args)
 Execute a function over the elements of a vector, dividing the execution in nChunks. More...
 
template<class F >
void Foreach (F func, unsigned nTimes)
 Execute a function without arguments several times, dividing the execution in nChunks. More...
 
unsigned GetPoolSize () const
 Return the number of workers in the sequential executor: a single one. More...
 
TSequentialExecutoroperator= (const TSequentialExecutor &)=delete
 
- Public Member Functions inherited from ROOT::TExecutorCRTP< TSequentialExecutor >
 TExecutorCRTP ()=default
 
 TExecutorCRTP (const TExecutorCRTP &)=delete
 
auto Map (F func, const std::vector< T > &args) -> std::vector< typename std::result_of< F(T)>::type >
 Execute a function over the elements of an immutable vector. More...
 
auto Map (F func, ROOT::TSeq< INTEGER > args) -> std::vector< typename std::result_of< F(INTEGER)>::type >
 Execute a function over a sequence of indexes. More...
 
auto Map (F func, std::initializer_list< T > args) -> std::vector< typename std::result_of< F(T)>::type >
 Execute a function over the elements of an initializer_list. More...
 
auto Map (F func, std::vector< T > &args) -> std::vector< typename std::result_of< F(T)>::type >
 Execute a function over the elements of a vector. More...
 
auto Map (F func, unsigned nTimes) -> std::vector< typename std::result_of< F()>::type >
 Execute a function without arguments several times. More...
 
T * MapReduce (F func, const std::vector< T * > &args)
 Execute a function over the TObject-inheriting elements of an immutable vector (Map) and merge the objects into a single one (Reduce). More...
 
auto MapReduce (F func, const std::vector< T > &args, R redfunc) -> typename std::result_of< F(T)>::type
 Execute a function over the elements of an immutable vector (Map) and accumulate the results into a single value (Reduce). More...
 
auto MapReduce (F func, ROOT::TSeq< INTEGER > args, R redfunc) -> typename std::result_of< F(INTEGER)>::type
 Execute a function over a sequence of indexes (Map) and accumulate the results into a single value (Reduce). More...
 
auto MapReduce (F func, std::initializer_list< T > args, R redfunc) -> typename std::result_of< F(T)>::type
 Execute a function over the elements of an initializer_list (Map) and accumulate the results into a single value (Reduce). More...
 
T * MapReduce (F func, std::vector< T * > &args)
 Execute a function over the TObject-inheriting elements of a vector (Map) and merge the objects into a single one (Reduce). More...
 
auto MapReduce (F func, std::vector< T > &args, R redfunc) -> typename std::result_of< F(T)>::type
 Execute a function over the elements of a vector (Map) and accumulate the results into a single value (Reduce). More...
 
auto MapReduce (F func, unsigned nTimes, R redfunc) -> typename std::result_of< F()>::type
 Execute a function without arguments several times (Map) and accumulate the results into a single value (Reduce). More...
 
TExecutorCRTPoperator= (const TExecutorCRTP &)=delete
 
T * Reduce (const std::vector< T * > &mergeObjs)
 "Reduce" an std::vector into a single object by using the object's Merge method. More...
 
auto Reduce (const std::vector< T > &objs, R redfunc) -> decltype(redfunc(objs))
 "Reduce" an std::vector into a single object by passing a function as the second argument defining the reduction operation. More...
 

Private Member Functions

template<class F , class T , class Cond = noReferenceCond<F, T>>
auto MapImpl (F func, const std::vector< T > &args) -> std::vector< typename std::result_of< F(T)>::type >
 Execute a function over the elements of an immutable vector. More...
 
template<class F , class INTEGER , class Cond = noReferenceCond<F, INTEGER>>
auto MapImpl (F func, ROOT::TSeq< INTEGER > args) -> std::vector< typename std::result_of< F(INTEGER)>::type >
 Execute a function over a sequence of indexes. More...
 
template<class F , class T , class Cond = noReferenceCond<F, T>>
auto MapImpl (F func, std::vector< T > &args) -> std::vector< typename std::result_of< F(T)>::type >
 Execute a function over the elements of a vector in parallel Implementation of the Map method. More...
 
template<class F , class Cond = noReferenceCond<F>>
auto MapImpl (F func, unsigned nTimes) -> std::vector< typename std::result_of< F()>::type >
 Execute a function without arguments several times. More...
 

Private Attributes

friend TExecutorCRTP
 

Additional Inherited Members

- Public Types inherited from ROOT::TExecutorCRTP< TSequentialExecutor >
using noReferenceCond = typename std::enable_if<"Function can't return a reference" &&!(std::is_reference< typename std::result_of< F(T...)>::type >::value)>::type
 type definition in used in templated functions for not allowing mapping functions that return references. More...
 

#include <ROOT/TSequentialExecutor.hxx>

Inheritance diagram for ROOT::TSequentialExecutor:
[legend]

Constructor & Destructor Documentation

◆ TSequentialExecutor() [1/2]

ROOT::TSequentialExecutor::TSequentialExecutor ( )
default

◆ TSequentialExecutor() [2/2]

ROOT::TSequentialExecutor::TSequentialExecutor ( const TSequentialExecutor )
delete

Member Function Documentation

◆ Foreach() [1/5]

template<class F , class T >
void ROOT::TSequentialExecutor::Foreach ( F  func,
const std::vector< T > &  args 
)

Execute a function over the elements of an immutable vector, dividing the execution in nChunks.

Parameters
funcFunction to be executed on the elements of the immutable vector passed as second parameter.
argsImmutable vector of elements passed as an argument to func.

Definition at line 131 of file TSequentialExecutor.hxx.

◆ Foreach() [2/5]

template<class F , class INTEGER >
void ROOT::TSequentialExecutor::Foreach ( F  func,
ROOT::TSeq< INTEGER >  args 
)

Execute a function over a sequence of indexes, dividing the execution in nChunks.

Parameters
funcFunction to be executed. Must take an element of the sequence passed assecond argument as a parameter.
argsSequence of indexes to execute func on.

Definition at line 98 of file TSequentialExecutor.hxx.

◆ Foreach() [3/5]

template<class F , class T >
void ROOT::TSequentialExecutor::Foreach ( F  func,
std::initializer_list< T >  args 
)

Execute a function over the elements of an initializer_list, dividing the execution in nChunks.

Parameters
funcFunction to be executed on the elements of the initializer_list passed as second parameter.
argsinitializer_list for a vector to apply func on.

Definition at line 108 of file TSequentialExecutor.hxx.

◆ Foreach() [4/5]

template<class F , class T >
void ROOT::TSequentialExecutor::Foreach ( F  func,
std::vector< T > &  args 
)

Execute a function over the elements of a vector, dividing the execution in nChunks.

Parameters
funcFunction to be executed on the elements of the vector passed as second parameter.
argsVector of elements passed as an argument to func.

Definition at line 119 of file TSequentialExecutor.hxx.

◆ Foreach() [5/5]

template<class F >
void ROOT::TSequentialExecutor::Foreach ( F  func,
unsigned  nTimes 
)

Execute a function without arguments several times, dividing the execution in nChunks.

Parameters
funcFunction to be executed.
nTimesNumber of times function should be called.

Definition at line 88 of file TSequentialExecutor.hxx.

◆ GetPoolSize()

unsigned ROOT::TSequentialExecutor::GetPoolSize ( ) const
inline

Return the number of workers in the sequential executor: a single one.

Returns
The number of workers in the pool, one.

Definition at line 65 of file TSequentialExecutor.hxx.

◆ MapImpl() [1/4]

template<class F , class T , class Cond >
auto ROOT::TSequentialExecutor::MapImpl ( F  func,
const std::vector< T > &  args 
) -> std::vector<typename std::result_of<F(T)>::type>
private

Execute a function over the elements of an immutable vector.

Implementation of the Map method.

Parameters
funcFunction to be executed on the elements of the vector passed as second parameter.
argsVector of elements passed as an argument to func.
Returns
A vector with the results of the function calls.

Definition at line 191 of file TSequentialExecutor.hxx.

◆ MapImpl() [2/4]

template<class F , class INTEGER , class Cond >
auto ROOT::TSequentialExecutor::MapImpl ( F  func,
ROOT::TSeq< INTEGER >  args 
) -> std::vector<typename std::result_of<F(INTEGER)>::type>
private

Execute a function over a sequence of indexes.

Implementation of the Map method.

Parameters
funcFunction to be executed. Must take an element of the sequence passed assecond argument as a parameter.
argsSequence of indexes to execute func on.
Returns
A vector with the results of the function calls.

Definition at line 159 of file TSequentialExecutor.hxx.

◆ MapImpl() [3/4]

template<class F , class T , class Cond >
auto ROOT::TSequentialExecutor::MapImpl ( F  func,
std::vector< T > &  args 
) -> std::vector<typename std::result_of<F(T)>::type>
private

Execute a function over the elements of a vector in parallel Implementation of the Map method.

Parameters
funcFunction to be executed on the elements of the vector passed as second parameter.
argsVector of elements passed as an argument to func.
Returns
A vector with the results of the function calls.

Definition at line 174 of file TSequentialExecutor.hxx.

◆ MapImpl() [4/4]

template<class F , class Cond >
auto ROOT::TSequentialExecutor::MapImpl ( F  func,
unsigned  nTimes 
) -> std::vector<typename std::result_of<F()>::type>
private

Execute a function without arguments several times.

Implementation of the Map method.

Parameters
funcFunction to be executed.
nTimesNumber of times function should be called.
Returns
A vector with the results of the function calls. Functions that take arguments can be executed (with fixed arguments) by wrapping them in a lambda or with std::bind.

Definition at line 143 of file TSequentialExecutor.hxx.

◆ operator=()

TSequentialExecutor& ROOT::TSequentialExecutor::operator= ( const TSequentialExecutor )
delete

Member Data Documentation

◆ TExecutorCRTP

friend ROOT::TSequentialExecutor::TExecutorCRTP
private

Definition at line 27 of file TSequentialExecutor.hxx.


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