pipelining/factory_base.h Base class of pipelining factories More...

Classes
class	any_noncopyable

class	Args

class	bad_any_noncopyable_cast

class	bad_any_noncopyable_copy

class	call_order_exception

class	container

struct	container< T, TT... >

struct	destination_kind

class	empty_pipe_middle

class	factory

class	factory_base
	Base class of all pipelining factories. More...

class	factory_init_hook

class	internal_passive_buffer
	Internal fifo buffer. More...

class	internal_passive_reverser
	A passive reverser stored in internal memory. More...

class	join
	Joins multiple push streams into one. More...

class	no_initiator_node

class	node
	Base class of all nodes. More...

struct	node_parameters

struct	node_resource_parameters

class	node_token

class	non_authoritative_node_map

class	not_initiator_node

class	passive_buffer
	Plain old file_stream buffer. More...

class	passive_reverser
	A passive reverser stored in external memory. More...

class	passive_serialization_buffer
	Serialization stream buffer. More...

class	passive_serialization_reverser
	A passive serialization reverser stored in external memory. More...

class	passive_sorter
	Pipelined sorter with push input and pull output. More...

class	pipe_begin

class	pipe_end

class	pipe_middle

class	pipeline

struct	pull_type

class	pullpipe_begin

class	pullpipe_end

class	pullpipe_middle

struct	push_type
	Class to deduce the item_type of a node of type T. More...

class	serialization_passive_sorter
	Pipelined sorter with push input and pull output. More...

class	split
	Split one push streams into multiple. More...

class	split_factory
	Node factory for split nodes, typically used for phase boundary nodes. More...

struct	subpipeline

class	termfactory

class	tfactory

class	tfactory< R, Args< TT... >, T... >

class	virtual_chunk
	Virtual chunk that has input and output. More...

class	virtual_chunk_begin
	Virtual chunk that has no input (that is, virtual producer). More...

class	virtual_chunk_end
	Virtual chunk that has no output (that is, virtual consumer). More...

class	virtual_chunk_missing_begin

class	virtual_chunk_missing_end

class	virtual_chunk_missing_middle

class	virtual_chunk_not_ready

class	virtual_chunk_pull
	Virtual chunk that has input and output. More...

class	virtual_chunk_pull_begin
	Virtual chunk that has no output (that is, virtual consumer). More...

class	virtual_chunk_pull_end
	Virtual chunk that has no input (that is, virtual producer). More...

class	virtual_container
	Virtual base class for extra data to go with virtual chunks. More...

Typedefs
typedef pipe_middle< split_factory< bits::buffer_input_t, node, bits::buffer_output_t > >	buffer
	The buffer node inserts a phase boundary into the pipeline by writing items to disk. More...

typedef pipe_middle< factory< bits::chunker_t, size_t > >	chunker
	A pipelining node that gathers elements into a vector of some size. More...

typedef tpie::flags< stream_option >	stream_options

typedef pipe_begin< factory< bits::named_input_t, std::string > >	named_input
	Pipelining nodes that pushes the contents of the named file stream to the next node in the pipeline. More...

typedef pullpipe_middle< factory< bits::pull_peek_t > >	pull_peek
	A node that allows peeking at the next item in the pipeline. More...

typedef boost::intrusive_ptr< bits::node_set_content >	node_set

template<typename T >
using	push_type_map_identity = T

template<typename T , template< typename > typename map = push_type_map_identity>
using	pull_type_base = bits::pull_type_base_help< typename push_type< T, bits::pull_type_base_tag >::type, map >

typedef int	priority_type

typedef pipe_middle< split_factory< bits::reverser_input_t, node, bits::reverser_output_t > >	reverser
	Constructs a reverser node stored in external memory. More...

typedef pipe_middle< split_factory< bits::internal_reverser_input_t, node, bits::internal_reverser_output_t > >	internal_reverser
	Constructs a reverser node stored in internal memory. More...

typedef pipe_middle< split_factory< serialization_bits::reverser_input_t, node, serialization_bits::reverser_output_t > >	serialization_reverser
	A pipelining node that reverses serializable items and creates a phase boundary. More...

typedef pipe_middle< split_factory< serialization_bits::buffer_input_t, node, serialization_bits::buffer_output_t > >	serialization_buffer
	A pipelining node that acts as a buffer for serializable items and creates a phase boundary. More...

typedef pipe_begin< factory< bits::scanf_ints_t > >	scanf_ints
	A pipelining node that pushes the integers it reads using scanf. More...

typedef pipe_end< termfactory< bits::printf_ints_t > >	printf_ints
	A pipelining node that prints the items that are pushed to it. More...

Enumerations
enum	stream_option { STREAM_RESET =1, STREAM_CLOSE =2 }

enum	maintain_order_type { arbitrary_order = false, maintain_order = true }
	Type describing whether to maintain the order of items in parallel. More...

Functions
template<typename T >
pipe_begin< factory< bits::ami_input_t, tpie::ami::stream< T > & > >	ami_input (tpie::ami::stream< T > &input)
	Pipelining nodes that pushes the contents of the given ami::stream to the next node in the pipeline. More...

template<typename T >
pipe_begin< factory< bits::ami_input_stack_t, tpie::ami::stack< T > & > >	ami_input_stack (tpie::ami::stack< T > &input)
	Pipelining nodes that pushes the contents of the given ami::stack to the next node in the pipeline. More...

template<typename T >
pullpipe_begin< termfactory< bits::pull_input_t< T >, tpie::ami::stack< T > & > >	ami_pull_input_stack (tpie::ami::stack< T > &fs)
	A pipelining pull-node that reads items from the given ami::stack. More...

template<typename T >
pipe_end< termfactory< bits::ami_output_t< T >, tpie::ami::stream< T > & > >	ami_output (tpie::ami::stream< T > &fs)
	A pipelining node that writes the pushed items to an ami stream. More...

template<typename T >
T &	move_if_movable (typename std::remove_reference< T >::type &t, typename std::enable_if<!std::is_move_constructible< T >::value >::type *=0)

template<typename T >
T &&	move_if_movable (typename std::remove_reference< T >::type &t, typename std::enable_if< std::is_move_constructible< T >::value >::type *=0)

template<typename T >
T &	move_if_movable_rvalue (typename std::remove_reference< T >::type &t, typename std::enable_if< !std::is_move_constructible< T >::value\|\|!std::is_rvalue_reference< T >::value >::type *=0)

template<typename T >
T &&	move_if_movable_rvalue (typename std::remove_reference< T >::type &t, typename std::enable_if< std::is_move_constructible< T >::value &&std::is_rvalue_reference< T >::value >::type *=0)

template<int i, typename ... T>
bits::get_impl< i, T... >::type &	get (container< T... > &c)

template<int i, typename ... T>
const bits::get_impl< i, T... >::type &	get (const container< T... > &c)

template<typename F , typename ... T1, typename ... T2>
F	container_construct (container< T1... > &cont, T2 &&... a)

template<typename F , typename ... T1, typename ... T2>
F	container_construct_copy (container< T1... > &cont, T2 &&... a)

template<typename T >
const T &	any_cast (const any_noncopyable &a)

template<typename T >
T &	any_cast (any_noncopyable &a)

void	swap (any_noncopyable &l, any_noncopyable &r)

template<typename T >
pipe_begin< factory< bits::input_t, file_stream< T > &, stream_options > >	input (file_stream< T > &fs, stream_options options=stream_options())
	Pipelining nodes that pushes the contents of the given file stream to the next node in the pipeline. More...

template<typename T >
pullpipe_begin< termfactory< bits::pull_input_t< T >, file_stream< T > &, stream_options > >	pull_input (file_stream< T > &fs, stream_options options=stream_options())
	A pipelining pull-node that reads items from the given file_stream. More...

template<typename T >
pullpipe_begin< termfactory< bits::pull_reverse_input_t< T >, file_stream< T > &, stream_options > >	pull_reverse_input (file_stream< T > &fs, stream_options options=stream_options())
	A pipelining pull-node that reads items in reverse order from the given file_stream. More...

template<typename T >
pullpipe_begin< termfactory< bits::named_pull_input_t< T >, std::string > >	named_pull_input (std::string path)
	A pipelining pull-node that reads items from the given file path. More...

template<typename T >
pipe_end< termfactory< bits::output_t< T >, file_stream< T > & > >	output (file_stream< T > &fs)
	A pipelining node that writes the pushed items to a file stream. More...

template<typename T >
pipe_end< termfactory< bits::named_output_t< T >, std::string > >	named_output (std::string path)
	A pipelining node that writes the pushed items to a named file stream. More...

template<typename T >
pullpipe_end< factory< bits::pull_output_t, file_stream< T > & > >	pull_output (file_stream< T > &fs)
	A pull-pipe node that writes the pulled items to a file stream. More...

template<typename T >
pipe_middle< tfactory< bits::tee_t, Args< typename T::item_type >, T & > >	tee (T &fs)
	A pipelining node that writes the pushed to a file stream and then pushes the items to the next node. More...

template<typename T >
pullpipe_middle< tfactory< bits::pull_tee_t, Args< typename T::item_type >, T & > >	pull_tee (T &fs)
	A pull-pipe node that when pulled from will pull from its source, write its item to disk and then return the item. More...

template<typename F >
pipe_middle< tfactory< bits::filter_t, Args< F >, F > >	filter (const F &functor)
	A pipelining node that keeps only elements where functor evaluates to true. More...

pipe_middle< factory< bits::Forwarder, std::vector< std::pair< std::string, any_noncopyable > > > >	forwarder (std::vector< std::pair< std::string, any_noncopyable > > items)
	A pipelining node that will forward values on prepare, and. More...

template<typename VT >
pipe_middle< factory< bits::Forwarder, std::vector< std::pair< std::string, any_noncopyable > > > >	forwarder (std::string name, VT value)
	A pipelining node that will forward value on prepare, and. More...

pipe_middle< factory< bits::ostream_logger_t, std::ostream & > >	cout_logger ()
	A pipelining node that writes items to standard out and then pushes them to the next node. More...

template<typename fact_t >
pipe_middle< tfactory< bits::fork_t, Args< fact_t >, fact_t > >	fork (pipe_end< fact_t > to)
	Create a fork pipe node. More...

template<typename dest_fact_t >
pullpipe_middle< tfactory< bits::pull_fork_t, Args< dest_fact_t >, dest_fact_t > >	pull_fork (dest_fact_t dest_fact)
	Create a pulling fork pipe node. More...

template<typename fact_t >
pipe_middle< tfactory< bits::unzip_t, Args< fact_t >, fact_t > >	unzip (pipe_end< fact_t > to)
	Create unzip pipe node. More...

template<typename fact_t >
pipe_middle< tfactory< bits::zip_t, Args< fact_t >, fact_t > >	zip (pullpipe_begin< fact_t > from)
	Create a zip pipe node. More...

template<typename T >
pipe_end< termfactory< bits::null_sink_t< T > > >	null_sink ()
	Create a dummy end pipe node. More...

template<typename T >
pullpipe_begin< termfactory< bits::zero_source_t< T > > >	zero_source ()
	Create a dummy pull begin pipe node. More...

template<template< typename dest_t > class Fact, typename... T>
pipe_begin< factory< Fact, T... > >	make_pipe_begin (T... t)

template<template< typename dest_t > class Fact, typename... T>
pipe_middle< factory< Fact, T... > >	make_pipe_middle (T... t)

template<typename Fact , typename... T>
pipe_end< termfactory< Fact, T... > >	make_pipe_end (T ... t)

template<typename IT >
pullpipe_begin< termfactory< bits::pull_input_iterator_t< IT >, IT, IT > >	pull_input_iterator (IT begin, IT end)
	A pull-pipe that returns items in the range given by two iterators. More...

template<typename IT >
pipe_begin< tfactory< bits::push_input_iterator_t, Args< IT >, IT, IT > >	push_input_iterator (IT begin, IT end)
	A pipelining node that pushes the items in the range given by two iterators. More...

template<typename IT >
pipe_end< termfactory< bits::push_output_iterator_t< IT >, IT > >	push_output_iterator (IT to)
	A node that writes its given items to the destination pointed to by the given iterator. More...

template<typename Item , typename IT >
pipe_end< termfactory< bits::push_output_iterator_t< IT, Item >, IT > >	typed_push_output_iterator (IT to)
	A node that writes its given items to the destination pointed to by the given iterator. More...

template<typename IT >
pullpipe_end< tfactory< bits::pull_output_iterator_t, Args< IT >, IT > >	pull_output_iterator (IT to)
	A pull-pipe node that writes its given items to the destination pointed to by the given iterator. More...

template<typename F >
pipe_middle< tfactory< bits::preparer_t, Args< F >, F > >	preparer (const F &functor)
	Create preparer callback identity pipe node. More...

template<typename F >
pipe_middle< tfactory< bits::propagater_t, Args< F >, F > >	propagater (const F &functor)
	Create propagate callback identity pipe node. More...

template<typename T >
pipe_middle< tfactory< bits::item_type_t, Args< T > > >	item_type ()
	Create item type defining identity pipe node. More...

template<typename fact_t >
pipe_begin< tfactory< bits::pull_source_t, Args< fact_t >, fact_t > >	pull_source (pullpipe_begin< fact_t > from)
	A node that pulls items from source and push them into dest. More...

template<typename equal_t >
pipe_middle< tfactory< bits::unique_t, Args< equal_t >, equal_t > >	unique (equal_t equal)
	Filter consecutive duplicates out. More...

template<typename equal_t >
pullpipe_middle< tfactory< bits::pull_unique_t, Args< equal_t >, equal_t > >	pull_unique (equal_t equal)
	Pull version of unique. More...

template<typename F , typename = typename std::enable_if<bits::has_argument_type<F>::value>::type>
pipe_middle< tfactory< bits::map_t, Args< F >, F > >	map (const F &functor)
	Pipelining nodes that applies to given functor to items in the stream. More...

template<typename F , typename = typename std::enable_if<!bits::has_argument_type<F>::value>::type>
pipe_middle< tfactory< bits::map_temp_t, Args< F >, F > >	map (const F &functor)

template<typename F >
pipe_end< termfactory< bits::map_sink_t< F >, F > >	map_sink (const F &functor)

template<typename F >
pullpipe_middle< tfactory< bits::pull_map_t, Args< F >, F > >	pull_map (const F &functor)

template<typename pull_t >
pipe_middle< tfactory< bits::merge_t, Args< pull_t >, pull_t > >	merge (pullpipe_begin< pull_t > with)
	A node that merges a pull pipeline into a push pipeline. More...

	TPIE_DECLARE_OPERATORS_FOR_FLAGS (node::PLOT)

node_set	make_node_set ()

template<typename T >
pipe_middle< factory< bits::linear_t, T, T > >	linear (T factor, T term)
	A pipelining node that transforms the items by applying a linear function to them. More...

template<typename T >
pipe_begin< factory< bits::range_t, T, T, T > >	range (T from, T to, T increment=1)

template<typename fact_t , typename comp_t = std::less<>>
pipe_middle< tfactory< bits::ordered_merge_t, Args< fact_t, comp_t >, fact_t, comp_t > >	ordered_merge (fact_t fact, comp_t comp=std::less<>())
	A node that merges a pull pipeline into a push pipeline. More...

template<typename fact_t >
pipe_middle< parallel_bits::factory< fact_t > >	parallel (pipe_middle< fact_t > &&fact, maintain_order_type maintainOrder, size_t numJobs, size_t bufSize=2048)
	Runs a pipeline in multiple threads. More...

template<typename fact_t >
pipe_middle< parallel_bits::factory< fact_t > >	parallel (pipe_middle< fact_t > &&fact, maintain_order_type maintainOrder=arbitrary_order)
	Runs a pipeline in multiple threads, using the number of threads reported by tpie::default_worker_count. More...

template<typename fact_t >
pipe_middle< parallel_bits::factory< fact_t > >	parallel (pipe_middle< fact_t > &&fact, bool maintainOrder, size_t numJobs, size_t bufSize=2048)

template<typename fact_t >
pipe_middle< parallel_bits::factory< fact_t > >	parallel (pipe_middle< fact_t > &&fact, bool maintainOrder)

pipe_begin< serialization_bits::input_factory >	serialization_input (serialization_reader &rd)
	A pipelining node that reads items from a serialization_reader. More...

template<typename T >
pipe_end< typename serialization_bits::output_factory< T >::type >	serialization_output (serialization_writer &wr)
	A pipelining node that writes item to a serialization_writer. More...

template<typename pred_t = std::less<void>>
pipe_middle< serialization_bits::sort_factory< pred_t > >	serialization_sort (const pred_t &p=std::less< void >())
	Pipelining sorter using the given predicate. More...

template<typename store_t >
pipe_middle< bits::sort_factory< std::less< void >, store_t > >	store_sort (store_t store=store_t())
	A pipelining node that sorts large elements indirectly by using a store and std::less. More...

template<typename store_t , typename pred_t >
pipe_middle< bits::sort_factory< pred_t, store_t > >	store_sort (const pred_t &p, store_t store=store_t())
	A pipelining node that sorts large elements indirectly by using a store and the given predicate. More...

template<typename pred_t = std::less<void>, typename store_t = default_store>
pipe_middle< bits::sort_factory< pred_t, store_t > >	sort (const pred_t &p=std::less< void >(), store_t store=default_store())
	A pipelining node that sorts large elements indirectly by using a store and a given predicate. More...

template<typename T , typename A >
pipe_begin< tfactory< bits::input_vector_t, Args< T, A >, const std::vector< T, A > & > >	input_vector (const std::vector< T, A > &input)
	Pipelining nodes that pushes the contents of the given vector to the next node in the pipeline. More...

template<typename T , typename A >
pipe_begin< tfactory< bits::input_vector_t, Args< T, A >, const std::vector< T, A > & > >	input_vector (std::vector< T, A > &&input)=delete

template<typename T , typename A >
pullpipe_begin< termfactory< bits::pull_input_vector_t< T, A >, const std::vector< T, A > & > >	pull_input_vector (const std::vector< T, A > &input)
	Pipelining nodes that pushes the contents of the given vector to the next node in the pipeline. More...

template<typename T , typename A >
pullpipe_begin< termfactory< bits::pull_input_vector_t< T, A >, const std::vector< T, A > & > >	pull_input_vector (std::vector< T, A > &&input)=delete

template<typename T , typename A >
pipe_end< termfactory< bits::output_vector_t< T, A >, std::vector< T, A > & > >	output_vector (std::vector< T, A > &output)
	Pipelining node that pushes items to the given vector. More...

template<typename T , typename A >
pipe_end< termfactory< bits::output_vector_t< T, A >, std::vector< T, A > & > >	output_vector (std::vector< T, A > &&output)=delete

template<typename F >
pipe_middle< tfactory< bits::lambda_t, Args< F >, F > >	lambda (const F &f)
	Pipelining nodes that applies to given functor to items in the stream. More...

template<typename F >
pipe_middle< tfactory< bits::exclude_lambda_t, Args< F >, F > >	exclude_lambda (const F &f)
	Pipelining nodes that applies to given functor to items in the stream. More...

pipe_middle< bits::pair_factory< factory< bits::count_consecutive_t >, factory< bits::extract_first_t > > >	pipeuniq ()
	A pipelining node that removes duplicate items and create a phase boundary. More...

template<typename Input >
pipe_end< termfactory< bits::devirtualize_end_node< Input >, virtual_chunk_end< Input > > >	devirtualize (const virtual_chunk_end< Input > &out)
	Convert a virtual_chunk_end for use at the end of a normal none virtual pipeline. More...

template<typename Output >
pipe_begin< tfactory< bits::devirtualize_begin_node, Args< Output >, virtual_chunk_begin< Output > > >	devirtualize (const virtual_chunk_begin< Output > &in)
	Convert a virtual_chunk_begin for use at the beginning of a normal none virtual pipeline. More...

template<typename Input , typename Output >
pipe_middle< bits::devirtualization_factory< Input, Output > >	devirtualize (const virtual_chunk< Input, Output > &mid)
	Convert a virtual_chunk for use in the middle of a normal none virtual pipeline. More...

template<typename Input >
pullpipe_begin< termfactory< bits::devirtualize_pull_begin_node< Input >, virtual_chunk_pull_begin< Input > > >	devirtualize (const virtual_chunk_pull_begin< Input > &out)
	Convert a virtual_chunk_pull_begin for use at the beginning of a normal none virtual pull pipeline. More...

template<typename Input >
pullpipe_end< tfactory< bits::devirtualize_pull_end_node, Args< Input >, virtual_chunk_pull_end< Input > > >	devirtualize (const virtual_chunk_pull_end< Input > &in)

template<typename Input , typename Output >
pullpipe_middle< bits::devirtualization_pull_factory< Input, Output > >	devirtualize (const virtual_chunk_pull< Input, Output > &mid)

template<typename T >
pipe_middle< tfactory< bits::vfork_node, Args< T >, virtual_chunk_end< T > > >	fork_to_virtual (const virtual_chunk_end< T > &out)

template<typename T >
virtual_chunk< T >	vfork (const virtual_chunk_end< T > &out)

template<typename T >
virtual_chunk< T >	chunk_if (bool b, virtual_chunk< T > t)

template<typename T >
virtual_chunk_end< T >	chunk_end_if (bool b, virtual_chunk_end< T > t)

template<typename F >
pipe_middle< tfactory< bits::visit_t, Args< F >, F > >	visit (const F &functor)
	A pipelining node that applies a functor to elements pushed to it. More...

Variables
TPIE_EXPORT std::unordered_set< bits::pipeline_base_base * >	current_pipelines

TPIE_EXPORT std::mutex	current_pipelines_mutex

const priority_type	PRIORITY_NO_NAME = 0

const priority_type	PRIORITY_INSIGNIFICANT = 5

const priority_type	PRIORITY_SIGNIFICANT = 10

const priority_type	PRIORITY_USER = 20

Detailed Description

pipelining/factory_base.h Base class of pipelining factories

TPIE pipelining framework.

Author: Mathias Rav

Typedef Documentation

◆ buffer

typedef pipe_middle<split_factory<bits::buffer_input_t, node, bits::buffer_output_t> > tpie::pipelining::buffer

The buffer node inserts a phase boundary into the pipeline by writing items to disk.

It does not change the contents of the stream.

Definition at line 205 of file buffer.h.

◆ chunker

typedef pipe_middle<factory<bits::chunker_t, size_t> > tpie::pipelining::chunker

A pipelining node that gathers elements into a vector of some size.

Parameters

maxSize the maximum size of the vector

Definition at line 75 of file chunker.h.

◆ internal_reverser

typedef pipe_middle<split_factory<bits::internal_reverser_input_t, node, bits::internal_reverser_output_t> > tpie::pipelining::internal_reverser

Constructs a reverser node stored in internal memory.

Reverses the stream and creates a phase boundary

Definition at line 373 of file reverse.h.

◆ named_input

typedef pipe_begin<factory<bits::named_input_t, std::string> > tpie::pipelining::named_input

Pipelining nodes that pushes the contents of the named file stream to the next node in the pipeline.

Parameters

path	The file stream from which it pushes items

Definition at line 388 of file file_stream.h.

◆ printf_ints

typedef pipe_end<termfactory<bits::printf_ints_t> > tpie::pipelining::printf_ints

A pipelining node that prints the items that are pushed to it.

Definition at line 73 of file stdio.h.

◆ pull_peek

typedef pullpipe_middle<factory<bits::pull_peek_t> > tpie::pipelining::pull_peek

A node that allows peeking at the next item in the pipeline.

Definition at line 484 of file helpers.h.

◆ reverser

typedef pipe_middle<split_factory<bits::reverser_input_t, node, bits::reverser_output_t> > tpie::pipelining::reverser

Constructs a reverser node stored in external memory.

Reverses the stream and creates a phase boundary

Definition at line 367 of file reverse.h.

◆ scanf_ints

typedef pipe_begin<factory<bits::scanf_ints_t> > tpie::pipelining::scanf_ints

A pipelining node that pushes the integers it reads using scanf.

Definition at line 68 of file stdio.h.

◆ serialization_buffer

typedef pipe_middle<split_factory<serialization_bits::buffer_input_t, node, serialization_bits::buffer_output_t> > tpie::pipelining::serialization_buffer

A pipelining node that acts as a buffer for serializable items and creates a phase boundary.

Definition at line 496 of file serialization.h.

◆ serialization_reverser

typedef pipe_middle<split_factory<serialization_bits::reverser_input_t, node, serialization_bits::reverser_output_t> > tpie::pipelining::serialization_reverser

A pipelining node that reverses serializable items and creates a phase boundary.

Definition at line 490 of file serialization.h.

Enumeration Type Documentation

◆ maintain_order_type

enum tpie::pipelining::maintain_order_type

Type describing whether to maintain the order of items in parallel.

Enumerator
arbitrary_order	Do not maintain order; push items as soon as a worker has processed them.
maintain_order	Maintain order; push items in the same order that a single thread would have.

Definition at line 29 of file maintain_order_type.h.

                          {
     arbitrary_order = false,
     maintain_order = true
 };

Function Documentation

◆ ami_input()

template<typename T >

pipe_begin<factory<bits::ami_input_t, tpie::ami::stream<T> &> > tpie::pipelining::ami_input ( tpie::ami::stream< T > & input )

inline

Pipelining nodes that pushes the contents of the given ami::stream to the next node in the pipeline.

Parameters

input The ami::stream from which it pushes items

Definition at line 140 of file ami_glue.h.

                                     {
     return factory<bits::ami_input_t, tpie::ami::stream<T> &>(input);
 }

References input().

◆ ami_input_stack()

template<typename T >

pipe_begin<factory<bits::ami_input_stack_t, tpie::ami::stack<T> &> > tpie::pipelining::ami_input_stack ( tpie::ami::stack< T > & input )

inline

Pipelining nodes that pushes the contents of the given ami::stack to the next node in the pipeline.

Parameters

input The ami::stack from which it pushes items

Definition at line 151 of file ami_glue.h.

                                          {
     return factory<bits::ami_input_stack_t, tpie::ami::stack<T> &>(input);
 }

References input().

◆ ami_output()

template<typename T >

pipe_end<termfactory<bits::ami_output_t<T>, tpie::ami::stream<T> &> > tpie::pipelining::ami_output ( tpie::ami::stream< T > & fs )

inline

A pipelining node that writes the pushed items to an ami stream.

Parameters

fs	The stream that items should be written to

Definition at line 170 of file ami_glue.h.

                                                                                                          {
     return termfactory<bits::ami_output_t<T>, tpie::ami::stream<T> &>(fs);
 }

◆ ami_pull_input_stack()

template<typename T >

pullpipe_begin<termfactory<bits::pull_input_t<T>, tpie::ami::stack<T> &> > tpie::pipelining::ami_pull_input_stack ( tpie::ami::stack< T > & fs )

inline

A pipelining pull-node that reads items from the given ami::stack.

Parameters

fs	The ami::stack from which it reads items.

Definition at line 161 of file ami_glue.h.

                                            {
     return termfactory<bits::pull_input_t<T>, tpie::ami::stack<T> &>(fs);
 }

◆ cout_logger()

pipe_middle<factory<bits::ostream_logger_t, std::ostream &> > tpie::pipelining::cout_logger ( )

inline

A pipelining node that writes items to standard out and then pushes them to the next node.

Definition at line 477 of file helpers.h.

               {
     return {std::cout};
 }

◆ devirtualize() [1/4]

template<typename Input , typename Output >

pipe_middle<bits::devirtualization_factory<Input, Output> > tpie::pipelining::devirtualize ( const virtual_chunk< Input, Output > & mid )

Convert a virtual_chunk for use in the middle of a normal none virtual pipeline.

Definition at line 1292 of file virtual.h.

                                                                                                                 {
     return {mid};
 }

◆ devirtualize() [2/4]

template<typename Output >

pipe_begin<tfactory<bits::devirtualize_begin_node, Args<Output>, virtual_chunk_begin<Output> > > tpie::pipelining::devirtualize ( const virtual_chunk_begin< Output > & in )

Convert a virtual_chunk_begin for use at the beginning of a normal none virtual pipeline.

Definition at line 1284 of file virtual.h.

                                                                                                                                                   {
     return {in};
 }

◆ devirtualize() [3/4]

template<typename Input >

pipe_end<termfactory<bits::devirtualize_end_node<Input>, virtual_chunk_end<Input> > > tpie::pipelining::devirtualize ( const virtual_chunk_end< Input > & out )

Convert a virtual_chunk_end for use at the end of a normal none virtual pipeline.

Definition at line 1276 of file virtual.h.

                                                                                                                                      {
     return {out};
 }

◆ devirtualize() [4/4]

template<typename Input >

pullpipe_begin<termfactory<bits::devirtualize_pull_begin_node<Input>, virtual_chunk_pull_begin<Input> > > tpie::pipelining::devirtualize ( const virtual_chunk_pull_begin< Input > & out )

Convert a virtual_chunk_pull_begin for use at the beginning of a normal none virtual pull pipeline.

Definition at line 1300 of file virtual.h.

                                                                                                                                                                 {
     return {out};
 }

◆ exclude_lambda()

template<typename F >

pipe_middle<tfactory<bits::exclude_lambda_t, Args<F>, F> > tpie::pipelining::exclude_lambda ( const F & f )

inline

Pipelining nodes that applies to given functor to items in the stream.

The functor should have a typedef named argument_type that is the type of the argument given to the call operator. It is required that the functor returns a pair. The first item should be a boolean indicating whether the item should be pushed to the next node. The second should be the value itself.

Parameters

f	The functor that should be applied to items

Definition at line 192 of file std_glue.h.

                                                                                             {
     return {f};
 }

◆ filter()

template<typename F >

pipe_middle<tfactory<bits::filter_t, Args<F>, F> > tpie::pipelining::filter ( const F & functor )

A pipelining node that keeps only elements where functor evaluates to true.

Parameters

functor The filter to use

Definition at line 60 of file filter.h.

                                                                            {
     return {functor};
 }

◆ fork()

template<typename fact_t >

pipe_middle<tfactory<bits::fork_t, Args<fact_t>, fact_t> > tpie::pipelining::fork ( pipe_end< fact_t > to )

Create a fork pipe node.

Whenever an element e is push into the fork node, e is pushed to the destination and then to "to"

Definition at line 495 of file helpers.h.

                           {
     return {std::move(to.factory)};
 }

◆ forwarder() [1/2]

template<typename VT >

pipe_middle<factory<bits::Forwarder, std::vector<std::pair<std::string, any_noncopyable> > > > tpie::pipelining::forwarder	(	std::string	name,
		VT	value
	)

A pipelining node that will forward value on prepare, and.

Definition at line 67 of file forwarder.h.

                                                                                                                            {
     std::vector<std::pair<std::string, any_noncopyable> > v;
     v.push_back(std::make_pair(name, any_noncopyable(value)));
     return forwarder(std::move(v));
 }

References forwarder().

◆ forwarder() [2/2]

pipe_middle<factory<bits::Forwarder, std::vector<std::pair<std::string, any_noncopyable> > > > tpie::pipelining::forwarder ( std::vector< std::pair< std::string, any_noncopyable > > items )

inline

A pipelining node that will forward values on prepare, and.

Definition at line 58 of file forwarder.h.

                                                                                                                                                                {
     return factory<bits::Forwarder, std::vector<std::pair<std::string, any_noncopyable> >  >(std::move(items));
 }

Referenced by forwarder().

◆ input()

template<typename T >

pipe_begin<factory<bits::input_t, file_stream<T> &, stream_options> > tpie::pipelining::input	(	file_stream< T > &	fs,
		stream_options	options = `stream_options()`
	)

inline

Pipelining nodes that pushes the contents of the given file stream to the next node in the pipeline.

Parameters

fs	The file stream from which it pushes items
options	Stream options

Definition at line 378 of file file_stream.h.

                                                                                                                             {
     return {fs, options};
 }

Referenced by ami_input(), ami_input_stack(), tpie::pipelining::bits::input_vector_t< dest_t, T, A >::go(), input_vector(), tpie::pipelining::bits::input_vector_t< dest_t, T, A >::propagate(), tpie::pipelining::bits::pull_input_vector_t< T, A >::propagate(), and pull_input_vector().

◆ input_vector()

template<typename T , typename A >

pipe_begin<tfactory<bits::input_vector_t, Args<T, A>, const std::vector<T, A> &> > tpie::pipelining::input_vector ( const std::vector< T, A > & input )

inline

Pipelining nodes that pushes the contents of the given vector to the next node in the pipeline.

Parameters

input The vector from which it pushes items

Definition at line 142 of file std_glue.h.

                                                                                                                                   {
     return {input};
 }

References input().

◆ item_type()

template<typename T >

pipe_middle<tfactory<bits::item_type_t, Args<T> > > tpie::pipelining::item_type ( )

Create item type defining identity pipe node.

Defines the item_type to be T. Whenever an element is push, it is immidiately pushed to the destination

Definition at line 654 of file helpers.h.

                                                               {
     return {};
 }

◆ lambda()

template<typename F >

pipe_middle<tfactory<bits::lambda_t, Args<F>, F> > tpie::pipelining::lambda ( const F & f )

inline

Pipelining nodes that applies to given functor to items in the stream.

The functor should have a typedef named argument_type that is the type of the argument given to the call operator.

Parameters

f	The functor that should be applied to items

Definition at line 178 of file std_glue.h.

                                                                             {
     return {f};
 }

◆ linear()

template<typename T >

pipe_middle<factory<bits::linear_t, T, T> > tpie::pipelining::linear	(	T	factor,
		T	term
	)

inline

A pipelining node that transforms the items by applying a linear function to them.

Parameters

factor	the factor that items should be multiplied by
term	the term is added after the item is multipled by the factor

Definition at line 83 of file numeric.h.

                          {
     return factory<bits::linear_t, T, T>(factor, term);
 }

◆ map()

template<typename F , typename = typename std::enable_if<bits::has_argument_type<F>::value>::type>

pipe_middle<tfactory<bits::map_t, Args<F>, F> > tpie::pipelining::map ( const F & functor )

Pipelining nodes that applies to given functor to items in the stream.

Parameters

functor The functor that should be applied to items

Definition at line 154 of file map.h.

                                                                      {
     return {functor};
 }

◆ merge()

template<typename pull_t >

pipe_middle<tfactory<bits::merge_t, Args<pull_t>, pull_t> > tpie::pipelining::merge ( pullpipe_begin< pull_t > with )

inline

A node that merges a pull pipeline into a push pipeline.

It pulls an items for each item pushed to it.

Definition at line 65 of file merge.h.

                                    {
     return {std::move(with.factory)};
 }

◆ named_output()

template<typename T >

pipe_end<termfactory<bits::named_output_t<T>, std::string> > tpie::pipelining::named_output ( std::string path )

inline

A pipelining node that writes the pushed items to a named file stream.

Parameters

path	The path of where to write the firestream

Definition at line 439 of file file_stream.h.

                                                                                              {
     return {std::move(path)}; 
 }

◆ named_pull_input()

template<typename T >

pullpipe_begin<termfactory<bits::named_pull_input_t<T>, std::string> > tpie::pipelining::named_pull_input ( std::string path )

inline

A pipelining pull-node that reads items from the given file path.

Parameters

path	The path of the file from which it reads items.

Definition at line 420 of file file_stream.h.

                                                                                                            {
     return {std::move(path)};
 }

◆ null_sink()

template<typename T >

pipe_end<termfactory<bits::null_sink_t<T> > > tpie::pipelining::null_sink ( )

inline

Create a dummy end pipe node.

Whenever an element of type T is pushed to the null_sink it is disregarded

Definition at line 543 of file helpers.h.

543 {return {};}

◆ ordered_merge()

template<typename fact_t , typename comp_t = std::less<>>

pipe_middle<tfactory<bits::ordered_merge_t, Args<fact_t, comp_t>, fact_t, comp_t> > tpie::pipelining::ordered_merge	(	fact_t	fact,
		comp_t	comp = `std::less<>()`
	)

inline

A node that merges a pull pipeline into a push pipeline.

It pulls an items for each item pushed to it.

Definition at line 71 of file ordered_merge.h.

                                                         {
     return {std::move(fact), std::move(comp)};
 }

◆ output()

template<typename T >

pipe_end<termfactory<bits::output_t<T>, file_stream<T> &> > tpie::pipelining::output ( file_stream< T > & fs )

inline

A pipelining node that writes the pushed items to a file stream.

Parameters

fs	The file stream that items should be written to

Definition at line 430 of file file_stream.h.

                                                                                              {
     return {fs};
 }

Referenced by output_vector().

◆ output_vector()

template<typename T , typename A >

pipe_end<termfactory<bits::output_vector_t<T, A>, std::vector<T, A> &> > tpie::pipelining::output_vector ( std::vector< T, A > & output )

inline

Pipelining node that pushes items to the given vector.

Parameters

output The vector to push items to

Definition at line 165 of file std_glue.h.

                                                                                                                     {
     return {output};
 }

References output().

◆ parallel() [1/2]

template<typename fact_t >

pipe_middle<parallel_bits::factory<fact_t> > tpie::pipelining::parallel	(	pipe_middle< fact_t > &&	fact,
		maintain_order_type	maintainOrder,
		size_t	numJobs,
		size_t	bufSize = `2048`
	)

Runs a pipeline in multiple threads.

Parameters

maintainOrder	Whether to make sure that items are processed and output in the order they are input.
numJobs	The number of threads to utilize for parallel execution.
bufSize	The number of items to store in the buffer sent between threads.

Definition at line 40 of file pipes.h.

                                                                                                                 {
     parallel_bits::options opts;
     switch (maintainOrder) {
         case arbitrary_order:
             opts.maintainOrder = false;
             break;
         case maintain_order:
             opts.maintainOrder = true;
             break;
     }
     opts.numJobs = numJobs;
     opts.bufSize = bufSize;
     return pipe_middle<parallel_bits::factory<fact_t> >
         (parallel_bits::factory<fact_t>
          (std::move(fact.factory), std::move(opts)));
 }

References arbitrary_order, and maintain_order.

Referenced by parallel().

◆ parallel() [2/2]

template<typename fact_t >

pipe_middle<parallel_bits::factory<fact_t> > tpie::pipelining::parallel	(	pipe_middle< fact_t > &&	fact,
		maintain_order_type	maintainOrder = `arbitrary_order`
	)

Runs a pipeline in multiple threads, using the number of threads reported by tpie::default_worker_count.

Parameters

maintainOrder Whether to make sure that items are processed and output in the order they are input.

Definition at line 65 of file pipes.h.

                                                                                            {
     return parallel(std::move(fact), maintainOrder, default_worker_count());
 }

References tpie::default_worker_count(), and parallel().

◆ pipeuniq()

pipe_middle<bits::pair_factory<factory<bits::count_consecutive_t>, factory<bits::extract_first_t> > > tpie::pipelining::pipeuniq ( )

inline

A pipelining node that removes duplicate items and create a phase boundary.

Definition at line 100 of file uniq.h.

            {
     return bits::pair_factory<factory<bits::count_consecutive_t>, factory<bits::extract_first_t> >
         (factory<bits::count_consecutive_t>(), factory<bits::extract_first_t>());
 }

◆ preparer()

template<typename F >

pipe_middle<tfactory<bits::preparer_t, Args<F>, F> > tpie::pipelining::preparer ( const F & functor )

Create preparer callback identity pipe node.

When prepare is called on the node the functor is called Whenever an element is pushed, it is immidiately pushed to the destination

Definition at line 632 of file helpers.h.

                                                                                {
     return {functor};
 }

◆ propagater()

template<typename F >

pipe_middle<tfactory<bits::propagater_t, Args<F>, F> > tpie::pipelining::propagater ( const F & functor )

Create propagate callback identity pipe node.

When propagate is called on the node the functor is called Whenever an element is pushed, it is immediately pushed to the destination

Definition at line 643 of file helpers.h.

                                                                                    {
     return {functor};
 }

◆ pull_fork()

template<typename dest_fact_t >

pullpipe_middle<tfactory<bits::pull_fork_t, Args<dest_fact_t>, dest_fact_t> > tpie::pipelining::pull_fork ( dest_fact_t dest_fact )

Create a pulling fork pipe node.

Whenever an element e is pulled from fork node, e is first pushed into the destination

Definition at line 507 of file helpers.h.

                                  {
     return {std::move(dest_fact)};
 }

◆ pull_input()

template<typename T >

pullpipe_begin<termfactory<bits::pull_input_t<T>, file_stream<T> &, stream_options> > tpie::pipelining::pull_input	(	file_stream< T > &	fs,
		stream_options	options = `stream_options()`
	)

inline

A pipelining pull-node that reads items from the given file_stream.

Parameters

fs	The file stream from which it reads items.
options	Stream options

Definition at line 396 of file file_stream.h.

                                              {
     return {fs, options};
 }

◆ pull_input_iterator()

template<typename IT >

pullpipe_begin<termfactory<bits::pull_input_iterator_t<IT>, IT, IT> > tpie::pipelining::pull_input_iterator	(	IT	begin,
		IT	end
	)

A pull-pipe that returns items in the range given by two iterators.

Parameters

begin	The iterator pointing to the first item
end	The iterator pointing to the end of the range

Definition at line 576 of file helpers.h.

                                                                                                           {
     return {begin, end};
 }

◆ pull_input_vector()

template<typename T , typename A >

pullpipe_begin<termfactory<bits::pull_input_vector_t<T, A>, const std::vector<T, A> &> > tpie::pipelining::pull_input_vector ( const std::vector< T, A > & input )

inline

Pipelining nodes that pushes the contents of the given vector to the next node in the pipeline.

Parameters

input The vector from which it pushes items

Definition at line 154 of file std_glue.h.

                                                                                                                                              {
     return {input};
 }

References input().

◆ pull_output()

template<typename T >

pullpipe_end<factory<bits::pull_output_t, file_stream<T> &> > tpie::pipelining::pull_output ( file_stream< T > & fs )

inline

A pull-pipe node that writes the pulled items to a file stream.

Parameters

fs	The file stream that items should be written to

Definition at line 449 of file file_stream.h.

                                                                                                     {
     return {fs};
 }

◆ pull_output_iterator()

template<typename IT >

pullpipe_end<tfactory<bits::pull_output_iterator_t, Args<IT>, IT> > tpie::pipelining::pull_output_iterator ( IT to )

A pull-pipe node that writes its given items to the destination pointed to by the given iterator.

Parameters

to	An iterator pointing to the destination that items should be written to

Definition at line 621 of file helpers.h.

                                                                                               {
     return {to};
 }

◆ pull_reverse_input()

template<typename T >

pullpipe_begin<termfactory<bits::pull_reverse_input_t<T>, file_stream<T> &, stream_options> > tpie::pipelining::pull_reverse_input	(	file_stream< T > &	fs,
		stream_options	options = `stream_options()`
	)

inline

A pipelining pull-node that reads items in reverse order from the given file_stream.

Parameters

fs	The file stream from which it reads items.
options	Stream options

Definition at line 409 of file file_stream.h.

                                              {
     return {fs, options};
 }

◆ pull_source()

template<typename fact_t >

pipe_begin<tfactory<bits::pull_source_t, Args<fact_t>, fact_t> > tpie::pipelining::pull_source ( pullpipe_begin< fact_t > from )

A node that pulls items from source and push them into dest.

Parameters

from	The pull source, and the source forwards the number of items, "items"

Definition at line 665 of file helpers.h.

                                          {
     return {std::move(from.factory)};
 }

◆ pull_tee()

template<typename T >

pullpipe_middle<tfactory<bits::pull_tee_t, Args<typename T::item_type>, T &> > tpie::pipelining::pull_tee ( T & fs )

inline

A pull-pipe node that when pulled from will pull from its source, write its item to disk and then return the item.

Parameters

fs	The file stream that items should be written to

Definition at line 469 of file file_stream.h.

                                                                                                    {
     return {fs};
 }

◆ pull_unique()

template<typename equal_t >

pullpipe_middle<tfactory<bits::pull_unique_t, Args<equal_t>, equal_t> > tpie::pipelining::pull_unique ( equal_t equal )

Pull version of unique.

When items are pulled in Whenever a pulled item is same as the previous, it is dropped

Definition at line 687 of file helpers.h.

                                                                                                  {
     return {equal};
 }

◆ push_input_iterator()

template<typename IT >

pipe_begin<tfactory<bits::push_input_iterator_t, Args<IT>, IT, IT> > tpie::pipelining::push_input_iterator	(	IT	begin,
		IT	end
	)

A pipelining node that pushes the items in the range given by two iterators.

Parameters

begin	The iterator pointing to the first item
end	The iterator pointing to the end of the range

Definition at line 587 of file helpers.h.

                                                                                                          {
     return {begin, end};
 }

◆ push_output_iterator()

template<typename IT >

pipe_end<termfactory<bits::push_output_iterator_t<IT>, IT> > tpie::pipelining::push_output_iterator ( IT to )

A node that writes its given items to the destination pointed to by the given iterator.

Parameters

to	An iterator pointing to the destination that items should be written to

Definition at line 598 of file helpers.h.

                                                                                        {
     return {to};
 }

◆ serialization_input()

pipe_begin<serialization_bits::input_factory> tpie::pipelining::serialization_input ( serialization_reader & rd )

inline

A pipelining node that reads items from a serialization_reader.

Parameters

rd	The reader from which which items should be read

Definition at line 107 of file serialization.h.

                                                       {
     return pipe_begin<serialization_bits::input_factory>(&rd);
 }

◆ serialization_output()

template<typename T >

pipe_end<typename serialization_bits::output_factory<T>::type> tpie::pipelining::serialization_output ( serialization_writer & wr )

A pipelining node that writes item to a serialization_writer.

Parameters

wr	The writer to which items should be written

Definition at line 117 of file serialization.h.

                                                 {
     return typename serialization_bits::output_factory<T>::type(&wr);
 }

◆ serialization_sort()

template<typename pred_t = std::less<void>>

pipe_middle<serialization_bits::sort_factory<pred_t> > tpie::pipelining::serialization_sort ( const pred_t & p = std::less<void>() )

Pipelining sorter using the given predicate.

Definition at line 379 of file serialization_sort.h.

                                                      {
     typedef serialization_bits::sort_factory<pred_t> fact;
     return pipe_middle<fact>(fact(p)).name("Sort");
 }

References tpie::pipelining::bits::pipe_base< child_t >::name().

◆ sort()

template<typename pred_t = std::less<void>, typename store_t = default_store>

pipe_middle<bits::sort_factory<pred_t, store_t> > tpie::pipelining::sort	(	const pred_t &	p = `std::less<void>()`,
		store_t	store = `default_store()`
	)

inline

A pipelining node that sorts large elements indirectly by using a store and a given predicate.

Definition at line 452 of file sort.h.

                                                                       {
     typedef bits::sort_factory<pred_t, store_t> fact;
     return pipe_middle<fact>(fact(p, store)).name("Sort");
 }

References tpie::pipelining::bits::pipe_base< child_t >::name().

◆ store_sort() [1/2]

template<typename store_t , typename pred_t >

pipe_middle<bits::sort_factory<pred_t, store_t> > tpie::pipelining::store_sort	(	const pred_t &	p,
		store_t	store = `store_t()`
	)

inline

A pipelining node that sorts large elements indirectly by using a store and the given predicate.

Definition at line 441 of file sort.h.

                                                       {
     typedef bits::sort_factory<pred_t, store_t> fact;
     return pipe_middle<fact>(fact(p, store)).name("Sort");
 }

References tpie::pipelining::bits::pipe_base< child_t >::name().

◆ store_sort() [2/2]

template<typename store_t >

pipe_middle<bits::sort_factory<std::less<void>, store_t> > tpie::pipelining::store_sort ( store_t store = store_t() )

inline

A pipelining node that sorts large elements indirectly by using a store and std::less.

Definition at line 430 of file sort.h.

                                     {
     typedef bits::sort_factory<std::less<void>, store_t> fact;
     return pipe_middle<fact>(fact(std::less<void>(), store)).name("Sort");
 }

References tpie::pipelining::bits::pipe_base< child_t >::name().

◆ tee()

template<typename T >

pipe_middle<tfactory<bits::tee_t, Args<typename T::item_type>, T &> > tpie::pipelining::tee ( T & fs )

inline

A pipelining node that writes the pushed to a file stream and then pushes the items to the next node.

Parameters

fs	The file stream that items should be written to

Definition at line 459 of file file_stream.h.

                                                                                      {
     return {fs};
 }

◆ typed_push_output_iterator()

template<typename Item , typename IT >

pipe_end<termfactory<bits::push_output_iterator_t<IT, Item>, IT> > tpie::pipelining::typed_push_output_iterator ( IT to )

A node that writes its given items to the destination pointed to by the given iterator.

Parameters

to	An iterator pointing to the destination that items should be written to

Template Parameters

Item	The type of the pushed items

Definition at line 610 of file helpers.h.

                                                                                                    {
     return {to};
 }

◆ unique()

template<typename equal_t >

pipe_middle<tfactory<bits::unique_t, Args<equal_t>, equal_t> > tpie::pipelining::unique ( equal_t equal )

Filter consecutive duplicates out.

When items are pushed in Whenever a pushed item is same as the previous, it is dropped

Definition at line 676 of file helpers.h.

                                                                                    {
     return {equal};
 }

◆ unzip()

template<typename fact_t >

pipe_middle<tfactory<bits::unzip_t, Args<fact_t>, fact_t> > tpie::pipelining::unzip ( pipe_end< fact_t > to )

Create unzip pipe node.

Whenever a std::pair<A,B>(a,b) is pushed to the unzip node, a is pushed to its destination, and then b is pushed to "to"

Definition at line 519 of file helpers.h.

                            {
     return {std::move(to.factory)};
 }

◆ visit()

template<typename F >

pipe_middle<tfactory<bits::visit_t, Args<F>, F> > tpie::pipelining::visit ( const F & functor )

A pipelining node that applies a functor to elements pushed to it.

Parameters

functor The visitor to use

Definition at line 56 of file visit.h.

                                                                          {
     return {functor};
 }

◆ zero_source()

template<typename T >

pullpipe_begin<termfactory<bits::zero_source_t<T> > > tpie::pipelining::zero_source ( )

inline

Create a dummy pull begin pipe node.

Whenever an element of type T is pushed to the null_sink it is disregarded

Definition at line 552 of file helpers.h.

552 {return {}; }

◆ zip()

template<typename fact_t >

pipe_middle<tfactory<bits::zip_t, Args<fact_t>, fact_t> > tpie::pipelining::zip ( pullpipe_begin< fact_t > from )

Create a zip pipe node.

Whenever an element a is pushed to the zip node, an element b is pulled from the "from" node, and std::make_pair(a,b) is pushed to the destination

Definition at line 532 of file helpers.h.

                                  {
     return {std::move(from.factory)};
 }

TPIE

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ buffer

◆ chunker

◆ internal_reverser

◆ named_input

◆ printf_ints

◆ pull_peek

◆ reverser

◆ scanf_ints

◆ serialization_buffer

◆ serialization_reverser

Enumeration Type Documentation

◆ maintain_order_type

Function Documentation

◆ ami_input()

◆ ami_input_stack()

◆ ami_output()

◆ ami_pull_input_stack()

◆ cout_logger()

◆ devirtualize() [1/4]

◆ devirtualize() [2/4]

◆ devirtualize() [3/4]

◆ devirtualize() [4/4]

◆ exclude_lambda()

◆ filter()

◆ fork()

◆ forwarder() [1/2]

◆ forwarder() [2/2]

◆ input()

◆ input_vector()

◆ item_type()

◆ lambda()

◆ linear()

◆ map()

◆ merge()

◆ named_output()

◆ named_pull_input()

◆ null_sink()

◆ ordered_merge()

◆ output()

◆ output_vector()

◆ parallel() [1/2]

◆ parallel() [2/2]

◆ pipeuniq()

◆ preparer()

◆ propagater()

◆ pull_fork()

◆ pull_input()

◆ pull_input_iterator()

◆ pull_input_vector()

◆ pull_output()

◆ pull_output_iterator()

◆ pull_reverse_input()

◆ pull_source()

◆ pull_tee()

◆ pull_unique()

◆ push_input_iterator()

◆ push_output_iterator()

◆ serialization_input()

◆ serialization_output()

◆ serialization_sort()

◆ sort()

◆ store_sort() [1/2]

◆ store_sort() [2/2]

◆ tee()

◆ typed_push_output_iterator()

◆ unique()

◆ unzip()

◆ visit()

◆ zero_source()

◆ zip()