#include <agents.h>

Inheritance diagram for Concurrency::details::_AsyncOriginator< _Type >:

Public Types
typedef single_link_registry< ITarget< _Type > >	_Target_registry

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

Public Member Functions
virtual	~_AsyncOriginator ()

virtual void	unlink_target (ITarget< _Type > *_PTarget)

virtual void	unlink_targets ()
	When overridden in a derived class, unlinks all target blocks from this `ISource` block. More...

virtual message< _Type > *	accept (runtime_object_identity _MsgId, ITarget< _Type > *_PTarget)

virtual bool	reserve (runtime_object_identity _MsgId, ITarget< _Type > *_PTarget)

virtual message< _Type > *	consume (runtime_object_identity _MsgId, ITarget< _Type > *_PTarget)

virtual void	release (runtime_object_identity _MsgId, ITarget< _Type > *_PTarget)

virtual void	acquire_ref (_Inout_ ITarget< _Type > *)
	When overridden in a derived class, acquires a reference count on this `ISource` block, to prevent deletion. More...

virtual void	release_ref (_Inout_ ITarget< _Type > *)
	When overridden in a derived class, releases a reference count on this `ISource` block. More...

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

virtual void	link_target (_Inout_ ITarget< _Type > *_PTarget)=0
	When overridden in a derived class, links a target block to this `ISource` block. More...

virtual void	unlink_target (_Inout_ ITarget< _Type > *_PTarget)=0
	When overridden in a derived class, unlinks a target block from this `ISource` block, if found to be previously linked. More...

virtual message< _Type > *	accept (runtime_object_identity _MsgId, _Inout_ ITarget< _Type > *_PTarget)=0
	When overridden in a derived class, accepts a message that was offered by this `ISource` block, transferring ownership to the caller. More...

virtual bool	reserve (runtime_object_identity _MsgId, _Inout_ ITarget< _Type > *_PTarget)=0
	When overridden in a derived class, reserves a message previously offered by this `ISource` block. More...

virtual message< _Type > *	consume (runtime_object_identity _MsgId, _Inout_ ITarget< _Type > *_PTarget)=0
	When overridden in a derived class, consumes a message previously offered by this `ISource` block and successfully reserved by the target, transferring ownership to the caller. More...

virtual void	release (runtime_object_identity _MsgId, _Inout_ ITarget< _Type > *_PTarget)=0
	When overridden in a derived class, releases a previous successful message reservation. More...

Private Member Functions
	_AsyncOriginator ()

bool	_internal_send (ITarget< _Type > *_PTarget, _Type const &_Value)

virtual void	link_target (ITarget< _Type > *_PTarget)

void	_Acquire_ref ()

void	_Release_ref ()

Private Attributes
message< _Type > *	_M_pMessage

volatile long	_M_refcount

::Concurrency::details::_ReentrantPPLLock	_M_internalLock

_Target_registry	_M_connectedTargets

Friends
class	_Originator

Additional Inherited Members
Protected Member Functions inherited from Concurrency::ISource< _Type >
void	_Invoke_link_source (ITarget< _Type > *_PLinkFrom)
	Links this source to a target. More...

void	_Invoke_unlink_source (ITarget< _Type > *_PUnlinkFrom)
	Unlinks this source from a target. More...

Member Typedef Documentation

template<class _Type>

typedef single_link_registry<ITarget<_Type> > Concurrency::details::_AsyncOriginator< _Type >::_Target_registry

Constructor & Destructor Documentation

template<class _Type>

virtual Concurrency::details::_AsyncOriginator< _Type >::~_AsyncOriginator ( )

inlinevirtual

         {
             unlink_targets();
 
             delete _M_pMessage;
         }

template<class _Type>

Concurrency::details::_AsyncOriginator< _Type >::_AsyncOriginator ( )

inlineprivate

                            :
           _M_pMessage(NULL),
           _M_refcount(0)
         {
         }

Member Function Documentation

template<class _Type>

void Concurrency::details::_AsyncOriginator< _Type >::_Acquire_ref ( )

inlineprivate

         {
             _InterlockedIncrement(&_M_refcount);
         }

template<class _Type>

bool Concurrency::details::_AsyncOriginator< _Type >::_internal_send	(	ITarget< _Type > *	_PTarget,
		_Type const &	_Value
	)

inlineprivate

         {
             // Keep a refcount so that this object doesn't get deleted if
             // the target decides to unlink before we release our lock
             _Acquire_ref();
 
             message_status _Status = declined;
             message<_Type> * _Msg = new message<_Type>(_Value);
 
             {
                 // Hold the lock to ensure that the target doesn't unlink while
                 // propagation is in progress.
                 _R_lock _Lock(_M_internalLock);
 
                 // link to the target, create a message and send it
                 link_target(_PTarget);
 
                 _CONCRT_ASSERT(_M_pMessage == NULL);
                 _M_pMessage = _Msg;
 
                 _Status = _PTarget->propagate(_M_pMessage, this);
             }
 
             // If the status is anything other than postponed, unlink away
             // from the target and delete the AsyncOriginator.
             if (_Status != postponed)
             {
                 unlink_target(_PTarget);
             }
 
             // Release the reference acquired above
             _Release_ref();
 
             return (_Status == accepted);
         }

template<class _Type>

void Concurrency::details::_AsyncOriginator< _Type >::_Release_ref ( )

inlineprivate

         {
             _CONCRT_ASSERT(_M_refcount > 0);
             if (_InterlockedDecrement(&_M_refcount) == 0)
             {
                 delete this;
             }
         }

template<class _Type>

virtual message<_Type>* Concurrency::details::_AsyncOriginator< _Type >::accept	(	runtime_object_identity	_MsgId,
		ITarget< _Type > *	_PTarget
	)

inlinevirtual

         {
             if (_PTarget == NULL)
             {
                 return NULL;
             }
 
             if (!_M_connectedTargets.contains(_PTarget))
             {
                 return NULL;
             }
 
             if (_M_pMessage == NULL || _M_pMessage->msg_id() != _MsgId)
             {
                 return NULL;
             }
 
             //
             // If the IDs match, actaully transfer ownership of the message.
             //
             message<_Type> * _Result = _M_pMessage;
             _M_pMessage = NULL;
 
             return _Result;
         }

template<class _Type>

virtual void Concurrency::details::_AsyncOriginator< _Type >::acquire_ref ( _Inout_ ITarget< _Type > * _PTarget )

inlinevirtual

When overridden in a derived class, acquires a reference count on this ISource block, to prevent deletion.

Parameters

_PTarget A pointer to the target block that is calling this method.

This method is called by an ITarget object that is being linked to this source during the link_target method.

Implements Concurrency::ISource< _Type >.

         {
             _Acquire_ref();
         }

template<class _Type>

virtual message<_Type>* Concurrency::details::_AsyncOriginator< _Type >::consume	(	runtime_object_identity	_MsgId,
		ITarget< _Type > *	_PTarget
	)

inlinevirtual

         {
             if (_PTarget == NULL)
             {
                 throw std::invalid_argument("_PTarget");
             }
 
             if (!_M_connectedTargets.contains(_PTarget))
             {
                 throw bad_target();
             }
 
             if (_M_pMessage == NULL || _M_pMessage->msg_id() != _MsgId)
             {
                 return NULL;
             }
 
             // The ownership of this message has changed.  Set the internal pointer to NULL
             // so it won't be deleted in the destructor
 
             message<_Type> * _Result = _M_pMessage;
             _M_pMessage = NULL;
 
             // We are done. Unlink from the target. DO NOT TOUCH "this" pointer after unlink
             unlink_target(_PTarget);
 
             return _Result;
         }

template<class _Type>

virtual void Concurrency::details::_AsyncOriginator< _Type >::link_target ( ITarget< _Type > * _PTarget )

inlineprivatevirtual

         {
             if (_PTarget == NULL)
             {
                 throw std::invalid_argument("_PTarget");
             }
 
             // Acquire a reference that will be released by unlink_target
             _Acquire_ref();
             _M_connectedTargets.add(_PTarget);
             _Invoke_link_source(_PTarget);
 
             // There should be no pending messages to propagate at this time.
             _CONCRT_ASSERT(_M_pMessage == NULL);
 
         }

template<class _Type>

virtual void Concurrency::details::_AsyncOriginator< _Type >::release	(	runtime_object_identity	_MsgId,
		ITarget< _Type > *	_PTarget
	)

inlinevirtual

         {
             if (_PTarget == NULL)
             {
                 throw std::invalid_argument("_PTarget");
             }
 
             if (!_M_connectedTargets.contains(_PTarget))
             {
                 throw bad_target();
             }
 
             if ((_M_pMessage == NULL) || (_M_pMessage->msg_id() != _MsgId))
             {
                 throw message_not_found();
             }
 
             // We can be connected to only 1 target. Unlink from the target.
             // DO NOT TOUCH "this" pointer after unlink
             unlink_target(_PTarget);
         }

template<class _Type>

virtual void Concurrency::details::_AsyncOriginator< _Type >::release_ref ( _Inout_ ITarget< _Type > * _PTarget )

inlinevirtual

When overridden in a derived class, releases a reference count on this ISource block.

Parameters

_PTarget A pointer to the target block that is calling this method.

This method is called by an ITarget object that is being unlinked from this source. The source block is allowed to release any resources reserved for the target block.

Implements Concurrency::ISource< _Type >.

         {
             _Release_ref();
         }

template<class _Type>

virtual bool Concurrency::details::_AsyncOriginator< _Type >::reserve	(	runtime_object_identity	_MsgId,
		ITarget< _Type > *	_PTarget
	)

inlinevirtual

         {
             if (_PTarget == NULL)
             {
                 throw std::invalid_argument("_PTarget");
             }
 
             if (!_M_connectedTargets.contains(_PTarget))
             {
                 return false;
             }
 
             if (_M_pMessage == NULL || _M_pMessage->msg_id() != _MsgId)
             {
                 return false;
             }
 
             return true;
         }

template<class _Type>

virtual void Concurrency::details::_AsyncOriginator< _Type >::unlink_target ( ITarget< _Type > * _PTarget )

inlinevirtual

         {
             if (_PTarget == NULL)
             {
                 throw std::invalid_argument("_PTarget");
             }
 
             bool _Unlinked = false;
             {
                 // Hold the lock to ensure that the target doesn't unlink while
                 // propagation is in progress.
                 _R_lock _Lock(_M_internalLock);
 
                 if (_M_connectedTargets.remove(_PTarget))
                 {
                     _Invoke_unlink_source(_PTarget);
                     _Unlinked = true;
                 }
             }
 
             // Release the lock before decrementing the refcount. Otherwise, the
             // lock release could corrupt memory.
             if (_Unlinked)
             {
                 _Release_ref();
             }
         }

template<class _Type>

virtual void Concurrency::details::_AsyncOriginator< _Type >::unlink_targets ( )

inlinevirtual

When overridden in a derived class, unlinks all target blocks from this ISource block.

Implements Concurrency::ISource< _Type >.

         {
             bool _Unlinked = false;
             {
                 // Hold the lock to ensure that the target doesn't unlink while
                 // propagation is in progress.
                 _R_lock _Lock(_M_internalLock);
 
                 for (_Target_registry::iterator _Iter = _M_connectedTargets.begin();
                     *_Iter != NULL;
                     ++_Iter)
                 {
                     ITarget<_Type> * _PTarget = *_Iter;
                     if (_M_connectedTargets.remove(_PTarget))
                     {
                         _Invoke_unlink_source(_PTarget);
                         _Unlinked = true;
                     }
 
                 }
 
                 // All targets should be unlinked
                 _CONCRT_ASSERT(_M_connectedTargets.count() == 0);
             }
 
             // Release the lock before decrementing the refcount. Otherwise, the
             // lock release could corrupt memory.
             if (_Unlinked)
             {
                 _Release_ref();
             }
         }