Concurrency::multi_link_registry< _Block > Class Template Reference

The multi_link_registry object is a network_link_registry that manages multiple source blocks or multiple target blocks. More...

#include <agents.h>

Inheritance diagram for Concurrency::multi_link_registry< _Block >:

Public Member Functions
	multi_link_registry ()
	Constructs a multi_link_registry object. More...
virtual	~multi_link_registry ()
	Destroys the multi_link_registry object. More...
void	set_bound (size_t _MaxLinks)
	Sets an upper bound on the number of links that the multi_link_registry object can hold. More...
virtual void	add (_EType _Link)
	Adds a link to the multi_link_registry object. More...
virtual bool	remove (_EType _Link)
	Removes a link from the multi_link_registry object. More...
virtual bool	contains (_EType _Link)
	Searches the multi_link_registry object for a specified block. More...
virtual size_t	count ()
	Counts the number of items in the multi_link_registry object. More...
virtual iterator	begin ()
	Returns an iterator to the first element in the multi_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 Member Functions
void	_Add (_EType _Link)
	Adds a link to the multi_link_registry object. More...
bool	_Remove (_EType _Link)
	Removes a link from the multi_link_registry More...
virtual size_t	_Find (_EType _Link)
	Searches the registry for the given link More...
size_t	_Count () const
	Returns the count of items in the registry. More...

Private Attributes
size_t	_M_maxLinks
::Concurrency::details::_Dynamic_array< _EType >	_M_vector

Static Private Attributes
static const size_t	_NOT_SET = SIZE_MAX

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::multi_link_registry< _Block >

The multi_link_registry object is a network_link_registry that manages multiple source blocks or multiple target blocks.

Template Parameters

_Block

The block data type being stored in the multi_link_registry object.

See also

single_link_registry Class

Constructor & Destructor Documentation

template<class _Block>

Concurrency::multi_link_registry< _Block >::multi_link_registry ( )

inline

Constructs a multi_link_registry object.

                          : _M_maxLinks(_NOT_SET)
    {
    }

template<class _Block>

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

inlinevirtual

Destroys the multi_link_registry object.

The method throws an invalid_operation exception if called before all links are 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>

void Concurrency::multi_link_registry< _Block >::_Add ( _EType  _Link )

inlineprivate

Adds a link to the multi_link_registry object.

Parameters

_Link

A pointer to a block to be added.

    {
        size_t _Size = _M_vector._Size();
        size_t _Insert_pos = 0;

        _CONCRT_ASSERT(_Link != NULL);

        // If max links is set, ensure that inserting the new
        // link will not exceed the bound.
        if ((_M_maxLinks != _NOT_SET) && ((_Size+1) > (size_t) _M_maxLinks))
        {
            throw invalid_link_target("_Link");
        }

        for (size_t _Index = 0; _Index < _Size; _Index++)
        {
            if (_M_vector[_Index] != NULL)
            {
                // We want to find the first NULL entry after all the
                // non-NULL entries.
                _Insert_pos = _Index + 1;

                // Throw if dupiclate entry is found
                if (_M_vector[_Index] == _Link)
                {
                    throw invalid_link_target("_Link");
                }
            }
        }

        if (_Insert_pos < _Size)
        {
            _M_vector[_Insert_pos] = _Link;
        }
        else
        {
            _M_vector._Push_back(_Link);
        }
    }

template<class _Block>

size_t Concurrency::multi_link_registry< _Block >::_Count ( ) const

inlineprivate

Returns the count of items in the registry.

Returns

The count of items in the registry.

    {
        size_t _Count = 0;

        for (size_t _Index = 0; _Index < _M_vector._Size(); _Index++)
        {
            if (_M_vector[_Index] != NULL)
            {
                _Count++;
            }
        }

        return _Count;
    }

template<class _Block>

virtual size_t Concurrency::multi_link_registry< _Block >::_Find ( _EType  _Link )

inlineprivatevirtual

Searches the registry for the given link

Parameters

_Link

A pointer to a block that is to be searched.

Returns

Index of the entry if found.

    {
        size_t _Index = 0;
        for (_Index = 0; _Index < _M_vector._Size(); _Index++)
        {
            if (_M_vector[_Index] == _Link)
            {
                break;
            }
        }

        return _Index;
    }

template<class _Block>

virtual _EType Concurrency::multi_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

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 < _M_vector._Size())
        {
            return _M_vector[_Index];
        }

        return NULL;
    }

template<class _Block>

virtual void Concurrency::multi_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 >.

    {
        size_t _Size = _M_vector._Size();
        while (_Index < _Size)
        {
            if (_M_vector[_Index] != NULL)
            {
                break;
            }

            ++_Index;
        }
    }

template<class _Block>

bool Concurrency::multi_link_registry< _Block >::_Remove ( _EType  _Link )

inlineprivate

Removes a link from the multi_link_registry

Parameters

_Link

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

Returns

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

    {
        _CONCRT_ASSERT(_Link != NULL);

        for (size_t _Index = 0; _Index < _M_vector._Size(); _Index++)
        {
            if (_M_vector[_Index] == _Link)
            {
                _M_vector[_Index] = NULL;

                // If max links is set, prevent new additions to the registry
                if (_M_maxLinks != _NOT_SET && _M_maxLinks > 0)
                {
                    // Setting the bound to 0. This causes add to always throw.
                    _M_maxLinks = 0;
                }

                return true;
            }
        }

        return false;
    }

template<class _Block>

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

inlinevirtual

Adds a link to the multi_link_registry object.

Parameters

_Link

A pointer to a block to be added.

The method throws an invalid_link_target exception if the link is already present in the registry, or if a bound has already been set with the set_bound function and a link has since been removed.

Implements Concurrency::network_link_registry< _Block >.

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

        _Add(_Link);
    }

template<class _Block>

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

inlinevirtual

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

The end state is indicated by a NULL link.

Returns

An iterator addressing the first element in the multi_link_registry object.

Implements Concurrency::network_link_registry< _Block >.

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

template<class _Block>

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

inlinevirtual

Searches the multi_link_registry object for a specified block.

Parameters

_Link

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

Returns

true if the specified block was found, false otherwise.

Implements Concurrency::network_link_registry< _Block >.

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

        return (_Find(_Link) < _M_vector._Size());
    }

template<class _Block>

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

inlinevirtual

Counts the number of items in the multi_link_registry object.

Returns

The number of items in the multi_link_registry object.

Implements Concurrency::network_link_registry< _Block >.

    {
        return _Count();
    }

template<class _Block>

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

inlinevirtual

Removes a link from the multi_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)
        {
            return false;
        }

        return (_Remove(_Link));
    }

template<class _Block>

void Concurrency::multi_link_registry< _Block >::set_bound ( size_t  _MaxLinks )

inline

Sets an upper bound on the number of links that the multi_link_registry object can hold.

Parameters

_MaxLinks

The maximum number of links that the multi_link_registry object can hold.

After a bound is set, unlinking an entry will cause the multi_link_registry object to enter an immutable state where further calls to add will throw an invalid_link_target exception.

    {
        _CONCRT_ASSERT(count() == 0);
        _M_maxLinks = _MaxLinks;
    }

Member Data Documentation

template<class _Block>

size_t Concurrency::multi_link_registry< _Block >::_M_maxLinks

private

template<class _Block>

::Concurrency::details::_Dynamic_array<_EType> Concurrency::multi_link_registry< _Block >::_M_vector

private

template<class _Block>

const size_t Concurrency::multi_link_registry< _Block >::_NOT_SET = SIZE_MAX

staticprivate

---

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

• VS2013/inc/agents.h