RWTPtrForwardList< T, A > Class Template Reference

A pointer-based collection of values implemented as a singly-linked list. More...

#include <rw/tools/tpfwdlist.h>

Public Types
typedef container_type::allocator_type	allocator_type
typedef container_type::const_iterator	const_iterator
typedef container_type::const_pointer	const_pointer
typedef container_type::const_reference	const_reference
typedef rw_forward_list< T *, A >	container_type
typedef container_type::difference_type	difference_type
typedef container_type::iterator	iterator
typedef container_type::pointer	pointer
typedef container_type::reference	reference
typedef container_type::size_type	size_type
typedef container_type::value_type	value_type

Public Member Functions
	RWTPtrForwardList ()
	RWTPtrForwardList (const container_type &lst)
	RWTPtrForwardList (const RWTPtrForwardList< T, A > &lst)
	RWTPtrForwardList (RWTPtrForwardList< T, A > &&lst)
	RWTPtrForwardList (container_type &&lst)
	RWTPtrForwardList (size_type n, value_type val=value_type())
template<typename InputIterator >
	RWTPtrForwardList (InputIterator first, InputIterator last)
void	apply (void(*fn)(value_type &, void *), void *d)
void	apply (void(*fn)(value_type, void *), void *d)
void	apply (void(*fn)(const T *, void *), void *d) const
template<typename InputIterator >
void	assign (InputIterator first, InputIterator last)
reference	at (size_type i)
const_reference	at (size_type i) const
iterator	beforeBegin ()
const_iterator	beforeBegin () const
iterator	begin ()
const_iterator	begin () const
const_iterator	cbeforeBegin () const
const_iterator	cbegin () const
const_iterator	cend () const
void	clear ()
void	clearAndDestroy ()
bool	contains (bool(*fn)(const T *, void *), void *d) const
bool	contains (const T *a) const
iterator	end ()
const_iterator	end () const
iterator	eraseAfter (const_iterator position)
iterator	eraseAfter (const_iterator position, const_iterator last)
value_type	find (bool(*fn)(const T *, void *), void *d) const
value_type	find (const T *a) const
reference	first ()
const_reference	first () const
size_type	index (const T *a) const
size_type	index (bool(*fn)(const T *, void *), void *d) const
iterator	insertAfter (const_iterator position, value_type value)
template<typename InputIterator >
iterator	insertAfter (const_iterator position, InputIterator first, InputIterator last)
iterator	insertAfter (const_iterator position, size_type n, value_type value)
void	insertAt (size_type i, value_type a)
bool	isEmpty () const
reference	maxElement ()
const_reference	maxElement () const
reference	minElement ()
const_reference	minElement () const
size_type	occurrencesOf (bool(*fn)(const T *, void *), void *d) const
size_type	occurrencesOf (const T *a) const
reference	operator() (size_type i)
const_reference	operator() (size_type i) const
RWTPtrForwardList< T, A > &	operator= (const RWTPtrForwardList< T, A > &rhs)
RWTPtrForwardList< T, A > &	operator= (const container_type &rhs)
RWTPtrForwardList< T, A > &	operator= (RWTPtrForwardList< T, A > &&rhs)
RWTPtrForwardList< T, A > &	operator= (container_type &&rhs)
reference	operator[] (size_type i)
const_reference	operator[] (size_type i) const
value_type	remove (const T *a)
value_type	remove (bool(*fn)(const T *, void *), void *d)
size_type	removeAll (const T *a)
value_type	removeAt (size_type i)
size_type	replaceAll (bool(*fn)(const T *, void *), void *d, value_type newVal)
size_type	replaceAll (const T *oldVal, value_type newVal)
void	sort ()
container_type &	std ()
const container_type &	std () const
void	swap (RWTPtrForwardList< T, A > &rhs)

Related Functions
(Note that these are not member functions.)
template<class T , class A >
bool	operator!= (const RWTPtrForwardList< T, A > &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
bool	operator!= (const RWTPtrForwardList< T, A > &lhs, const typename RWTPtrForwardList< T, A >::container_type &rhs)
template<class T , class A >
bool	operator!= (const typename RWTPtrForwardList< T, A >::container_type &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
bool	operator< (const RWTPtrForwardList< T, A > &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
bool	operator< (const RWTPtrForwardList< T, A > &lhs, const typename RWTPtrForwardList< T, A >::container_type &rhs)
template<class T , class A >
bool	operator< (const typename RWTPtrForwardList< T, A >::container_type &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
RWvostream &	operator<< (RWvostream &strm, const RWTPtrForwardList< T, A > &coll)
template<class T , class A >
RWFile &	operator<< (RWFile &strm, const RWTPtrForwardList< T, A > &coll)
template<class T , class A >
bool	operator<= (const RWTPtrForwardList< T, A > &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
bool	operator<= (const RWTPtrForwardList< T, A > &lhs, const typename RWTPtrForwardList< T, A >::container_type &rhs)
template<class T , class A >
bool	operator<= (const typename RWTPtrForwardList< T, A >::container_type &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
bool	operator== (const RWTPtrForwardList< T, A > &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
bool	operator== (const RWTPtrForwardList< T, A > &lhs, const typename RWTPtrForwardList< T, A >::container_type &rhs)
template<class T , class A >
bool	operator== (const typename RWTPtrForwardList< T, A >::container_type &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
bool	operator> (const RWTPtrForwardList< T, A > &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
bool	operator> (const RWTPtrForwardList< T, A > &lhs, const typename RWTPtrForwardList< T, A >::container_type &rhs)
template<class T , class A >
bool	operator> (const typename RWTPtrForwardList< T, A >::container_type &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
bool	operator>= (const RWTPtrForwardList< T, A > &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
bool	operator>= (const RWTPtrForwardList< T, A > &lhs, const typename RWTPtrForwardList< T, A >::container_type &rhs)
template<class T , class A >
bool	operator>= (const typename RWTPtrForwardList< T, A >::container_type &lhs, const RWTPtrForwardList< T, A > &rhs)
template<class T , class A >
RWvistream &	operator>> (RWvistream &strm, RWTPtrForwardList< T, A > &coll)
template<class T , class A >
RWFile &	operator>> (RWFile &strm, RWTPtrForwardList< T, A > &coll)
template<class T , class A >
RWvistream &	operator>> (RWvistream &strm, RWTPtrForwardList< T, A > *&p)
template<class T , class A >
RWFile &	operator>> (RWFile &strm, RWTPtrForwardList< T, A > *&p)

Detailed Description

template<class T, class A = std::allocator<T*>>
class RWTPtrForwardList< T, A >

This class maintains a pointer-based collection of values, implemented as a singly-linked list that allows constant time insert and erase operations anywhere within the sequence. Fast random access is not supported as this class maintains uni-directional linking for space efficiency. Class T is the type pointed to by the items in the collection. Class A is an allocator of objects of class T. For more information about using custom allocators, please see the Essential Tools Module User's Guide.

Synopsis

#include <rw/tools/tpfwdlist.h>
RWTPtrForwardList<T,A> lst;

See also

Classes RWTPtrDlist, RWTPtrDeque, and RWTPtrOrderedVector also provide a Rogue Wave interface to C++ Standard Library sequence collections.

The Rogue Wave supplied, Standard Library-compliant class rw_forward_list is the collection that serves as the underlying implementation for this class.

Persistence

Isomorphic

Member Typedef Documentation

template<class T, class A = std::allocator<T*>>

typedef container_type::allocator_type RWTPtrForwardList< T, A >::allocator_type

A type representing the allocator type for the container.

template<class T, class A = std::allocator<T*>>

typedef container_type::const_iterator RWTPtrForwardList< T, A >::const_iterator

A type that provides a const forward iterator over the elements in the container.

template<class T, class A = std::allocator<T*>>

typedef container_type::const_pointer RWTPtrForwardList< T, A >::const_pointer

A type that provides a const pointer to an element in the container.

template<class T, class A = std::allocator<T*>>

typedef container_type::const_reference RWTPtrForwardList< T, A >::const_reference

A type that provides a const reference to an element in the container.

template<class T, class A = std::allocator<T*>>

typedef rw_forward_list<T*, A> RWTPtrForwardList< T, A >::container_type

A type representing the underlying implementation container.

template<class T, class A = std::allocator<T*>>

typedef container_type::difference_type RWTPtrForwardList< T, A >::difference_type

A signed integral type used to indicate the distance between two valid iterators on the same container.

template<class T, class A = std::allocator<T*>>

typedef container_type::iterator RWTPtrForwardList< T, A >::iterator

A type that provides a forward iterator over the elements in the container.

template<class T, class A = std::allocator<T*>>

typedef container_type::pointer RWTPtrForwardList< T, A >::pointer

A type that provides a pointer to an element in the container.

template<class T, class A = std::allocator<T*>>

typedef container_type::reference RWTPtrForwardList< T, A >::reference

A type that provides a reference to an element in the container.

template<class T, class A = std::allocator<T*>>

typedef container_type::size_type RWTPtrForwardList< T, A >::size_type

An unsigned integral type used for counting the number of elements in the container.

template<class T, class A = std::allocator<T*>>

typedef container_type::value_type RWTPtrForwardList< T, A >::value_type

A type representing the container's data type.

Constructor & Destructor Documentation

template<class T, class A = std::allocator<T*>>

RWTPtrForwardList< T, A >::RWTPtrForwardList ( )

inline

Constructs an empty, singly-linked list.

template<class T, class A = std::allocator<T*>>

RWTPtrForwardList< T, A >::RWTPtrForwardList ( const container_type &  lst )

inline

Constructs a singly-linked list by copying all elements of lst.

template<class T, class A = std::allocator<T*>>

RWTPtrForwardList< T, A >::RWTPtrForwardList ( const RWTPtrForwardList< T, A > &  lst )

inline

Copy constructor.

template<class T, class A = std::allocator<T*>>

RWTPtrForwardList< T, A >::RWTPtrForwardList ( RWTPtrForwardList< T, A > &&  lst )

inline

Move constructor. The constructed list takes ownership of the data owned by lst.

Condition:

This method is available only on platforms with rvalue reference support.

template<class T, class A = std::allocator<T*>>

RWTPtrForwardList< T, A >::RWTPtrForwardList ( container_type &&  lst )

inline

Move constructor. The constructed list takes ownership of the data owned by lst.

Condition:

This method is available only on platforms with rvalue reference support.

template<class T, class A = std::allocator<T*>>

RWTPtrForwardList< T, A >::RWTPtrForwardList ( size_type  n, value_type  val = value_type()  )

inline

Constructs a singly-linked list with n elements, each initialized to val.

template<class T, class A = std::allocator<T*>>

template<typename InputIterator >

RWTPtrForwardList< T, A >::RWTPtrForwardList ( InputIterator  first, InputIterator  last  )

inline

Constructs a singly-linked list by copying elements from the range [first, last).

InputIterator is an input iterator type that points to elements that are convertible to value_type objects.

Member Function Documentation

template<class T, class A = std::allocator<T*>>

void RWTPtrForwardList< T, A >::apply ( void(*)(value_type &, void *)  fn, void *  d  )

inline

Invokes the function pointer fn on each item in the collection. Client data may be passed through parameter d.

template<class T, class A = std::allocator<T*>>

void RWTPtrForwardList< T, A >::apply ( void(*)(value_type, void *)  fn, void *  d  )

inline

Invokes the function pointer fn on each item in the collection. Client data may be passed through parameter d.

template<class T, class A = std::allocator<T*>>

void RWTPtrForwardList< T, A >::apply ( void(*)(const T *, void *)  fn, void *  d  ) const

inline

Invokes the function pointer fn on each item in the collection. Client data may be passed through parameter d.

template<class T, class A = std::allocator<T*>>

template<typename InputIterator >

void RWTPtrForwardList< T, A >::assign ( InputIterator  first, InputIterator  last  )

inline

Copies each element in the range [first, last) into self, replacing any existing items.

InputIterator is an input iterator type that points to elements that are convertible to value_type objects.

Note

first and last must not be iterators into self.

template<class T, class A = std::allocator<T*>>

reference RWTPtrForwardList< T, A >::at ( size_type  i )

inline

Returns a reference to the i ^th element of self.

Exceptions

RWBoundsErr

Thrown if index i is not between 0 and one less than the number of entries in self.

template<class T, class A = std::allocator<T*>>

const_reference RWTPtrForwardList< T, A >::at ( size_type  i ) const

inline

Returns a reference to the i ^th element of self.

Exceptions

RWBoundsErr

Thrown if index i is not between 0 and one less than the number of entries in self.

template<class T, class A = std::allocator<T*>>

iterator RWTPtrForwardList< T, A >::beforeBegin ( )

inline

Returns an iterator preceding the first element in the container. This iterator is intended for use with functions insertAfter() and eraseAfter(). Attempting to access this iterator results in undefined behavior. When the iterator returned by this function is incremented, it is equivalent to the iterator returned by begin().

template<class T, class A = std::allocator<T*>>

const_iterator RWTPtrForwardList< T, A >::beforeBegin ( ) const

inline

Returns an iterator preceding the first element in the container. This iterator is intended for use with functions insertAfter() and eraseAfter(). Attempting to access this iterator results in undefined behavior. When the iterator returned by this function is incremented, it is equivalent to the iterator returned by begin().

template<class T, class A = std::allocator<T*>>

iterator RWTPtrForwardList< T, A >::begin ( )

inline

Returns an iterator referring to the first element in the container.

If the container is empty, returns end().

template<class T, class A = std::allocator<T*>>

const_iterator RWTPtrForwardList< T, A >::begin ( ) const

inline

Returns an iterator referring to the first element in the container.

If the container is empty, returns end().

template<class T, class A = std::allocator<T*>>

const_iterator RWTPtrForwardList< T, A >::cbeforeBegin ( ) const

inline

Returns an iterator preceding the first element in the container. This iterator is intended for use with functions insertAfter() and eraseAfter(). Dereferencing the iterator returned by this function results in undefined behavior. When the iterator returned by this function is incremented, it is equivalent to the iterator returned by cbegin().

template<class T, class A = std::allocator<T*>>

const_iterator RWTPtrForwardList< T, A >::cbegin ( ) const

inline

Returns an iterator referring to the first element in the container.

If the container is empty, returns end().

template<class T, class A = std::allocator<T*>>

const_iterator RWTPtrForwardList< T, A >::cend ( ) const

inline

Returns an iterator referring to the element after the last element in the container.

Dereferencing the iterator returned by this function results in undefined behavior.

template<class T, class A = std::allocator<T*>>

void RWTPtrForwardList< T, A >::clear ( void  )

inline

Clears the collection by removing all items from self.

template<class T, class A = std::allocator<T*>>

void RWTPtrForwardList< T, A >::clearAndDestroy ( void  )

inline

Removes all items from the collection and uses operator delete to destroy the objects pointed to by those items. Do not use this method if multiple pointers to the same object are stored.

template<class T, class A = std::allocator<T*>>

bool RWTPtrForwardList< T, A >::contains ( bool(*)(const T *, void *)  fn, void *  d  ) const

inline

Returns true if there exists an element t in self such that the expression ((*fn)(t, d)) is true, otherwise returns false. Client data may be passed through parameter d.

template<class T, class A = std::allocator<T*>>

bool RWTPtrForwardList< T, A >::contains ( const T *  a ) const

inline

Returns true if there exists an element t in self such that the expression (t == a) is true, otherwise returns false.

template<class T, class A = std::allocator<T*>>

iterator RWTPtrForwardList< T, A >::end ( )

inline

Returns an iterator referring to the element after the last element in the container.

Dereferencing the iterator returned by this function results in undefined behavior.

template<class T, class A = std::allocator<T*>>

const_iterator RWTPtrForwardList< T, A >::end ( ) const

inline

Returns an iterator referring to the element after the last element in the container.

Dereferencing the iterator returned by this function results in undefined behavior.

template<class T, class A = std::allocator<T*>>

iterator RWTPtrForwardList< T, A >::eraseAfter ( const_iterator  position )

inline

Removes from self the element following position. If position does not reference an actual element contained in self, the behavior is undefined. Returns an iterator referencing the location just after the erased element.

template<class T, class A = std::allocator<T*>>

iterator RWTPtrForwardList< T, A >::eraseAfter ( const_iterator  position, const_iterator  last  )

inline

Removes from self the elements referenced by the range following position and bounded by last. Returns an iterator referencing a position just after the last erased element. If position does not reference an element in self, the behavior is undefined.

template<class T, class A = std::allocator<T*>>

value_type RWTPtrForwardList< T, A >::find ( bool(*)(const T *, void *)  fn, void *  d  ) const

inline

If there exists an element t in self such that the expression ((*fn)(t,d)) is true, returns t. Otherwise, returns rwnil. Client data may be passed through parameter d.

template<class T, class A = std::allocator<T*>>

value_type RWTPtrForwardList< T, A >::find ( const T *  a ) const

inline

If there exists an element t in self such that the expression (*t == *a) is true, returns t. Otherwise, returns rwnil.

template<class T, class A = std::allocator<T*>>

reference RWTPtrForwardList< T, A >::first ( void  )

inline

Returns a reference to the first item in the collection.

Calling this function on an empty collection results in undefined behavior.

template<class T, class A = std::allocator<T*>>

const_reference RWTPtrForwardList< T, A >::first ( void  ) const

inline

Returns a reference to the first item in the collection.

Calling this function on an empty collection results in undefined behavior.

template<class T, class A = std::allocator<T*>>

size_type RWTPtrForwardList< T, A >::index ( const T *  a ) const

inline

Returns the position of the first item t in self such that (*t == *a), or returns RW_NPOS if no such item exists.

template<class T, class A = std::allocator<T*>>

size_type RWTPtrForwardList< T, A >::index ( bool(*)(const T *, void *)  fn, void *  d  ) const

inline

Returns the position of the first item t in self such that ((*fn)(t,d)) is true, or returns RW_NPOS if no such item exists. Client data may be passed through parameter d.

template<class T, class A = std::allocator<T*>>

iterator RWTPtrForwardList< T, A >::insertAfter ( const_iterator  position, value_type  value  )

inline

Inserts value after the element referenced by position. Returns an iterator referencing the newly inserted element.

template<class T, class A = std::allocator<T*>>

template<typename InputIterator >

iterator RWTPtrForwardList< T, A >::insertAfter ( const_iterator  position, InputIterator  first, InputIterator  last  )

inline

Inserts instances of each element in the range [first, last) into self after the element referenced by position. Returns an iterator referencing the last inserted element.

InputIterator is an input iterator type that points to elements that are convertible to value_type objects.

Note

If first or last are iterators into this container, the behavior is undefined.

template<class T, class A = std::allocator<T*>>

iterator RWTPtrForwardList< T, A >::insertAfter ( const_iterator  position, size_type  n, value_type  value  )

inline

Inserts n copies of value into self after the element referenced by position. Returns an iterator to the last inserted element, or position if no items are inserted.

template<class T, class A = std::allocator<T*>>

void RWTPtrForwardList< T, A >::insertAt ( size_type  i, value_type  a  )

inline

Inserts the item a in front of the item at position i in self.

Exceptions

RWBoundsErr

Thrown if this position is not between 0 and the number of entries in the collection.

template<class T, class A = std::allocator<T*>>

bool RWTPtrForwardList< T, A >::isEmpty ( ) const

inline

Returns true if there are no items in the collection, false otherwise.

template<class T, class A = std::allocator<T*>>

reference RWTPtrForwardList< T, A >::maxElement ( )

inline

Returns a reference to the maximum element in the collection. Type T must have well-defined less-than semantics (T::operator<(const T&) or equivalent).

template<class T, class A = std::allocator<T*>>

const_reference RWTPtrForwardList< T, A >::maxElement ( ) const

inline

Returns a reference to the maximum element in the collection. Type T must have well-defined less-than semantics (T::operator<(const T&) or equivalent).

template<class T, class A = std::allocator<T*>>

reference RWTPtrForwardList< T, A >::minElement ( )

inline

Returns a reference to the minimum element in the collection. Type T must have well-defined less-than semantics (T::operator<(const T&) or equivalent).

template<class T, class A = std::allocator<T*>>

const_reference RWTPtrForwardList< T, A >::minElement ( ) const

inline

Returns a reference to the minimum element in the collection. Type T must have well-defined less-than semantics (T::operator<(const T&) or equivalent).

template<class T, class A = std::allocator<T*>>

size_type RWTPtrForwardList< T, A >::occurrencesOf ( bool(*)(const T *, void *)  fn, void *  d  ) const

inline

Returns the number of elements t in self such that the expression ((*fn)(t,d)) is true. Client data may be passed through parameter d.

template<class T, class A = std::allocator<T*>>

size_type RWTPtrForwardList< T, A >::occurrencesOf ( const T *  a ) const

inline

Returns the number of elements t in self such that the expression (*t == *a) is true.

template<class T, class A = std::allocator<T*>>

reference RWTPtrForwardList< T, A >::operator() ( size_type  i )

inline

Returns a reference to the i ^th element of self. Index i should be between 0 and one less than the number of entries, otherwise the results are undefined.

Note

No bounds checking is performed.

template<class T, class A = std::allocator<T*>>

const_reference RWTPtrForwardList< T, A >::operator() ( size_type  i ) const

inline

Returns a reference to the i ^th element of self. Index i should be between 0 and one less than the number of entries, otherwise the results are undefined.

Note

No bounds checking is performed.

template<class T, class A = std::allocator<T*>>

RWTPtrForwardList<T, A>& RWTPtrForwardList< T, A >::operator= ( const RWTPtrForwardList< T, A > &  rhs )

inline

Empties self, then inserts all elements of rhs.

template<class T, class A = std::allocator<T*>>

RWTPtrForwardList<T, A>& RWTPtrForwardList< T, A >::operator= ( const container_type &  rhs )

inline

Empties self, then inserts all elements of rhs.

template<class T, class A = std::allocator<T*>>

RWTPtrForwardList<T, A>& RWTPtrForwardList< T, A >::operator= ( RWTPtrForwardList< T, A > &&  rhs )

inline

Move assignment. Self takes ownership of the data owned by rhs.

Condition:

This method is available only on platforms with rvalue reference support.

template<class T, class A = std::allocator<T*>>

RWTPtrForwardList<T, A>& RWTPtrForwardList< T, A >::operator= ( container_type &&  rhs )

inline

Move assignment. Self takes ownership of the data owned by rhs.

Condition:

This method is available only on platforms with rvalue reference support.

template<class T, class A = std::allocator<T*>>

reference RWTPtrForwardList< T, A >::operator[] ( size_type  i )

inline

Returns a reference to the i ^th element of self.

Exceptions

RWBoundsErr

Thrown if index i is not between 0 and one less than the number of entries in self.

template<class T, class A = std::allocator<T*>>

const_reference RWTPtrForwardList< T, A >::operator[] ( size_type  i ) const

inline

Returns a reference to the i ^th element of self.

Exceptions

RWBoundsErr

Thrown if index i is not between 0 and one less than the number of entries in self.

template<class T, class A = std::allocator<T*>>

value_type RWTPtrForwardList< T, A >::remove ( const T *  a )

inline

Removes and returns the first element t in self such that the expression (*t == *a) is true. Returns rwnil if there is no such element.

template<class T, class A = std::allocator<T*>>

value_type RWTPtrForwardList< T, A >::remove ( bool(*)(const T *, void *)  fn, void *  d  )

inline

Removes and returns the first element t in self such that the expression ((*fn)(t,d)) is true. Returns rwnil if there is no such element. Client data may be passed through parameter d.

template<class T, class A = std::allocator<T*>>

size_type RWTPtrForwardList< T, A >::removeAll ( const T *  a )

inline

Removes all elements t in self such that the expression (*t == *a) is true. Returns the number of items removed.

template<class T, class A = std::allocator<T*>>

value_type RWTPtrForwardList< T, A >::removeAt ( size_type  i )

inline

Removes and returns the item at position i in self.

Exceptions

RWBoundsErr

Thrown if the index i is not between 0 and one less than the number of entries in the collection.

template<class T, class A = std::allocator<T*>>

size_type RWTPtrForwardList< T, A >::replaceAll ( bool(*)(const T *, void *)  fn, void *  d, value_type  newVal  )

inline

Replaces with newVal all elements t in self such that the expression ((*fn)(t,d)) is true. Returns the number of items replaced. Client data may be passed through parameter d.

template<class T, class A = std::allocator<T*>>

size_type RWTPtrForwardList< T, A >::replaceAll ( const T *  oldVal, value_type  newVal  )

inline

Replaces with newVal all elements t in self such that the expression (*t == *oldVal) is true. Returns the number of items replaced.

template<class T, class A = std::allocator<T*>>

void RWTPtrForwardList< T, A >::sort ( )

inline

Sorts the collection using the less-than operator to compare elements.

template<class T, class A = std::allocator<T*>>

container_type& RWTPtrForwardList< T, A >::std ( )

inline

Returns a reference to the underlying collection that serves as the implementation for self. This reference may be used freely, providing access to the C++ Standard Library interface as well as interoperability with other software components that make use of the C++ Standard Library collections.

template<class T, class A = std::allocator<T*>>

const container_type& RWTPtrForwardList< T, A >::std ( ) const

inline

Returns a reference to the underlying collection that serves as the implementation for self. This reference may be used freely, providing access to the C++ Standard Library interface as well as interoperability with other software components that make use of the C++ Standard Library collections.

template<class T, class A = std::allocator<T*>>

void RWTPtrForwardList< T, A >::swap ( RWTPtrForwardList< T, A > &  rhs )

inline

Swaps the data owned by self with the data owned by rhs.

Friends And Related Function Documentation

template<class T , class A >

bool operator!= ( const RWTPtrForwardList< T, A > &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Equivalent to !(lhs == rhs).

template<class T , class A >

bool operator!= ( const RWTPtrForwardList< T, A > &  lhs, const typename RWTPtrForwardList< T, A >::container_type &  rhs  )

related

Equivalent to !(lhs == rhs).

template<class T , class A >

bool operator!= ( const typename RWTPtrForwardList< T, A >::container_type &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Equivalent to !(lhs == rhs).

template<class T , class A >

bool operator< ( const RWTPtrForwardList< T, A > &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Returns true if lhs is lexicographically less than rhs, otherwise false. Assumes that type T has well-defined less-than semantics. Elements are dereferenced before being compared.

template<class T , class A >

bool operator< ( const RWTPtrForwardList< T, A > &  lhs, const typename RWTPtrForwardList< T, A >::container_type &  rhs  )

related

Returns true if lhs is lexicographically less than rhs, otherwise false. Assumes that type T has well-defined less-than semantics. Elements are dereferenced before being compared.

template<class T , class A >

bool operator< ( const typename RWTPtrForwardList< T, A >::container_type &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Returns true if lhs is lexicographically less than rhs, otherwise false. Assumes that type T has well-defined less-than semantics. Elements are dereferenced before being compared.

template<class T , class A >

RWvostream & operator<< ( RWvostream &  strm, const RWTPtrForwardList< T, A > &  coll  )

related

Saves the collection coll onto the output stream strm, or a reference to it if it has already been saved.

template<class T , class A >

RWFile & operator<< ( RWFile &  strm, const RWTPtrForwardList< T, A > &  coll  )

related

Saves the collection coll onto the RWFile strm, or a reference to it if it has already been saved.

template<class T , class A >

bool operator<= ( const RWTPtrForwardList< T, A > &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Equivalent to !(rhs < lhs).

template<class T , class A >

bool operator<= ( const RWTPtrForwardList< T, A > &  lhs, const typename RWTPtrForwardList< T, A >::container_type &  rhs  )

related

Equivalent to !(rhs < lhs).

template<class T , class A >

bool operator<= ( const typename RWTPtrForwardList< T, A >::container_type &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Equivalent to !(rhs < lhs).

template<class T , class A >

bool operator== ( const RWTPtrForwardList< T, A > &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Returns true if lhs and rhs are equal, otherwise false. Two collections are equal if both have the same number of entries, and iterating through both collections produces individual elements that, in turn, compare equal to each other. Elements are dereferenced before being compared.

template<class T , class A >

bool operator== ( const RWTPtrForwardList< T, A > &  lhs, const typename RWTPtrForwardList< T, A >::container_type &  rhs  )

related

Returns true if lhs and rhs are equal, otherwise false. Two collections are equal if both have the same number of entries, and iterating through both collections produces individual elements that, in turn, compare equal to each other. Elements are dereferenced before being compared.

template<class T , class A >

bool operator== ( const typename RWTPtrForwardList< T, A >::container_type &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Returns true if lhs and rhs are equal, otherwise false. Two collections are equal if both have the same number of entries, and iterating through both collections produces individual elements that, in turn, compare equal to each other. Elements are dereferenced before being compared.

template<class T , class A >

bool operator> ( const RWTPtrForwardList< T, A > &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Equivalent to (rhs < lhs).

template<class T , class A >

bool operator> ( const RWTPtrForwardList< T, A > &  lhs, const typename RWTPtrForwardList< T, A >::container_type &  rhs  )

related

Equivalent to (rhs < lhs).

template<class T , class A >

bool operator> ( const typename RWTPtrForwardList< T, A >::container_type &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Equivalent to (rhs < lhs).

template<class T , class A >

bool operator>= ( const RWTPtrForwardList< T, A > &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Equivalent to !(lhs < rhs).

template<class T , class A >

bool operator>= ( const RWTPtrForwardList< T, A > &  lhs, const typename RWTPtrForwardList< T, A >::container_type &  rhs  )

related

Equivalent to !(lhs < rhs).

template<class T , class A >

bool operator>= ( const typename RWTPtrForwardList< T, A >::container_type &  lhs, const RWTPtrForwardList< T, A > &  rhs  )

related

Equivalent to !(lhs < rhs).

template<class T , class A >

RWvistream & operator>> ( RWvistream &  strm, RWTPtrForwardList< T, A > &  coll  )

related

Restores the contents of the collection coll from the input stream strm.

template<class T , class A >

RWFile & operator>> ( RWFile &  strm, RWTPtrForwardList< T, A > &  coll  )

related

Restores the contents of the collection coll from the RWFile strm.

template<class T , class A >

RWvistream & operator>> ( RWvistream &  strm, RWTPtrForwardList< T, A > *&  p  )

related

Looks at the next object on the input stream strm and either creates a new collection off the heap and sets p to point to it, or sets p to point to a previously read instance. If a collection is created off the heap, then the application is responsible for deleting it.

template<class T , class A >

RWFile & operator>> ( RWFile &  strm, RWTPtrForwardList< T, A > *&  p  )

related

Looks at the next object on the RWFile strm and either creates a new collection off the heap and sets p to point to it, or sets p to point to a previously read instance. If a collection is created off the heap, then the application is responsible for deleting it.