Rogue Wave banner
Previous fileTop of documentContentsIndexNext file

RWTPtrSlist<T>

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

Synopsis

#include <rw/tpslist.h> 
RWTPtrSlist<T> slist;

Please Note!


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


Description

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

Persistence

Isomorphic

Example

//
// tpsldat.cpp
//
#include <rw/tpslist.h>
#include <rw/rwdate.h>
#include <iostream.h>

main(){
  RWTPtrSlist<RWDate> dates;
  dates.insert(new RWDate(2, "June", 52));      // 6/2/52
  dates.insert(new RWDate(30, "March", 46));    // 3/30/46
  dates.insert(new RWDate(1, "April", 90));     // 4/1/90

  // Now look for one of the dates:
  RWDate * ret = dates.find(new RWDate(2,"June",52));
  if (ret){
    cout << "Found date " << ret << endl;
  }

  // Remove in reverse order:
  while (!dates.isEmpty())
    cout << *dates.removeLast() << endl;

  return 0;
}
Program Output:
Found date
4/01/90
3/30/46
6/02/52

Related Classes

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

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

Public Typedefs

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

Public Constructors

RWTPtrSlist<T>();
RWTPtrSlist<T>(const RWTPtrSlist<T>& rwlst);
RWTPtrSlist<T>(const rw_slist<T*>& lst);
RWTPtrSlist<T>(size_type n, const T* a=0);
RWTPtrSlist<T>(T* const* first, T* const* last);

Public Member Operators

RWTPtrSlist<T>&
operator=(const RWTPtrSlist<T>& lst); 
RWTPtrSlist<T>&
operator=(const rw_slist<T*>& lst);
bool
operator<(const RWTPtrSlist<T>& lst) const; 
bool
operator==(const RWTPtrSlist<T>& lst) 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;
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;
T*
get();
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;
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
sort();
rw_slist<T*>&
std();
const rw_slist<T*>&
std() const;

Static Public Data Member

const size_type  npos;

Related Global Operators

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


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