std::list2< _Ty, _Alloc > Class Template Reference

expanded list template class More...

#include <list2.h>

Inheritance diagram for std::list2< _Ty, _Alloc >:

[legend]

Collaboration diagram for std::list2< _Ty, _Alloc >:

[legend]

List of all members.

Public Member Functions
virtual void	limit (size_type _Limit)
pair< size_type, bool >	position (const _Ty &_Val) const
bool	contains (const _Ty &_Val) const
bool	contains_no (const _Ty &_Val) const
virtual bool	add_if_new (const _Ty &_Val)
	operator bool ()
reference	at (size_type _Off)
const_reference	at (size_type _Off) const
reference	operator[] (size_type _Off)
const_reference	operator[] (size_type _Off) const
Static Public Member Functions
static list2< _Ty, _Alloc > __cdecl	dyn_create (size_type _Count,...)
Protected Member Functions
void	_Xran () const
Related Functions
(Note that these are not member functions.)
template<class _Ty_a, class _Alloc_a, class _Ty_b, class _Alloc_b>
list2< _Ty_a, _Alloc_a > &	operator+= (list2< _Ty_a, _Alloc_a > &container, const list< _Ty_b, _Alloc_b > &values)
template<class _Ty_a, class _Alloc_a, class _Ty_b, class _Alloc_b>
list2< _Ty_a, _Alloc_a > &	operator<< (list2< _Ty_a, _Alloc_a > &container, const list< _Ty_b, _Alloc_b > &values)

---

Detailed Description

template<class _Ty, class _Alloc = allocator<_Ty>>
class std::list2< _Ty, _Alloc >

expanded list template class

This specialisation supports:

• limit() Decreases size to a given limit
• contains() Checks whether or not a specific element is contained
• add_if_new() Adds an element if it is not contained
• sort() Sorts the elements

Note:

deque2, list2 and vector2 are designed to be replaceable by each other and hence have the same access methods. However the main differences of their stl base templates still apply.

Speed?

• contains() O(n)
• at(), [] O(n)
• sort() O(n^2)

Parameters:

	_Ty	element/value type
	_Alloc	element/value allocator

Definition at line 70 of file list2.h.

---

Member Function Documentation

template<class _Ty, class _Alloc = allocator<_Ty>>

virtual void std::list2< _Ty, _Alloc >::limit

(

size_type

_Limit

)

[inline, virtual]

Limit does not grow if size() < _Limit as resize() does!

Parameters:

_Limit

size limit for vector

Definition at line 80 of file list2.h.

    {
        if (size() > _Limit)
        {
            resize(_Limit);
        }
    }

template<class _Ty, class _Alloc = allocator<_Ty>>

pair<size_type, bool> std::list2< _Ty, _Alloc >::position

(

const _Ty &

_Val

)

const [inline]

Brute force evaluation of element index in container. -1 is returned if element is not contained.

Parameters:

_Val

element to search for

Returns:

• position of _Val in vector or -1 if _VAL is not element of vector
• whether or not _Val is element of vector

Definition at line 98 of file list2.h.

    {
        size_type _Index = 0;
        for (const_iterator iter = begin(); iter != end(); ++iter, ++_Index)
        {
            if (*iter == _Val)
            {
                return pair<size_type, bool>(_Index, true);
            }
        }
        return pair<size_type, bool>(-1, false);
    }

template<class _Ty, class _Alloc = allocator<_Ty>>

bool std::list2< _Ty, _Alloc >::contains

(

const _Ty &

_Val

)

const [inline]

Brute force test to check whether or not a specific value is contained in the vector.

Parameters:

_Val

element to check for

Returns:

whether or not _Val is member of the vector

Definition at line 119 of file list2.h.

Referenced by std::list2< _Ty, _Alloc >::add_if_new().

    {
        return std::find(begin(), end(), _Val) != end();
    }

template<class _Ty, class _Alloc = allocator<_Ty>>

bool std::list2< _Ty, _Alloc >::contains_no

(

const _Ty &

_Val

)

const [inline]

Brute force test to check whether or not a specific value is contained in the vector. The inverted result is returned this can be used for map2 values(check_fun_t) to return a unique list.

Parameters:

_Val

element to check for

Returns:

whether or not _Val is new = NOT contained in the vector

Definition at line 133 of file list2.h.

    {
        return std::find(begin(), end(), _Val) == end();
    }

template<class _Ty, class _Alloc = allocator<_Ty>>

virtual bool std::list2< _Ty, _Alloc >::add_if_new

(

const _Ty &

_Val

)

[inline, virtual]

Add _Val if it is not already contained in the list Returns wether or not _Val was added

Parameters:

_Val

element to add

Returns:

whether _Val was added or already contained

Definition at line 146 of file list2.h.

References std::list2< _Ty, _Alloc >::contains().

    {
        if (!contains(_Val))
        {
            push_back(_Val);
            return true;
        }
        return false;
    }

Here is the call graph for this function:

template<class _Ty, class _Alloc = allocator<_Ty>>

std::list2< _Ty, _Alloc >::operator bool

(

)

[inline]

Check whether the vector contains any element

Returns:

element cout > 0

Definition at line 162 of file list2.h.

    {
        return size() > 0;
    }

template<class _Ty, class _Alloc = allocator<_Ty>>

reference std::list2< _Ty, _Alloc >::at

(

size_type

_Off

)

[inline]

dereference operator

Parameters:

_Off

offset/index of element to dereference

Definition at line 171 of file list2.h.

References std::list2< _Ty, _Alloc >::_Xran().

Referenced by std::list2< _Ty, _Alloc >::operator[]().

    {   // subscript mutable sequence with checking
        if (size() <= _Off)
        {
            _Xran();
        }
        iterator it = begin();
        while(_Off--) ++it;
        return *it;
    }

Here is the call graph for this function:

template<class _Ty, class _Alloc = allocator<_Ty>>

const_reference std::list2< _Ty, _Alloc >::at

(

size_type

_Off

)

const [inline]

dereference operator

Parameters:

_Off

offset/index of element to dereference

Definition at line 188 of file list2.h.

References std::list2< _Ty, _Alloc >::_Xran().

    {   // subscript non mutable sequence with checking
        if (size() <= _Off)
        {
            _Xran();
        }
        const_iterator it = begin();
        while(_Off--) ++it;
        return *it;
    }

Here is the call graph for this function:

template<class _Ty, class _Alloc = allocator<_Ty>>

reference std::list2< _Ty, _Alloc >::operator[]

(

size_type

_Off

)

[inline]

dereference operator

Parameters:

_Off

offset/index of element to dereference

Definition at line 205 of file list2.h.

References std::list2< _Ty, _Alloc >::at().

    {   // subscript mutable sequence
        return at(_Off);
    }

Here is the call graph for this function:

template<class _Ty, class _Alloc = allocator<_Ty>>

const_reference std::list2< _Ty, _Alloc >::operator[]

(

size_type

_Off

)

const [inline]

dereference operator

Parameters:

_Off

offset/index of element to dereference

Definition at line 216 of file list2.h.

References std::list2< _Ty, _Alloc >::at().

    {   // subscript nonmutable sequence
        return at(_Off);
    }

Here is the call graph for this function:

template<class _Ty, class _Alloc = allocator<_Ty>>

static list2<_Ty, _Alloc> __cdecl std::list2< _Ty, _Alloc >::dyn_create	(	size_type	_Count,
			...
	)			[inline, static]

Dynamic list creation.

Parameters:

	_Count	number of elemnts to put into list2
	...	elements to put into the vector each of type _Ty (_Count times)

Definition at line 228 of file list2.h.

    {
        _Myt       _List;
        va_list    _Args;

        va_start(_Args, _Count);
        while(_Count--)
        {
            _List.push_back(va_arg(_Args, const _Ty));
        }
        va_end(_Args);
        return _List;
    }

template<class _Ty, class _Alloc = allocator<_Ty>>

void std::list2< _Ty, _Alloc >::_Xran

(

)

const [inline, protected]

throw an out of range exception

Definition at line 249 of file list2.h.

Referenced by std::list2< _Ty, _Alloc >::at().

    {   // report an out_of_range error
        _THROW(out_of_range, "invalid list2<T> subscript");
    }

---

Friends And Related Function Documentation

template<class _Ty_a, class _Alloc_a, class _Ty_b, class _Alloc_b>

list2< _Ty_a, _Alloc_a > & operator+=	(	list2< _Ty_a, _Alloc_a > &	container,
		const list< _Ty_b, _Alloc_b > &	values
	)			[related]

add (not store) the values of a container to another container

Note:

the receiver container will not be emptied

Warning:

this operator can only be instanciated if a conversion from _Ty_b to _Ty_a exists

See also:

list2::operator<<

Parameters:

	_Ty_a	element/value type of receiver container
	_Alloc_a	element/value allocator of receiver container
	_Ty_b	element/value type of input container
	_Alloc_b	element/value allocator of input container
	container	container that receives th e input values
	values	container input values

Returns:

modified container

Definition at line 274 of file list2.h.

{
    // NO clear
    for (list2<_Ty_b, _Alloc_b>::const_iterator it = values.begin(); it != values.end(); ++it)
    {
        container.push_back((_Ty_a)*it);
    }
    return container;
};

template<class _Ty_a, class _Alloc_a, class _Ty_b, class _Alloc_b>

list2< _Ty_a, _Alloc_a > & operator<<	(	list2< _Ty_a, _Alloc_a > &	container,
		const list< _Ty_b, _Alloc_b > &	values
	)			[related]

store (not add) the values of a container to another containert

Note:

the receiver container will be emptied

Warning:

this operator can only be instanciated if a conversion from _Ty_b to _Ty_a exists

See also:

list2::operator+=

Parameters:

	_Ty_a	element/value type of receiver container
	_Alloc_a	element/value allocator of receiver container
	_Ty_b	element/value type of input container
	_Alloc_b	element/value allocator of input container
	container	container that receives th e input values
	values	container input values

Returns:

modified container

Definition at line 305 of file list2.h.

{
    container.clear();
    container += values;
    return container;
};

---

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

• list2.h

---