#include <tpie/pipelining/file_stream.h>

Public Types
typedef T	item_type

enum	STATE { STATE_FRESH, STATE_IN_PREPARE, STATE_AFTER_PREPARE, STATE_IN_PROPAGATE, STATE_AFTER_PROPAGATE, STATE_IN_BEGIN, STATE_AFTER_BEGIN, STATE_IN_END, STATE_AFTER_END }

Public Member Functions
	output_t (file_stream< T > &fs)

void	push (const T &item)

memory_size_type	get_minimum_memory () const
	Get the minimum amount of memory declared by this node. More...

memory_size_type	get_maximum_memory () const
	Get the maximum amount of memory declared by this node. More...

memory_size_type	get_available_memory () const
	Get the amount of memory assigned to this node. More...

void	set_memory_fraction (double f)
	Set the memory priority of this node. More...

double	get_memory_fraction () const
	Get the memory priority of this node. More...

bits::node_map::ptr	get_node_map () const
	Get the local node map, mapping node IDs to node pointers for all the nodes reachable from this one. More...

node_token::id_t	get_id () const
	Get the internal node ID of this node (mainly for debugging purposes). More...

virtual void	prepare ()
	Called before memory assignment but after depending phases have executed and ended. More...

virtual void	propagate ()
	Propagate stream metadata. More...

virtual void	begin ()
	Begin pipeline processing phase. More...

virtual void	go ()
	For initiator nodes, execute this phase by pushing all items to be pushed. More...

virtual void	go (progress_indicator_base &)
	Deprecated go()-implementation signature. More...

virtual void	end ()
	End pipeline processing phase. More...

virtual bool	can_evacuate ()
	Overridden by nodes that have data to evacuate. More...

virtual void	evacuate ()
	Overridden by nodes that have data to evacuate. More...

priority_type	get_name_priority ()
	Get the priority of this node's name. More...

const std::string &	get_name ()
	Get this node's name. More...

void	set_name (const std::string &name, priority_type priority=PRIORITY_USER)
	Set this node's name. More...

void	set_breadcrumb (const std::string &breadcrumb)
	Used internally when a pair_factory has a name set. More...

void	add_successor (node *succ)
	Used internally to facilitate forwarding parameters to successors in the item flow graph. More...

stream_size_type	get_steps ()
	Used internally for progress indication. More...

void	set_progress_indicator (progress_indicator_base *pi)
	Used internally. Set the progress indicator to use. More...

progress_indicator_base *	get_progress_indicator ()
	Used internally. Get the progress indicator used. More...

STATE	get_state () const

void	set_state (STATE s)

void	add_forwarded_data (std::string key, boost::any value, bool explicitForward=true)
	Called by users to add forwarded data to this node and recursively to its successors. More...

bool	can_fetch (std::string key)
	Find out if there is a piece of auxiliary data forwarded with a given name. More...

boost::any	fetch_any (std::string key)
	Fetch piece of auxiliary data as boost::any (the internal representation). More...

template<typename T >
T	fetch (std::string key)
	Fetch piece of auxiliary data, expecting a given value type. More...

Protected Member Functions
void	add_push_destination (const node_token &dest)
	Called by implementers to declare a push destination. More...

void	add_push_destination (const node &dest)
	Called by implementers to declare a push destination. More...

void	add_pull_source (const node_token &dest)
	Called by implementers to declare a pull source. More...

void	add_pull_source (const node &dest)
	Called by implementers to declare a pull source. More...

void	add_pull_destination (const node_token &dest)
	Legacy alias of add_pull_source. More...

void	add_pull_destination (const node &dest)
	Legacy alias of add_pull_source. More...

void	add_dependency (const node_token &dest)
	Called by implementers to declare a node dependency, that is, a requirement that another node has end() called before the begin() of this node. More...

void	add_dependency (const node &dest)
	Called by implementers to declare a node dependency, that is, a requirement that another node has end() called before the begin() of this node. More...

void	set_minimum_memory (memory_size_type minimumMemory)
	Called by implementers to declare minimum memory requirements. More...

void	set_maximum_memory (memory_size_type maximumMemory)
	Called by implementers to declare maximum memory requirements. More...

virtual void	set_available_memory (memory_size_type availableMemory)
	Called by the memory manager to set the amount of memory assigned to this node. More...

template<typename T >
void	forward (std::string key, T value, bool explicitForward=true)
	Called by implementers to forward auxiliary data to successors. More...

void	forward_any (std::string key, boost::any value, bool explicitForward=true)
	See node::forward. More...

const node_token &	get_token ()
	Get the node_token that maps this node's ID to a pointer to this. More...

void	set_steps (stream_size_type steps)
	Called by implementers that intend to call step(). More...

void	step (stream_size_type steps=1)
	Step the progress indicator. More...

progress_indicator_base *	proxy_progress_indicator ()
	Get a non-initialized progress indicator for use with external implementations. More...

bool	can_pull () const
	For pull nodes, return true if there are more items to be pulled. More...

item_type	pull ()
	For pull nodes, pull the next item from this node. More...

void	push (const item_type &item)
	For push nodes, push the next item to this node. More...

Detailed Description

template<typename T>
class tpie::pipelining::bits::output_t< T >

file_stream output terminator.

Definition at line 111 of file file_stream.h.

Member Function Documentation

void tpie::pipelining::node::add_dependency ( const node_token & dest )

inlineprotectedinherited

Called by implementers to declare a node dependency, that is, a requirement that another node has end() called before the begin() of this node.

Definition at line 404 of file node.h.

Referenced by tpie::pipelining::node::add_dependency().

                                                         {
         bits::node_map::ptr m = token.map_union(dest);
         m->add_relation(token.id(), dest.id(), bits::depends);
     }

void tpie::pipelining::node::add_dependency ( const node & dest )

inlineprotectedinherited

Called by implementers to declare a node dependency, that is, a requirement that another node has end() called before the begin() of this node.

Definition at line 414 of file node.h.

References tpie::pipelining::node::add_dependency().

                                                   {
         add_dependency(dest.token);
     }

void tpie::pipelining::node::add_forwarded_data	(	std::string	key,
		boost::any	value,
		bool	explicitForward = `true`
	)

inlineinherited

Called by users to add forwarded data to this node and recursively to its successors.

If explicitForward is false, the data will not override data forwarded with explicitForward == true.

Definition at line 501 of file node.h.

References tpie::pipelining::node::forward_any().

                                                                                         {
         if (m_values.count(key) &&
             !explicitForward && m_values[key].second) return;
         m_values[key].first = value;
         m_values[key].second = explicitForward;
         forward_any(key, value, false);
     }

void tpie::pipelining::node::add_pull_destination ( const node_token & dest )

inlineprotectedinherited

Legacy alias of add_pull_source.

Definition at line 388 of file node.h.

References tpie::pipelining::node::add_pull_source().

                                                        {
         add_pull_source(dest);
     }

void tpie::pipelining::node::add_pull_destination ( const node & dest )

inlineprotectedinherited

Legacy alias of add_pull_source.

Definition at line 395 of file node.h.

References tpie::pipelining::node::add_pull_source().

                                                  {
         add_pull_source(dest);
     }

void tpie::pipelining::node::add_pull_source ( const node_token & dest )

inlineprotectedinherited

Called by implementers to declare a pull source.

Definition at line 370 of file node.h.

Referenced by tpie::pipelining::node::add_pull_destination(), and tpie::pipelining::node::add_pull_source().

                                                   {
         if (get_state() != STATE_FRESH) {
             throw call_order_exception("add_pull_source called too late");
         }
         bits::node_map::ptr m = token.map_union(dest);
         m->add_relation(token.id(), dest.id(), bits::pulls);
     }

void tpie::pipelining::node::add_pull_source ( const node & dest )

inlineprotectedinherited

Called by implementers to declare a pull source.

Definition at line 381 of file node.h.

References tpie::pipelining::node::add_pull_source().

                                             {
         add_pull_source(dest.token);
     }

void tpie::pipelining::node::add_push_destination ( const node_token & dest )

inlineprotectedinherited

Called by implementers to declare a push destination.

Definition at line 352 of file node.h.

Referenced by tpie::pipelining::node::add_push_destination(), and tpie::pipelining::parallel_bits::after< T >::set_consumer().

                                                               {
         bits::node_map::ptr m = token.map_union(dest);
         m->add_relation(token.id(), dest.id(), bits::pushes);
     }

void tpie::pipelining::node::add_push_destination ( const node & dest )

inlineprotectedinherited

Called by implementers to declare a push destination.

Definition at line 360 of file node.h.

References tpie::pipelining::node::add_push_destination().

                                                         {
         if (get_state() != STATE_FRESH) {
             throw call_order_exception("add_push_destination called too late");
         }
         add_push_destination(dest.token);
     }

void tpie::pipelining::node::add_successor ( node * succ )

inlineinherited

Used internally to facilitate forwarding parameters to successors in the item flow graph.

Called by node_map::send_successors.

Definition at line 258 of file node.h.

                                            {
         m_successors.push_back(succ);
     }

virtual void tpie::pipelining::node::begin ( )

inlinevirtualinherited

Begin pipeline processing phase.

The implementation may pull() from a pull destination in begin(), and it may push() to a push destination.

The pipelining framework calls begin() on the nodes in the actor graph in a reverse topological order. The framework calls node::begin() on a node after calling begin() on its pull and push destinations.

The default implementation does nothing.

Reimplemented in tpie::pipelining::parallel_bits::producer< T1, T2 >, tpie::pipelining::parallel_bits::before< T >, tpie::pipelining::parallel_bits::before< dest_t::item_type >, tpie::pipelining::serialization_bits::sort_input_t< Traits >, tpie::pipelining::serialization_bits::rev_input_t< rev_output_t< output_dest_t > >, tpie::pipelining::bits::virtrecv< Output >, tpie::pipelining::join< T >::sink_impl, tpie::pipelining::bits::buffer_input_t< T >, and tpie::pipelining::bits::ostream_logger_t< dest_t >.

Definition at line 167 of file node.h.

Referenced by tpie::pipelining::bits::ostream_logger_t< dest_t >::begin(), tpie::pipelining::bits::buffer_input_t< T >::begin(), tpie::pipelining::bits::virtrecv< Output >::begin(), tpie::pipelining::serialization_bits::sort_input_t< Traits >::begin(), and tpie::pipelining::parallel_bits::before< dest_t::item_type >::begin().

167 {

168 }

virtual bool tpie::pipelining::node::can_evacuate ( )

inlinevirtualinherited

Overridden by nodes that have data to evacuate.

Reimplemented in tpie::pipelining::bits::sort_input_t< T, pred_t >, tpie::pipelining::serialization_bits::sort_input_t< Traits >, tpie::pipelining::bits::sort_calc_t< T, pred_t >, and tpie::pipelining::serialization_bits::sort_calc_t< Traits >.

Definition at line 211 of file node.h.

                                 {
         return false;
     }

bool tpie::pipelining::node::can_fetch ( std::string key )

inlineinherited

Find out if there is a piece of auxiliary data forwarded with a given name.

Definition at line 513 of file node.h.

Referenced by tpie::pipelining::bits::sort_input_t< T, pred_t >::propagate().

                                          {
         return m_values.count(key) != 0;
     }

bool tpie::pipelining::node::can_pull ( ) const

inlineprotectedinherited

For pull nodes, return true if there are more items to be pulled.

virtual void tpie::pipelining::node::end ( )

inlinevirtualinherited

End pipeline processing phase.

The implementation may pull() from a pull destination in end(), and it may push() to a push destination.

The pipelining framework calls end() on the nodes in the pipeline graph in a topological order. The framework calls node::end() on a node before its pull and push destinations.

The default implementation does nothing, so it does not matter if the implementation calls the parent end().

Reimplemented in tpie::pipelining::parallel_bits::producer< T1, T2 >, tpie::pipelining::parallel_bits::after< T >, tpie::pipelining::bits::sort_input_t< T, pred_t >, tpie::pipelining::serialization_bits::sort_input_t< Traits >, tpie::pipelining::serialization_bits::rev_input_t< rev_output_t< output_dest_t > >, tpie::pipelining::bits::reverser_output_t< dest_t >, tpie::pipelining::bits::delayed_buffer_output_t< dest_t >, tpie::pipelining::serialization_bits::rev_output_t< dest_t >, tpie::pipelining::serialization_bits::rev_output_t< output_dest_t >, tpie::pipelining::bits::buffer_pull_output_t< T >, tpie::pipelining::bits::count_consecutive_t< dest_t >, and tpie::pipelining::bits::ostream_logger_t< dest_t >.

Definition at line 205 of file node.h.

Referenced by tpie::pipelining::bits::ostream_logger_t< dest_t >::end(), tpie::pipelining::bits::count_consecutive_t< dest_t >::end(), tpie::pipelining::serialization_bits::sort_input_t< Traits >::end(), and tpie::pipelining::bits::sort_input_t< T, pred_t >::end().

205 {

206 }

virtual void tpie::pipelining::node::evacuate ( )

inlinevirtualinherited

Overridden by nodes that have data to evacuate.

Reimplemented in tpie::pipelining::bits::sort_input_t< T, pred_t >, tpie::pipelining::serialization_bits::sort_input_t< Traits >, tpie::pipelining::bits::sort_calc_t< T, pred_t >, and tpie::pipelining::serialization_bits::sort_calc_t< Traits >.

Definition at line 218 of file node.h.

218 {

219 }

template<typename T >

T tpie::pipelining::node::fetch ( std::string key )

inlineinherited

Fetch piece of auxiliary data, expecting a given value type.

Definition at line 535 of file node.h.

                                   {
         if (m_values.count(key) == 0) {
             std::stringstream ss;
             ss << "Tried to fetch nonexistent key '" << key
                << "' of type " << typeid(T).name();
             throw invalid_argument_exception(ss.str());
         }
         try {
             return boost::any_cast<T>(m_values[key].first);
         } catch (boost::bad_any_cast m) {
             std::stringstream ss;
             ss << "Trying to fetch key '" << key << "' of type "
                << typeid(T).name() << " but forwarded data was of type "
                << m_values[key].first.type().name() << ". Message was: " << m.what();
             throw invalid_argument_exception(ss.str());
         }
     }

boost::any tpie::pipelining::node::fetch_any ( std::string key )

inlineinherited

Fetch piece of auxiliary data as boost::any (the internal representation).

Definition at line 521 of file node.h.

                                              {
         if (m_values.count(key) != 0) {
             return m_values[key].first;
         } else {
             std::stringstream ss;
             ss << "Tried to fetch nonexistent key '" << key << '\'';
             throw invalid_argument_exception(ss.str());
         }
     }

template<typename T >

void tpie::pipelining::node::forward	(	std::string	key,
		T	value,
		bool	explicitForward = `true`
	)

inlineprotectedinherited

Called by implementers to forward auxiliary data to successors.

If explicitForward is false, the data will not override data forwarded with explicitForward == true.

Definition at line 461 of file node.h.

References tpie::pipelining::node::forward_any().

                                                                       {
         forward_any(key, boost::any(value), explicitForward);
     }

void tpie::pipelining::node::forward_any	(	std::string	key,
		boost::any	value,
		bool	explicitForward = `true`
	)

inlineprotectedinherited

See node::forward.

Definition at line 468 of file node.h.

References tpie::log_debug().

Referenced by tpie::pipelining::node::add_forwarded_data(), and tpie::pipelining::node::forward().

                                                                                  {
         switch (get_state()) {
             case STATE_IN_PREPARE:
                 log_debug() << "forward in prepare" << std::endl;
                 break;
             case STATE_IN_PROPAGATE:
                 log_debug() << "forward in propagate" << std::endl;
                 break;
             case STATE_IN_BEGIN:
                 log_debug() << "forward in begin" << std::endl;
                 break;
             case STATE_AFTER_BEGIN:
                 log_debug() << "forward after begin" << std::endl;
                 break;
             case STATE_AFTER_END:
                 throw call_order_exception("forward");
             default:
                 log_debug() << "forward in unknown state " << get_state() << std::endl;
                 break;
         }
 
         for (size_t i = 0; i < m_successors.size(); ++i) {
             m_successors[i]->add_forwarded_data(key, value, explicitForward);
         }
     }

memory_size_type tpie::pipelining::node::get_available_memory ( ) const

inlineinherited

Get the amount of memory assigned to this node.

Definition at line 96 of file node.h.

                                                          {
         return m_availableMemory;
     }

node_token::id_t tpie::pipelining::node::get_id ( ) const

inlineinherited

Get the internal node ID of this node (mainly for debugging purposes).

Definition at line 127 of file node.h.

                                          {
         return token.id();
     }

memory_size_type tpie::pipelining::node::get_maximum_memory ( ) const

inlineinherited

Get the maximum amount of memory declared by this node.

Defaults to maxint when no maximum has been set.

Definition at line 89 of file node.h.

                                                        {
         return m_maximumMemory;
     }

double tpie::pipelining::node::get_memory_fraction ( ) const

inlineinherited

Get the memory priority of this node.

Definition at line 111 of file node.h.

                                               {
         return m_memoryFraction;
     }

memory_size_type tpie::pipelining::node::get_minimum_memory ( ) const

inlineinherited

Get the minimum amount of memory declared by this node.

Defaults to zero when no minimum has been set.

Definition at line 81 of file node.h.

                                                        {
         return m_minimumMemory;
     }

const std::string& tpie::pipelining::node::get_name ( )

inlineinherited

Get this node's name.

For purposes of pipeline debugging and phase naming for progress indicator breadcrumbs.

Definition at line 233 of file node.h.

                                         {
         return m_name;
     }

priority_type tpie::pipelining::node::get_name_priority ( )

inlineinherited

Get the priority of this node's name.

For purposes of pipeline debugging and phase naming for progress indicator breadcrumbs.

Definition at line 225 of file node.h.

                                              {
         return m_namePriority;
     }

bits::node_map::ptr tpie::pipelining::node::get_node_map ( ) const

inlineinherited

Get the local node map, mapping node IDs to node pointers for all the nodes reachable from this one.

Definition at line 119 of file node.h.

Referenced by tpie::pipelining::virtual_chunk_end< Input >::operator=(), tpie::pipelining::virtual_chunk< Input, Output >::operator=(), and tpie::pipelining::virtual_chunk_begin< Output >::operator=().

                                                 {
         return token.get_map();
     }

progress_indicator_base* tpie::pipelining::node::get_progress_indicator ( )

inlineinherited

Used internally. Get the progress indicator used.

Definition at line 280 of file node.h.

                                                        {
         return m_pi;
     }

stream_size_type tpie::pipelining::node::get_steps ( )

inlineinherited

Used internally for progress indication.

Get the number of times the node expects to call step() at most.

Definition at line 266 of file node.h.

                                         {
         return m_stepsTotal;
     }

const node_token& tpie::pipelining::node::get_token ( )

inlineprotectedinherited

Get the node_token that maps this node's ID to a pointer to this.

Definition at line 558 of file node.h.

                                    {
         return token;
     }

virtual void tpie::pipelining::node::go ( )

inlinevirtualinherited

For initiator nodes, execute this phase by pushing all items to be pushed.

For non-initiator nodes, the default implementation throws a not_initiator_segment exception.

Definition at line 175 of file node.h.

References tpie::log_warning().

                       {
         progress_indicator_null pi;
         go(pi);
         // if go didn't throw, it was overridden - but it shouldn't be
         log_warning() << "node subclass " << typeid(*this).name() << " uses old go() interface" << std::endl;
     }

virtual void tpie::pipelining::node::go ( progress_indicator_base & )

inlinevirtualinherited

Deprecated go()-implementation signature.

The progress indicator argument does nothing. Instead, use step() and set_steps().

Reimplemented in tpie::pipelining::passive_reverser< T >::source_t< dest_t >.

Definition at line 186 of file node.h.

References tpie::log_warning().

                                                {
         log_warning() << "node subclass " << typeid(*this).name() << " is not an initiator node" << std::endl;
         throw not_initiator_node();
     }

virtual void tpie::pipelining::node::prepare ( )

inlinevirtualinherited

Called before memory assignment but after depending phases have executed and ended.

The implementer may use fetch and forward in this phase. The implementer does not have to call the super prepare-method; its default implementation is empty.

Reimplemented in tpie::pipelining::join< T >::source_impl< dest_t >.

Definition at line 137 of file node.h.

137 {

138 }

virtual void tpie::pipelining::node::propagate ( )

inlinevirtualinherited

Propagate stream metadata.

The implementation may fetch() and forward() metadata such as number of items or the size of a single item.

The pipelining framework calls propagate() on the nodes in the item flow graph in a topological order.

The default implementation does nothing.

Definition at line 151 of file node.h.

151 {

152 }

progress_indicator_base* tpie::pipelining::node::proxy_progress_indicator ( )

inlineprotectedinherited

Get a non-initialized progress indicator for use with external implementations.

When step() is called on a proxying progress indicator, step() is called on the node according to the number of steps declared in progress_indicator_base::init() and in node::set_steps().

Definition at line 604 of file node.h.

Referenced by tpie::pipelining::serialization_bits::sort_calc_t< Traits >::go(), and tpie::pipelining::bits::sort_calc_t< T, pred_t >::go().

                                                          {
         if (m_piProxy.get() != 0) return m_piProxy.get();
         progress_indicator_base * pi = new bits::proxy_progress_indicator(*this);
         m_piProxy.reset(pi);
         return pi;
     }

item_type tpie::pipelining::node::pull ( )

inlineprotectedinherited

For pull nodes, pull the next item from this node.

void tpie::pipelining::node::push ( const item_type & item )

inlineprotectedinherited

For push nodes, push the next item to this node.

virtual void tpie::pipelining::node::set_available_memory ( memory_size_type availableMemory )

inlineprotectedvirtualinherited

Called by the memory manager to set the amount of memory assigned to this node.

Reimplemented in tpie::pipelining::bits::sort_input_t< T, pred_t >, tpie::pipelining::serialization_bits::sort_input_t< Traits >, tpie::pipelining::bits::sort_calc_t< T, pred_t >, tpie::pipelining::serialization_bits::sort_calc_t< Traits >, tpie::pipelining::bits::sort_output_t< pred_t, dest_t >, tpie::pipelining::serialization_bits::sort_output_t< Traits, dest_t >, tpie::pipelining::bits::sort_pull_output_t< T, pred_t >, tpie::pipelining::bits::sort_pull_output_t< item_type, pred_t >, and tpie::pipelining::serialization_bits::sort_pull_output_t< Traits >.

Definition at line 445 of file node.h.

                                                                         {
         m_availableMemory = availableMemory;
     }

void tpie::pipelining::node::set_breadcrumb ( const std::string & breadcrumb )

inlineinherited

Used internally when a pair_factory has a name set.

Definition at line 249 of file node.h.

                                                              {
         m_name = m_name.empty() ? breadcrumb : (breadcrumb + " | " + m_name);
     }

void tpie::pipelining::node::set_maximum_memory ( memory_size_type maximumMemory )

inlineprotectedinherited

Called by implementers to declare maximum memory requirements.

To signal that you don't want any memory, set minimum memory and the memory fraction to zero.

Definition at line 434 of file node.h.

                                                                    {
         if (get_state() != STATE_FRESH && get_state() != STATE_IN_PREPARE) {
             throw call_order_exception("set_maximum_memory");
         }
         m_maximumMemory = maximumMemory;
     }

void tpie::pipelining::node::set_memory_fraction ( double f )

inlineinherited

Set the memory priority of this node.

Memory is distributed proportionally to the priorities of the nodes in the given phase.

Definition at line 104 of file node.h.

                                               {
         m_memoryFraction = f;
     }

void tpie::pipelining::node::set_minimum_memory ( memory_size_type minimumMemory )

inlineprotectedinherited

Called by implementers to declare minimum memory requirements.

Definition at line 421 of file node.h.

                                                                    {
         if (get_state() != STATE_FRESH && get_state() != STATE_IN_PREPARE) {
             throw call_order_exception("set_minimum_memory");
         }
         m_minimumMemory = minimumMemory;
     }

void tpie::pipelining::node::set_name	(	const std::string &	name,
		priority_type	priority = `PRIORITY_USER`
	)

inlineinherited

Set this node's name.

For purposes of pipeline debugging and phase naming for progress indicator breadcrumbs.

Definition at line 241 of file node.h.

                                                                                          {
         m_name = name;
         m_namePriority = priority;
     }

void tpie::pipelining::node::set_progress_indicator ( progress_indicator_base * pi )

inlineinherited

Used internally. Set the progress indicator to use.

Definition at line 273 of file node.h.

                                                                      {
         m_pi = pi;
     }

void tpie::pipelining::node::set_steps ( stream_size_type steps )

inlineprotectedinherited

Called by implementers that intend to call step().

Parameters

steps The number of times step() is called at most.

Definition at line 566 of file node.h.

References tpie::log_error().

                                            {
         switch (get_state()) {
             case STATE_FRESH:
             case STATE_IN_PREPARE:
             case STATE_IN_PROPAGATE:
                 break;
             case STATE_IN_BEGIN:
                 log_error() << "set_steps in begin(); use set_steps in propagate() instead." << std::endl;
                 throw call_order_exception("set_steps");
             default:
                 log_error() << "set_steps in unknown state " << get_state() << std::endl;
                 throw call_order_exception("set_steps");
         }
         m_stepsTotal = m_stepsLeft = steps;
     }

void tpie::pipelining::node::step ( stream_size_type steps = 1 )

inlineprotectedinherited

Step the progress indicator.

Parameters

steps How many steps to step.

Definition at line 586 of file node.h.

References tpie::log_warning(), and tpie::progress_indicator_base::step().

Referenced by tpie::pipelining::bits::input_vector_t< dest_t >::go(), tpie::pipelining::bits::input_t< dest_t >::go(), tpie::pipelining::serialization_bits::input_t< dest_t >::go(), tpie::pipelining::serialization_bits::rev_output_t< output_dest_t >::go(), tpie::pipelining::bits::delayed_buffer_output_t< dest_t >::go(), tpie::pipelining::serialization_bits::sort_output_t< Traits, dest_t >::go(), tpie::pipelining::bits::reverser_output_t< dest_t >::go(), tpie::pipelining::bits::sort_output_t< pred_t, dest_t >::go(), and tpie::pipelining::bits::proxy_progress_indicator::refresh().

                                           {
         assert(get_state() == STATE_IN_END || get_state() == STATE_AFTER_BEGIN || get_state() == STATE_IN_END);
         if (m_stepsLeft < steps) {
             log_warning() << typeid(*this).name() << " ==== Too many steps!" << std::endl;
             m_stepsLeft = 0;
         } else {
             m_stepsLeft -= steps;
         }
         m_pi->step(steps);
     }

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

pipelining/file_stream.h

TPIE

Public Types

Public Member Functions

Protected Member Functions

Detailed Description

template<typename T> class tpie::pipelining::bits::output_t< T >

Member Function Documentation

template<typename T>
class tpie::pipelining::bits::output_t< T >