Rogue Wave banner
Previous fileTop of documentContentsIndexNext file

RWTPtrOrderedVector<T>

Data Type and Member Function Indexes
(exclusive of constructors and destructors)

Synopsis

#include <rw/tpordvec.h> 
RWTPtrOrderedVector<T> ordvec;

Please Note!


If you have the Standard C++ Library, use the interface described here. Otherwise, use the restricted interface for RWTPtrOrderedVector described in Appendix A.


Description

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

Persistence

Isomorphic

Example

In this example, a pointer-based vector of type RWDate is exercised.

//
// tporddat.cpp
//
#include <rw/tpordvec.h>
#include <rw/rwdate.h>
#include <iostream.h>

main(){
  RWTPtrOrderedVector<RWDate> week(7);

  RWDate begin;  // Today's date

  for (int i=0; i<7; i++)
    week.insert(new RWDate(begin++));

  for (i=0; i<7; i++)
    cout << *week[i] << endl;

  return 0;
}


Program Output:
05/31/95
06/01/95
06/02/95
06/03/95
06/04/95
06/05/95
06/06/95

Related Classes

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

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

Public Typedefs

typedef vector<T*,allocator>                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

RWTPtrOrderedVector<T>();
RWTPtrOrderedVector<T>(const RWTPtrOrderedVector<T>& rwvec);
RWTPtrOrderedVector<T>(const vector<T*,allocator>& vec);
RWTPtrOrderedVector<T>(size_type n, T* a);
RWTPtrOrderedVector<T>(T* const* first,T* const* last);

Public Member Operators

RWTPtrOrderedVector<T>&
operator=(const RWTPtrOrderedVector<T>& vec); 
RWTPtrOrderedVector<T>&
operator=(const vector<T*,allocator>& vec);
bool
operator<(const RWTPtrOrderedVector<T>& vec) const; 
bool
operator==(const RWTPtrOrderedVector<T>& vec) const; 
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)(T*,void*), void* d);
void
apply(void (*fn)(const T*,void*), void*`d) const;
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)(T*,void*), void* d) const; 
bool
contains(bool (*fn)(const T*,void*), void* d) const;
T*const*
data() const; 
iterator
end();
const_iterator
end() const;
size_type
entries();
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;
size_type
length() 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;
void
prepend(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
removeAll(const T* 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,T* newVal);
void
resize(size_type n); 
void
sort();
vector<T*,allocator>&
std();
const vector<T*,allocator>&
std() const;

Static Public Data Member

const size_type  npos;

Related Global Operators

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


Previous fileTop of documentContentsIndexNext file
©Copyright 1999, Rogue Wave Software, Inc.
Send mail to report errors or comment on the documentation.