Concurrency::single_link_registry< _Block > Class Template Reference

The single_link_registry object is a network_link_registry that manages only a single source or target block. More...

#include <agents.h>

Inheritance diagram for Concurrency::single_link_registry< _Block >:

Public Member Functions
	single_link_registry ()
	Constructs a single_link_registry object. More...
virtual	~single_link_registry ()
	Destroys the single_link_registry object. More...
virtual void	add (_EType _Link)
	Adds a link to the single_link_registry object. More...
virtual bool	remove (_EType _Link)
	Removes a link from the single_link_registry object. More...
virtual bool	contains (_EType _Link)
	Searches the single_link_registry object for a specified block. More...
virtual size_t	count ()
	Counts the number of items in the single_link_registry object. More...
virtual iterator	begin ()
	Returns an iterator to the first element in the single_link_registry object. More...

Protected Member Functions
virtual void	_Next_index (size_t &_Index)
	Skips empty slots and updates the index to the next non-empty slot. This is called by the iterator. More...
virtual _EType	_Get_element (size_t _Index) const
	Retrieves the element at the given index. If the index is out of bounds, NULL is returned. Users need to use the iterator to access the links. More...

Private Attributes
_EType	_M_connectedLink

Additional Inherited Members
Public Types inherited from Concurrency::network_link_registry< _Block >
typedef _Block	type
	A type that represents the block type stored in the network_link_registry object. More...
typedef _Block *	_EType
	A type that represents an element pointer stored in the network_link_registry object. More...
typedef _EType const &	const_reference
	A type that provides a reference to a const element stored in a network_link_registry object for reading and performing const operations. More...
typedef _EType const *	const_pointer
	A type that provides a pointer to a const element in a network_link_registry object. More...
typedef _Network_link_iterator< _Block >	iterator
	A type that provides an iterator that can read or modify any element in a network_link_registry object. More...

Detailed Description

template<class _Block>
class Concurrency::single_link_registry< _Block >

The single_link_registry object is a network_link_registry that manages only a single source or target block.

Template Parameters

_Block

The block data type being stored in the single_link_registry object.

See also

multi_link_registry Class

Constructor & Destructor Documentation

template<class _Block>

Concurrency::single_link_registry< _Block >::single_link_registry ( )

inline

Constructs a single_link_registry object.

                           : _M_connectedLink(NULL)
    {
    }

template<class _Block>

virtual Concurrency::single_link_registry< _Block >::~single_link_registry ( )

inlinevirtual

Destroys the single_link_registry object.

The method throws an invalid_operation exception if it is called before the link is removed.

    {
        // It is an error to delete link registry with links
        // still present
        if (count() != 0)
        {
            throw invalid_operation("Deleting link registry before removing all the links");
        }
    }

Member Function Documentation

template<class _Block>

virtual _EType Concurrency::single_link_registry< _Block >::_Get_element ( size_t  _Index ) const

inlineprotectedvirtual

Retrieves the element at the given index. If the index is out of bounds, NULL is returned. Users need to use the iterator to access the links.

Parameters

_Index

The index of the link to be retrieved.

Returns

The element in the registry at the index specified by the _Index parameter.

Implements Concurrency::network_link_registry< _Block >.

    {
        if (_Index == 0)
        {
            return _M_connectedLink;
        }

        return NULL;
    }

template<class _Block>

virtual void Concurrency::single_link_registry< _Block >::_Next_index ( size_t &  _Index )

inlineprotectedvirtual

Skips empty slots and updates the index to the next non-empty slot. This is called by the iterator.

Parameters

_Index

A reference to the index that is to be updated.

Implements Concurrency::network_link_registry< _Block >.

    {
        if (_M_connectedLink == NULL)
        {
            _Index++;
        }
    }

template<class _Block>

virtual void Concurrency::single_link_registry< _Block >::add ( _EType  _Link )

inlinevirtual

Adds a link to the single_link_registry object.

Parameters

_Link

A pointer to a block to be added.

The method throws an invalid_link_target exception if there is already a link in this registry.

Implements Concurrency::network_link_registry< _Block >.

    {
        if (_Link == NULL)
        {
            return;
        }

        // Only one link can be added.
        if (_M_connectedLink != NULL)
        {
            throw invalid_link_target("_Link");
        }

        _M_connectedLink = _Link;
    }

template<class _Block>

virtual iterator Concurrency::single_link_registry< _Block >::begin ( )

inlinevirtual

Returns an iterator to the first element in the single_link_registry object.

The end state is indicated by a NULL link.

Returns

An iterator addressing the first element in the single_link_registry object.

Implements Concurrency::network_link_registry< _Block >.

    {
        return (iterator(this, 0));
    }

template<class _Block>

virtual bool Concurrency::single_link_registry< _Block >::contains ( _EType  _Link )

inlinevirtual

Searches the single_link_registry object for a specified block.

Parameters

_Link

A pointer to a block that is to be searched for in the single_link_registry object.

Returns

true if the link was found, false otherwise.

Implements Concurrency::network_link_registry< _Block >.

    {
        return ((_Link != NULL) && (_M_connectedLink == _Link));
    }

template<class _Block>

virtual size_t Concurrency::single_link_registry< _Block >::count ( )

inlinevirtual

Counts the number of items in the single_link_registry object.

Returns

The number of items in the single_link_registry object.

Implements Concurrency::network_link_registry< _Block >.

    {
        return (_M_connectedLink == NULL) ? 0 : 1;
    }

template<class _Block>

virtual bool Concurrency::single_link_registry< _Block >::remove ( _EType  _Link )

inlinevirtual

Removes a link from the single_link_registry object.

Parameters

_Link

A pointer to a block to be removed, if found.

Returns

true if the link was found and removed, false otherwise.

Implements Concurrency::network_link_registry< _Block >.

    {
        if ((_Link != NULL) && (_M_connectedLink == _Link))
        {
            _M_connectedLink = NULL;
            return true;
        }

        return false;
    }

Member Data Documentation

template<class _Block>

_EType Concurrency::single_link_registry< _Block >::_M_connectedLink

private

---

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

• VS2013/inc/agents.h