Rogue Wave banner
Previous fileTop of documentContentsIndexNext file

RWTPtrMultiMap<K,T,C>

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

Synopsis

#include <rw/tpmmap.h> 
RWTPtrMultiMap<K,T,C> m;

Standard C++ Library Dependent!


RWTPtrMultiMap requires the Standard C++ Library.


Description

This class maintains a pointer-based collection of associations of type pair<K*, const T*>. The first part of the association is a key of type K*, the second is its associated item of type T*. Order is determined by the key according to a comparison object of type C. C must induce a total ordering on elements of type K via a public member

bool operator()(const K& x, const K& y)

which returns true if x and its partner should precede y and its partner within the collection. The structure less<T> from the C++-standard header file <functional> is an example. Note that keys will be dereferenced before being compared.

RWTPtrMultiMap<K,T,C> may contain multiple keys that compare equal to each other. (RWTPtrMap<K,T,C> will not accept a key that compares equal to any key already in the collection.) Equality is based on the comparison object and not on the == operator. Given a comparison object comp, keys a and b are equal if

!comp(a,b) && !comp(b,a).

The value type must have operator== and operator< defined. This requirement is imposed by the Standard C++ Library.

Persistence

Isomorphic.

Examples

In this example, a multimap of RWCStrings and RWDates is exercised.

//
// tpmmap.cpp
//
#include <rw/tpmmap.h>
#include <rw/cstring.h>
#include <rw/rwdate.h>
#include <iostream.h>

main(){
  typedef RWTPtrMultiMap<RWCString, RWDate, 
     less<RWCString> > RWMMap;
  RWMMap birthdays;
  birthdays.insert(new RWCString("John"),
                              new RWDate(12, "April", 1975));
  birthdays.insert(new RWCString("Ivan"),
                              new RWDate(2, "Nov", 1980));
  birthdays.insert(new RWCString("Mary"),
                              new RWDate(22, "Oct", 1987));
  birthdays.insert(new RWCString("Ivan"),
                              new RWDate(19, "June", 1971));
  birthdays.insert(new RWCString("Sally"),
                              new RWDate(15, "March", 1976));
  birthdays.insert(new RWCString("Ivan"),
                              new RWDate(6, "July", 1950));
  // How many "Ivan"s?
  RWCString ivanstr("Ivan");
  RWMMap::size_type n = birthdays.occurrencesOf(&ivanstr);
  RWMMap::size_type idx = 0;
  cout << "There are " << n << " Ivans:" << endl;
  RWMMap::const_iterator iter = 
                             birthdays.std().lower_bound(&ivanstr);
  while (++idx <= n) 
    cout << idx << ".  " << *(*iter++).second << endl; 
  return 0;
}

Program Output:
There are 3 Ivans:
1.  11/02/80
2.  06/19/71
3.  07/06/50

Related Classes

Class RWTPtrMap<K,T,C> offers the same interface to a pointer-based collection that will not accept multiple keys that compare equal to each other. RWTPtrMultiSet<T,C> maintains a pointer-based collection of keys without the associated values.

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

Public Typedefs

typedef rw_deref_compare<C,K>             container_comp; 
typedef multimap<K*,T*,container_comp,allocator>
                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 pair<K* const, T*>                value_type; 
typedef pair<K* const, T*>                reference; 
typedef const pair<K* const, T*>&         const_reference; 
typedef K*                                value_type_key; 
typedef T*                                value_type_data; 
typedef K*&                               reference_key; 
typedef T*&                               reference_data; 
typedef const K*const&                    const_reference_key; 
typedef const T*const&                    const_reference_data; 

Public Constructors

RWTPtrMultiMap<K,T,C>
(const container_comp& comp =container_comp());
RWTPtrMultiMap<K,T,C>(const container_type& m);
RWTPtrMultiMap<K,T,C>(const RWTPtrMultiMap<K,T,C>& rwm);
RWTPtrMultiMap<K,T,C>(value_type* first,value_type* last,
   const container_comp& comp = container_comp());

Public Member Operators

RWTPtrMultiMap<K,T,C>&
operator=(const container_type& m);
RWTPtrMultiMap<K,T,C>&
operator=(const RWTPtrMultiMap<K,T,C>& m);
bool
operator<(const RWTPtrMultiMap<K,T,C>& m); 
bool
operator==(const RWTPtrMultiMap<K,T,C>& m); 

Public Member Functions

void
apply(void (*fn)(const K*, T*&,void*),void* d); 
void
apply(void (*fn)(const K*,const T*,void*),void* d) const;
void
applyToKeyAndValue(void (*fn)(const K*, T*&,void*),void* d); 
void
applyToKeyAndValue
(void (*fn)(const K*,const T*,void*),void* d) const;
iterator
begin();
const_iterator
begin() const;
void
clear();
void
clearAndDestroy();
bool
contains(const K* key) const; 
bool
contains(bool (*fn)(value_type,void*), void* d) const;
iterator
end();
const_iterator
end() const;
size_type
entries() const; 
const K*
find(const K* key) const; 
value_type
find(bool (*fn)(value_type,void*), void* d) const;
T*
findValue(const K* key); 
const T*
findValue(const K* key) const;
const K*
findKeyAndValue(const K* key, T*& tr); 
const K*
findKeyAndValue(const K* key, const T*& tr) const;
bool
insert(K* key, T* a); 
bool
insertKeyAndValue(K* key, T* a); 
bool
isEmpty() const; 
size_type
occurrencesOf(const K* key) const; 
size_type
occurrencesOf
(bool (*fn)(value_type,void*), void* d) const;
K*
remove(const K* key); 
K*
remove(bool (*fn)(value_type,void*), void* d);
size_type
removeAll(const K* key); 
size_type
removeAll(bool (*fn)(value_type,void*), void* d);
container_type&
std();
const container_type&
std() const;

Related Global Operators

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


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