A call messaging block is a multi-source, ordered target_block that invokes a specified function when receiving a message. More...

#include <agents.h>

Inheritance diagram for Concurrency::call< _Type, _FunctorType >:

Public Member Functions
	call (_Call_method const &_Func)
	Constructs a `call` messaging block. More...

	call (_Call_method const &_Func, filter_method const &_Filter)
	Constructs a `call` messaging block. More...

	~call ()
	Destroys the `call` messaging block. More...

Public Member Functions inherited from Concurrency::target_block< multi_link_registry< ISource< _Type > > >
	target_block ()
	Constructs a `target_block` object. More...

virtual	~target_block ()
	Destroys the `target_block` object. More...

virtual message_status	propagate (_Inout_opt_ message< _Source_type > _PMessage, _Inout_opt_ ISource< _Source_type > _PSource)
	Asynchronously passes a message from a source block to this target block. More...

virtual message_status	send (_Inout_ message< _Source_type > _PMessage, _Inout_ ISource< _Source_type > _PSource)
	Synchronously passes a message from a source block to this target block. More...

Public Member Functions inherited from Concurrency::ITarget< multi_link_registry< ISource< _Type > >::type::source_type >
virtual	~ITarget ()
	Destroys the `ITarget` object. More...

virtual message_status	propagate (_Inout_opt_ message< multi_link_registry< ISource< _Type > >::type::source_type > _PMessage, _Inout_opt_ ISource< multi_link_registry< ISource< _Type > >::type::source_type > _PSource)=0
	When overridden in a derived class, asynchronously passes a message from a source block to this target block. More...

virtual message_status	send (_Inout_ message< multi_link_registry< ISource< _Type > >::type::source_type > _PMessage, _Inout_ ISource< multi_link_registry< ISource< _Type > >::type::source_type > _PSource)=0
	When overridden in a derived class, synchronously passes a message to the target block. More...

Protected Member Functions
virtual message_status	propagate_message (_Inout_ message< _Type > _PMessage, _Inout_ ISource< _Type > _PSource)
	Asynchronously passes a message from an `ISource` block to this `call` messaging block. It is invoked by the `propagate` method, when called by a source block. More...

virtual message_status	send_message (_Inout_ message< _Type > _PMessage, _Inout_ ISource< _Type > _PSource)
	Synchronously passes a message from an `ISource` block to this `call` messaging block. It is invoked by the `send` method, when called by a source block. More...

virtual bool	supports_anonymous_source ()
	Overrides the `supports_anonymous_source` method to indicate that this block can accept messages offered to it by a source that is not linked. More...

virtual void	process_message (_Inout_ message< _Type > *_PMessage)
	Processes a message that was accepted by this `call` messaging block. More...

virtual void	process_input_messages (_Inout_ message< _Type > *_PMessage)
	Executes the call function on the input messages. More...

Protected Member Functions inherited from Concurrency::target_block< multi_link_registry< ISource< _Type > > >
virtual message_status	propagate_message (_Inout_ message< _Source_type > _PMessage, _Inout_ ISource< _Source_type > _PSource)=0
	When overridden in a derived class, this method asynchronously passes a message from an `ISource` block to this `target_block` object. It is invoked by the `propagate` method, when called by a source block. More...

virtual message_status	send_message (_Inout_ message< _Source_type > , _Inout_ ISource< _Source_type > )
	When overridden in a derived class, this method synchronously passes a message from an `ISource` block to this `target_block` object. It is invoked by the `send` method, when called by a source block. More...

virtual void	link_source (_Inout_ ISource< _Source_type > *_PSource)
	Links a specified source block to this `target_block` object. More...

virtual void	unlink_source (_Inout_ ISource< _Source_type > *_PSource)
	Unlinks a specified source block from this `target_block` object. More...

virtual void	unlink_sources ()
	Unlinks all source blocks from this `target_block` object. More...

virtual void	process_message (message< _Source_type > *)
	When overridden in a derived class, processes a message that was accepted by this `target_block` object. More...

void	register_filter (filter_method const &_Filter)
	Registers a filter method that will be invoked on every message received. More...

void	decline_incoming_messages ()
	Indicates to the block that new messages should be declined. More...

void	initialize_target (_Inout_opt_ Scheduler _PScheduler=NULL, _Inout_opt_ ScheduleGroup _PScheduleGroup=NULL)
	Initializes the base object. Specifically, the `message_processor` object needs to be initialized. More...

void	enable_batched_processing ()
	Enables batched processing for this block. More...

void	async_send (_Inout_opt_ message< _Source_type > *_PMessage)
	Asynchronously sends a message for processing. More...

void	sync_send (_Inout_opt_ message< _Source_type > *_PMessage)
	Synchronously send a message for processing. More...

void	wait_for_async_sends ()
	Waits for all asynchronous propagations to complete. More...

void	remove_sources ()
	Unlinks all sources after waiting for outstanding asynchronous send operations to complete. More...

virtual void	process_input_messages (_Inout_ message< _Source_type > *_PMessage)
	Processes messages that are received as inputs. More...

Protected Member Functions inherited from Concurrency::ITarget< multi_link_registry< ISource< _Type > >::type::source_type >
virtual void	link_source (_Inout_ ISource< multi_link_registry< ISource< _Type > >::type::source_type > *_PSource)=0
	When overridden in a derived class, links a specified source block to this `ITarget` block. More...

virtual void	unlink_source (_Inout_ ISource< multi_link_registry< ISource< _Type > >::type::source_type > *_PSource)=0
	When overridden in a derived class, unlinks a specified source block from this `ITarget` block. More...

Private Types
typedef _FunctorType	_Call_method
	The function type that this block executes upon receiving a `message`. More...

Private Member Functions
call const &	operator= (call const &)

	call (call const &)

Private Attributes
_Call_method	_M_pFunc

Additional Inherited Members
Public Types inherited from Concurrency::target_block< multi_link_registry< ISource< _Type > > >
typedef multi_link_registry< ISource< _Type > >::type::source_type	_Source_type
	The type of the payload for the incoming messages to this `target_block` object. More...

typedef source_link_manager< multi_link_registry< ISource< _Type > > >	_SourceLinkManager
	The type of the `source_link_manager` this `target_block` object. More...

typedef _SourceLinkManager::iterator	source_iterator
	The type of the iterator for the `source_link_manager` for this `target_block` object. More...

Public Types inherited from Concurrency::ITarget< multi_link_registry< ISource< _Type > >::type::source_type >
typedef multi_link_registry< ISource< _Type > >::type::source_type	type
	A type alias for _Type . More...

typedef std::tr1::function< bool(multi_link_registry< ISource< _Type > >::type::source_typeconst &)>	filter_method
	The signature of any method used by the block that returns a `bool` value to determine whether an offered message should be accepted. More...

Protected Attributes inherited from Concurrency::target_block< multi_link_registry< ISource< _Type > > >
_SourceLinkManager	_M_connectedSources
	The container for all the sources connected to this block. More...

filter_method *	_M_pFilter
	The filter function which determines whether offered messages should be accepted. More...

bool	_M_fDeclineMessages
	A `bool` that is set to indicate that all messages should be declined in preparation for deleting the block More...

_MessageProcessorType	_M_messageProcessor
	The `message_processor` for this `target_block`. More...

Detailed Description

template<class _Type, class _FunctorType = std::tr1::function<void(_Type const&)>>
class Concurrency::call< _Type, _FunctorType >

A call messaging block is a multi-source, ordered target_block that invokes a specified function when receiving a message.

Template Parameters

_Type	The payload type of the messages propagated to this block.
_FunctorType	The signature of functions that this block can accept.

For more information, see Asynchronous Message Blocks.

See also: transformer Class

Member Typedef Documentation

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

typedef _FunctorType Concurrency::call< _Type, _FunctorType >::_Call_method

private

The function type that this block executes upon receiving a message.

Constructor & Destructor Documentation

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

Concurrency::call< _Type, _FunctorType >::call ( _Call_method const & _Func )

inline

Constructs a call messaging block.

Parameters

_Func A function that will be invoked for each accepted message.

The runtime uses the default scheduler if you do not specify the _PScheduler or _PScheduleGroup parameters.

The type _Call_method is a functor with signature void (_Type const &) which is invoked by this call messaging block to process a message.

The type filter_method is a functor with signature bool (_Type const &) which is invoked by this call messaging block to determine whether or not it should accept an offered message.

See also: Scheduler Class, ScheduleGroup Class

                                     :
         _M_pFunc(_Func)
     {
         initialize_target();
         enable_batched_processing();
     }

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

Concurrency::call< _Type, _FunctorType >::call	(	_Call_method const &	_Func,
		filter_method const &	_Filter
	)

inline

Constructs a call messaging block.

Parameters

_Filter A filter function which determines whether offered messages should be accepted.

The runtime uses the default scheduler if you do not specify the _PScheduler or _PScheduleGroup parameters.

The type _Call_method is a functor with signature void (_Type const &) which is invoked by this call messaging block to process a message.

The type filter_method is a functor with signature bool (_Type const &) which is invoked by this call messaging block to determine whether or not it should accept an offered message.

See also: Scheduler Class, ScheduleGroup Class

                                       :
         _M_pFunc(_Func)
     {
         initialize_target();
         enable_batched_processing();
         register_filter(_Filter);
     }

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

Concurrency::call< _Type, _FunctorType >::~call ( )

inline

Destroys the call messaging block.

     {
         remove_sources();
     }

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

Concurrency::call< _Type, _FunctorType >::call ( call< _Type, _FunctorType > const & )

private

Member Function Documentation

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

call const& Concurrency::call< _Type, _FunctorType >::operator= ( call< _Type, _FunctorType > const & )

private

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

virtual void Concurrency::call< _Type, _FunctorType >::process_input_messages ( _Inout_ message< _Type > * _PMessage )

inlineprotectedvirtual

Executes the call function on the input messages.

     {
         // Invoke the function provided by the user
         _CONCRT_ASSERT(_PMessage != NULL);
         _M_pFunc(_PMessage->payload);
         delete _PMessage;
     }

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

virtual void Concurrency::call< _Type, _FunctorType >::process_message ( _Inout_ message< _Type > * _PMessage )

inlineprotectedvirtual

Processes a message that was accepted by this call messaging block.

Parameters

_PMessage A pointer to the message that is to be handled.

     {
         // No longer necessary with CRT110 change
     }

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

virtual message_status Concurrency::call< _Type, _FunctorType >::propagate_message	(	_Inout_ message< _Type > *	_PMessage,
		_Inout_ ISource< _Type > *	_PSource
	)

inlineprotectedvirtual

Asynchronously passes a message from an ISource block to this call messaging block. It is invoked by the propagate method, when called by a source block.

Parameters

_PMessage	A pointer to the `message` object.
_PSource	A pointer to the source block offering the message.

Returns: A message_status indication of what the target decided to do with the message.

     {
         // It is important that calls to propagate do *not* take the same lock on the
         // internal structure that is used by Consume and the LWT.  Doing so could
         // result in a deadlock with the Consume call.
 
         message_status _Result = accepted;
 
         //
         // Accept the message being propagated
         // Note: depending on the source block propagating the message
         // this may not necessarily be the same message (pMessage) first
         // passed into the function.
         //
         _PMessage = _PSource->accept(_PMessage->msg_id(), this);
 
         if (_PMessage != NULL)
         {
             async_send(_PMessage);
         }
         else
         {
             _Result = missed;
         }
 
         return _Result;
     }

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

virtual message_status Concurrency::call< _Type, _FunctorType >::send_message	(	_Inout_ message< _Type > *	_PMessage,
		_Inout_ ISource< _Type > *	_PSource
	)

inlineprotectedvirtual

Synchronously passes a message from an ISource block to this call messaging block. It is invoked by the send method, when called by a source block.

Parameters

_PMessage	A pointer to the `message` object.
_PSource	A pointer to the source block offering the message.

Returns: A message_status indication of what the target decided to do with the message.

     {
         message_status _Result = accepted;
 
         //
         // Accept the message being propagated
         // Note: depending on the source block propagating the message
         // this may not necessarily be the same message (pMessage) first
         // passed into the function.
         //
         _PMessage = _PSource->accept(_PMessage->msg_id(), this);
 
         if (_PMessage != NULL)
         {
             sync_send(_PMessage);
         }
         else
         {
             _Result = missed;
         }
 
         return _Result;
     }

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

virtual bool Concurrency::call< _Type, _FunctorType >::supports_anonymous_source ( )

inlineprotectedvirtual

Overrides the supports_anonymous_source method to indicate that this block can accept messages offered to it by a source that is not linked.

Returns: true because the block does not postpone offered messages.

Reimplemented from Concurrency::ITarget< multi_link_registry< ISource< _Type > >::type::source_type >.

     {
         return true;
     }

Member Data Documentation

template<class _Type , class _FunctorType = std::tr1::function<void(_Type const&)>>

_Call_method Concurrency::call< _Type, _FunctorType >::_M_pFunc

private

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

VS2013/inc/agents.h

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<class _Type, class _FunctorType = std::tr1::function<void(_Type const&)>> class Concurrency::call< _Type, _FunctorType >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class _Type, class _FunctorType = std::tr1::function<void(_Type const&)>>
class Concurrency::call< _Type, _FunctorType >