Rogue Wave banner
Previous fileTop of DocumentContentsIndex pageNext file
Essential Tools Module Reference Guide

RWTPtrDeque<T,A>

Module:  Essential Tools Module   Group:  STL-based Collection


Does not inherit

Local Index

Members

Non-Members

Synopsis

#include <rw/tpdeque.h> 
RWTPtrDeque<T,A> deq;

Description

This class maintains a pointer-based collection of values, implemented as a double-ended queue, or deque. Class T is the type pointed to by the items in the collection.

Persistence

Isomorphic

Example

In this example, a double-ended queue of ints is exercised.

Program Input:

Program Output:

Related Classes

Classes RWTPtrDlist<T,A>, RWTPtrSlist<T,A>, and RWTPtrOrderedVector<T,A> also provide a Rogue Wave pointer-based interface to C++-standard sequence collections.

Class deque<T*,A> is the C++-standard collection that serves as the underlying implementation for this class.

Public Typedefs

typedef deque<T*,A> container_type;
typedef container_type::iterator iterator;
typedef container_type::const_iterator const_iterator;
typedef container_type::size_type size_type;
typedef container_type::difference_type difference_type;
typedef T* value_type;
typedef T*& reference; 
typedef T* const& const_reference;

Public Constructors

RWTPtrDeque<T,A>();
RWTPtrDeque<T,A>(const deque<T*,A>& deq); 
RWTPtrDeque<T,A>(const RWTPtrDeque<T,A>& rwdeq);
RWTPtrDeque<T,A>(size_type n, T* a);
RWTPtrDeque<T,A>(T* const* first, T* const* last);

Public Member Operators

RWTPtrDeque<T,A>&
operator=(const RWTPtrDeque<T,A>& deq);
RWTPtrDeque<T,A>&
operator=(const deque<T*,A>& stddeq);
bool
operator<(const RWTPtrDeque<T,A>& deq);
bool
operator==(const RWTPtrDeque<T,A>& deq);
reference
operator()(size_type i) ;
const_reference
operator()(size_type i) const;
reference
operator[](size_type i); 
const_reference
operator[](size_type i) const;

Public Member Functions

void
append(T* a); 
void
apply(void (*fn)(T*,void*), void* d); 
void
apply(void (*fn)(const T*,void*), void* d) const; 
void
apply(void (*fn)(T*&,void*), void* d);
reference
at(size_type i); 
const_reference
at(size_type i) const;
iterator
begin();
const_iterator
begin() const;
void
clear();
void
clearAndDestroy();
bool
contains (const T* a) const; 
bool
contains (bool (*fn)(const T*, void*), void *d) const;
bool
contains(bool (*fn)(T*,void*), void* d) const;
iterator
end();
const_iterator
end() const;
size_type
entries() const; 
T*
find(const T* a) const; 
T*
find(bool (*fn)( T*,void*), void* d) const;
T*
find(bool (*fn)(const T*,void*), void* d) const;
reference
first();
const_reference
first() const;
size_type
index(const T* a) const; 
size_type
index(bool (*fn)(T*,void*), void* d) const;
size_type
index(bool (*fn)(const T*,void*), void* d) const;
bool
insert(T* a); 
void
insertAt(size_type i, T* a); 
bool
isEmpty() const; 
T*&
last();
T* const &
last() const;
reference
maxElement();
const_reference
maxElement() const;
reference
minElement();
const_reference
minElement() const;
size_type
occurrencesOf(const T* a) const; 
size_type
occurrencesOf(bool (*fn)(T*,void*), void* d) const;
size_type
occurrencesOf(bool (*fn)(const T*,void*), void* d) const;
T*
popBack();
T*
popFront();
void
prepend(T* a); 
void
pushBack(T* a); 
void
pushFront(T* a); 
T*
remove(const T* a); 
T*
remove(bool (*fn)(T*, void*), void* d);
T*
remove(bool (*fn)(const T*,void*), void* d);
size_type const T*
removeAll(const_reference a); 
size_type
removeAll(bool (*fn)(T*,void*), void* d);
size_type
removeAll(bool (*fn)(const T*,void*), void* d);
T*
removeAt(size_type i); 
T*
removeFirst();
T*
removeLast();
size_type
replaceAll(const T* oldVal, T* newVal); 
size_type
replaceAll(bool (*fn)(T*, void*), void* x, T* newVal);
size_type
replaceAll(bool (*fn)(const T*, void*), void* x,
           const T* newVal);
void
sort();
deque<T*,A>&
std();
const deque<T*,A>&
std() const;

Static Public Data Member

size_type npos;

Related Global Operators

RWvostream&
operator<<(RWvostream& strm, const RWTPtrDeque<T,A>& coll);
RWFile&
operator<<(RWFile& strm, const RWTPtrDeque<T,A>& coll);
RWvistream&
operator>>(RWvistream& strm, RWTPtrDeque<T,A>& coll);
RWFile&
operator>>(RWFile& strm, RWTPtrDeque<T,A>& coll);
RWvistream&
operator>>(RWvistream& strm, RWTPtrDeque<T,A>*& p);
RWFile&
operator>>(RWFile& strm, RWTPtrDeque<T,A>*& p);


Previous fileTop of DocumentContentsIndex pageNext file

©2004 Copyright Quovadx, Inc. All Rights Reserved.
Rogue Wave and SourcePro are registered trademarks of Quovadx, Inc. in the United States and other countries. All other trademarks are the property of their respective owners.
Contact Rogue Wave about documentation or support issues.