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

RWTPtrMultiMap<K,T,C,A>

Module:  Essential Tools Module   Group:  STL-based Collection


Does not inherit

Local Index

Members

Non-Members

Synopsis

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

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

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,A> may contain multiple keys that compare equal to each other. (RWTPtrMap<K,T,C,A> 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

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.

Program Output:

Related Classes

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

Class multimap<K*,T*,deref_compare<C,K,A>> 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,A>
                       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,A>(const container_comp&
     comp =container_comp());
RWTPtrMultiMap<K,T,C,A>(const container_type& m);
RWTPtrMultiMap<K,T,C,A>(const RWTPtrMultiMap<K,T,C,A>& rwm);
RWTPtrMultiMap<K,T,C,A>(value_type* first,value_type* last,
   const container_comp& comp = container_comp());

Public Member Operators

RWTPtrMultiMap<K,T,C,A>&
operator=(const container_type& m);
RWTPtrMultiMap<K,T,C,A>&
operator=(const RWTPtrMultiMap<K,T,C,A>& m);
bool
operator<(const RWTPtrMultiMap<K,T,C,A>& m); 
bool
operator==(const RWTPtrMultiMap<K,T,C,A>& 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; 
const K*
minElement() const;
const K*
maxElement() 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,A>& coll);
RWFile&
operator<<(RWFile& strm, 
       const RWTPtrMultiMap<K,T,C,A>& coll);
RWvistream&
operator>>(RWvistream& strm, RWTPtrMultiMap<K,T,C,A>& coll); 
RWFile&
operator>>(RWFile& strm, RWTPtrMultiMap<K,T,C,A>& coll);
RWvistream&
operator>>(RWvistream& strm, RWTPtrMultiMap<K,T,C,A>*& p);
RWFile&
operator>>(RWFile& strm, RWTPtrMultiMap<K,T,C,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.