Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

ACE_Array_Map< Key, Value, EqualTo > Class Template Reference

Light weight array-based map with fast iteration, but linear (i.e. O(n)) search times. More...

#include <Array_Map.h>

List of all members.

Public Types

typedef Key key_type
typedef Value data_type
typedef std::pair< key_type,
data_type > 		value_type
typedef value_type * iterator
typedef value_type const * const_iterator
typedef value_type & reference
typedef value_type const & const_reference
typedef value_type * pointer
typedef value_type const * const_pointer
typedef ptrdiff_t difference_type
typedef size_t size_type
typedef std::reverse_iterator<
iterator > 		reverse_iterator
typedef std::reverse_iterator<
const_iterator > 		const_reverse_iterator

Public Member Functions

 ACE_Array_Map (size_type s=0)
 Default Constructor.

template<typename InputIterator>  ACE_Array_Map (InputIterator f, InputIterator l)
 ACE_Array_Map (ACE_Array_Map const &map)
ACE_Array_Map & operator= (ACE_Array_Map const &map)
 ~ACE_Array_Map (void)
 Destructor.

size_type size (void) const
 Return current size of map.

size_type max_size (void) const
 Maximum number of elements the map can hold.

bool is_empty (void) const
 Return true if the map is empty, else false.

bool empty (void) const
void swap (ACE_Array_Map &map)
std::pair< iterator, bool > insert (value_type const &x)
 Insert the value x into the map.

template<typename InputIterator> void insert (InputIterator f, InputIterator l)
 Insert range of elements into map.

void erase (iterator pos)
 Remove element at position pos from the map.

size_type erase (key_type const &k)
 Remove element corresponding to key k from the map.

void erase (iterator first, iterator last)
 Remove range of elements [first, last) from the map.

void clear (void)
 Clear contents of map.

size_type count (key_type const &k)
 Count the number of elements corresponding to key k.

data_type & operator[] (key_type const &k)
 Convenience array index operator.

Forward Iterator Accessors
Forward iterator accessors.

iterator begin (void)
iterator end (void)
const_iterator begin (void) const
const_iterator end (void) const
Reverse Iterator Accessors
Reverse iterator accessors.

reverse_iterator rbegin (void)
reverse_iterator rend (void)
const_reverse_iterator rbegin (void) const
const_reverse_iterator rend (void) const
Search Operations
Search the map for data corresponding to key k.

iterator find (key_type const &k)
const_iterator find (key_type const &k) const

Private Member Functions

void grow (size_type s)
 Increase size of underlying buffer by s.


Private Attributes

size_type size_
 Number of elements in the map.

size_type capacity_
 Current size of underlying array.

value_type * nodes_
 Underlying array containing keys and data.

Detailed Description

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
class ACE_Array_Map< Key, Value, EqualTo >

Light weight array-based map with fast iteration, but linear (i.e. O(n)) search times.

Map implementation that focuses on small footprint and fast iteration. Search times are, however, linear (O(n)) meaning that this map isn't suitable for large data sets that will be searched in performance critical areas of code. Iteration over large data sets, however, is faster than linked list-based maps, for example, since spatial locality is maximized through the use of contiguous arrays as the underlying storage.

An ACE_Array_Map is a unique associative container, meaning that duplicate values may not be added to the map. It is also pair associative (value_type is a std::pair<>). It is not a sorted container.
An STL std::map -like interface is exposed by this class portability. Furthermore, this map's iterators are compatible with STL algorithms.
Requirements and Performance Characteristics

Definition at line 88 of file Array_Map.h.

Member Typedef Documentation

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef value_type const* ACE_Array_Map< Key, Value, EqualTo >::const_iterator
 

Definition at line 97 of file Array_Map.h.

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef value_type const* ACE_Array_Map< Key, Value, EqualTo >::const_pointer
 

Definition at line 101 of file Array_Map.h.

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef value_type const& ACE_Array_Map< Key, Value, EqualTo >::const_reference
 

Definition at line 99 of file Array_Map.h.

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef std::reverse_iterator<const_iterator> ACE_Array_Map< Key, Value, EqualTo >::const_reverse_iterator
 

Definition at line 129 of file Array_Map.h.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::rbegin(), and ACE_Array_Map< Key, Value, EqualTo >::rend().

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef Value ACE_Array_Map< Key, Value, EqualTo >::data_type
 

Definition at line 94 of file Array_Map.h.

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef ptrdiff_t ACE_Array_Map< Key, Value, EqualTo >::difference_type
 

Definition at line 102 of file Array_Map.h.

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef value_type* ACE_Array_Map< Key, Value, EqualTo >::iterator
 

Definition at line 96 of file Array_Map.h.

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef Key ACE_Array_Map< Key, Value, EqualTo >::key_type
 

Definition at line 93 of file Array_Map.h.

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef value_type* ACE_Array_Map< Key, Value, EqualTo >::pointer
 

Definition at line 100 of file Array_Map.h.

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef value_type& ACE_Array_Map< Key, Value, EqualTo >::reference
 

Definition at line 98 of file Array_Map.h.

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef std::reverse_iterator<iterator> ACE_Array_Map< Key, Value, EqualTo >::reverse_iterator
 

Definition at line 128 of file Array_Map.h.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::rbegin(), and ACE_Array_Map< Key, Value, EqualTo >::rend().

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef size_t ACE_Array_Map< Key, Value, EqualTo >::size_type
 

Definition at line 103 of file Array_Map.h.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::ACE_Array_Map(), ACE_Array_Map< Key, Value, EqualTo >::grow(), and ACE_Array_Map< Key, Value, EqualTo >::max_size().

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
typedef std::pair<key_type, data_type> ACE_Array_Map< Key, Value, EqualTo >::value_type
 

Definition at line 95 of file Array_Map.h.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::ACE_Array_Map(), ACE_Array_Map< Key, Value, EqualTo >::erase(), and ACE_Array_Map< Key, Value, EqualTo >::max_size().

Constructor & Destructor Documentation

template<typename Key, typename Value, class EqualTo>
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_Array_Map< Key, Value, EqualTo >::ACE_Array_Map (  size_type  s = 0  ) 
 

Default Constructor.

Create an empty map with a preallocated buffer of size s.

Definition at line 9 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::size_type, and ACE_Array_Map< Key, Value, EqualTo >::value_type. 

00011   : size_ (0)
00012   , capacity_ (s)
00013   , nodes_ (s == 0 ? 0 : new value_type[s])
00014 {
00015 }

template<typename Key, typename Value, class EqualTo>
template<typename InputIterator>
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Array_Map< Key, Value, EqualTo >::ACE_Array_Map (  InputIterator  f,
InputIterator  l
) 
 

Definition at line 19 of file Array_Map.cpp.

References ACE_Array_Map< Key, Value, EqualTo >::value_type. 

00021   : size_ (l - f)
00022   , capacity_ (size_)
00023   , nodes_ (size_ == 0 ? 0 : new value_type[size_])
00024 {
00025   (void) std::copy (f, l, this->begin ());
00026 
00027 //   iterator n = this->begin ();
00028 
00029 //   for (InputIterator i = f; i != l; ++i, ++n)
00030 //     *n = *i;
00031 }

template<typename Key, typename Value, class EqualTo>
ACE_Array_Map< Key, Value, EqualTo >::ACE_Array_Map (  ACE_Array_Map< Key, Value, EqualTo > const &  map  ) 
 

Definition at line 51 of file Array_Map.cpp.

References ACE_Array_Map< Key, Value, EqualTo >::begin(), ACE_Array_Map< Key, Value, EqualTo >::end(), and ACE_Array_Map< Key, Value, EqualTo >::value_type. 

00053   : size_ (map.size_)
00054   , capacity_ (map.size_)
00055   , nodes_ (size_ == 0 ? 0 : new value_type[size_])
00056 {
00057   std::copy (map.begin (), map.end (), this->begin ());
00058 
00059 //   iterator f = map.begin ();
00060 //   iterator l = map.end ();
00061 //   iterator n = this->begin ();
00062 
00063 //   for (iterator i = f; i != l; ++i, ++n)
00064 //     *n = *i;
00065 }

template<typename Key, typename Value, class EqualTo>
ACE_Array_Map< Key, Value, EqualTo >::~ACE_Array_Map (  void   ) 
 

Destructor.

Definition at line 68 of file Array_Map.cpp.

References ACE_Array_Map< Key, Value, EqualTo >::nodes_. 

00069 {
00070   delete[] this->nodes_;
00071 }

Member Function Documentation

template<typename Key, typename Value, class EqualTo>
ACE_INLINE ACE_Array_Map< Key, Value, EqualTo >::const_iterator ACE_Array_Map< Key, Value, EqualTo >::begin (  void   )  const
 

Definition at line 45 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::nodes_. 

00046 {
00047   return this->nodes_;
00048 }

template<typename Key, typename Value, class EqualTo>
ACE_INLINE ACE_Array_Map< Key, Value, EqualTo >::iterator ACE_Array_Map< Key, Value, EqualTo >::begin (  void   ) 
 

Definition at line 31 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::nodes_.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::ACE_Array_Map(), ACE_Array_Map< Key, Value, EqualTo >::erase(), ACE_Array_Map< Key, Value, EqualTo >::grow(), and operator==(). 

00032 {
00033   return this->nodes_;
00034 }

template<typename Key, typename Value, class EqualTo>
void ACE_Array_Map< Key, Value, EqualTo >::clear (  void   ) 
 

Clear contents of map.

Note:
This a constant time (O(1)) operation.

Definition at line 194 of file Array_Map.cpp.

References ACE_Array_Map< Key, Value, EqualTo >::size_. 

00195 {
00196   this->size_ = 0;  // No need to deallocate array nor destroy elements.
00197 }

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
size_type ACE_Array_Map< Key, Value, EqualTo >::count (  key_type const &  k  ) 
 

Count the number of elements corresponding to key k.

Returns:
In the case of this map, the count will always be one if such exists in the map.

template<typename Key, typename Value, class EqualTo>
ACE_INLINE bool ACE_Array_Map< Key, Value, EqualTo >::empty (  void   )  const
 

Return true if the map is empty, else false. We recommend using is_empty() instead since it's more consistent with the ACE container naming conventions.

Definition at line 110 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::is_empty(). 

00111 {
00112   return this->is_empty ();
00113 }

template<typename Key, typename Value, class EqualTo>
ACE_INLINE ACE_Array_Map< Key, Value, EqualTo >::const_iterator ACE_Array_Map< Key, Value, EqualTo >::end (  void   )  const
 

Definition at line 52 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::nodes_, and ACE_Array_Map< Key, Value, EqualTo >::size_. 

00053 {
00054   return this->nodes_ + this->size_;
00055 }

template<typename Key, typename Value, class EqualTo>
ACE_INLINE ACE_Array_Map< Key, Value, EqualTo >::iterator ACE_Array_Map< Key, Value, EqualTo >::end (  void   ) 
 

Definition at line 38 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::nodes_, and ACE_Array_Map< Key, Value, EqualTo >::size_.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::ACE_Array_Map(), ACE_Array_Map< Key, Value, EqualTo >::erase(), ACE_Array_Map< Key, Value, EqualTo >::grow(), and operator==(). 

00039 {
00040   return this->nodes_ + this->size_;
00041 }

template<typename Key, typename Value, class EqualTo>
void ACE_Array_Map< Key, Value, EqualTo >::erase (  iterator  first,
iterator  last
) 
 

Remove range of elements [first, last) from the map.

Note:
[first, last) must be valid range within the map.

Definition at line 183 of file Array_Map.cpp.

References ACE_Array_Map< Key, Value, EqualTo >::begin(), ACE_Array_Map< Key, Value, EqualTo >::end(), and ACE_Array_Map< Key, Value, EqualTo >::erase(). 

00186 {
00187   if (this->begin () <= first && first < last && last < this->end ())
00188     for (iterator i = first; i != last; ++i)
00189       this->erase (i);
00190 }

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
size_type ACE_Array_Map< Key, Value, EqualTo >::erase (  key_type const &  k  ) 
 

Remove element corresponding to key k from the map.

Returns:
Number of elements that were erased.

template<typename Key, typename Value, class EqualTo>
void ACE_Array_Map< Key, Value, EqualTo >::erase (  iterator  pos  ) 
 

Remove element at position pos from the map.

Definition at line 142 of file Array_Map.cpp.

References ACE_Array_Map< Key, Value, EqualTo >::begin(), ACE_Array_Map< Key, Value, EqualTo >::end(), ACE_Array_Map< Key, Value, EqualTo >::size_, and ACE_Array_Map< Key, Value, EqualTo >::value_type.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::erase(). 

00144 {
00145   iterator const first = this->begin ();
00146   iterator const last = this->end ();
00147 
00148   if (pos >= first && pos < last)
00149     {
00150       if (pos != last - 1)
00151         {
00152           // Relocate the tail element to the location of the erased
00153           // element to prevent introduction of "holes" in the
00154           // underlying array.
00155           *pos = *(last - 1);
00156         }
00157 
00158       // Explicitly destroy the tail element by assigning a default
00159       // constructed instance to it.  Note that this also works for
00160       // the case of a map of size 1.
00161       *(last - 1) = value_type ();
00162 
00163       --this->size_;
00164     }
00165 }

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
const_iterator ACE_Array_Map< Key, Value, EqualTo >::find (  key_type const &  k  )  const
 

Returns:
end() if data corresponding to key k is not in the map.

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
iterator ACE_Array_Map< Key, Value, EqualTo >::find (  key_type const &  k  ) 
 

Returns:
end() if data corresponding to key k is not in the map.

template<typename Key, typename Value, class EqualTo>
void ACE_Array_Map< Key, Value, EqualTo >::grow (  size_type  s  )  [private]
 

Increase size of underlying buffer by s.

Definition at line 233 of file Array_Map.cpp.

References ACE_Array_Map< Key, Value, EqualTo >::begin(), ACE_Array_Map< Key, Value, EqualTo >::capacity_, ACE_Array_Map< Key, Value, EqualTo >::end(), ACE_Array_Map< Key, Value, EqualTo >::size(), ACE_Array_Map< Key, Value, EqualTo >::size_, ACE_Array_Map< Key, Value, EqualTo >::size_type, and ACE_Array_Map< Key, Value, EqualTo >::swap().

Referenced by ACE_Array_Map< Key, Value, EqualTo >::insert(). 

00235 {
00236   if (this->size () + s > this->capacity_)
00237     {
00238       // This implementation focuses more on static footprint than
00239       // speed.
00240 
00241       // Strongly exception safe.
00242 
00243       ACE_Array_Map<Key, Value, EqualTo> temp (this->size () + s);
00244 
00245       std::copy (this->begin (), this->end (), temp.begin ());
00246 
00247       size_type const n = this->size ();  // Do not swap out the size
00248                                           // since we bypassed the
00249                                           // temporary map's element
00250                                           // counting code.
00251       this->swap (temp);
00252 
00253       this->size_ = n;
00254     }
00255 }

template<typename Key, typename Value, class EqualTo>
template<typename InputIterator>
void ACE_Array_Map< Key, Value, EqualTo >::insert (  InputIterator  f,
InputIterator  l
) 
 

Insert range of elements into map.

Definition at line 115 of file Array_Map.cpp.

References ACE_Array_Map< Key, Value, EqualTo >::grow(), and ACE_Array_Map< Key, Value, EqualTo >::insert(). 

00116 {
00117   this->grow (l - f);  // Preallocate storage.
00118 
00119   for (InputIterator i = f; i != l; ++i)
00120     {
00121       (void) this->insert (*i);
00122     }
00123 }

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
std::pair<iterator, bool> ACE_Array_Map< Key, Value, EqualTo >::insert (  value_type const &  x  ) 
 

Insert the value x into the map.

STL-style map insertion method.

Parameters:
x std::pair containing key and datum.
Returns:
std::pair::second will be false if the map already contains a value with the same key as x.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::insert().

template<typename Key, typename Value, class EqualTo>
ACE_INLINE bool ACE_Array_Map< Key, Value, EqualTo >::is_empty (  void   )  const
 

Return true if the map is empty, else false.

Definition at line 101 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::size_.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::empty(). 

00102 {
00103   return this->size_ == 0;
00104 }

template<typename Key, typename Value, class EqualTo>
ACE_INLINE ACE_Array_Map< Key, Value, EqualTo >::size_type ACE_Array_Map< Key, Value, EqualTo >::max_size (  void   )  const
 

Maximum number of elements the map can hold.

Definition at line 94 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::size_type, and ACE_Array_Map< Key, Value, EqualTo >::value_type. 

00095 {
00096   return size_type (-1) / sizeof (value_type);
00097 }

template<typename Key, typename Value, class EqualTo>
ACE_INLINE ACE_Array_Map< Key, Value, EqualTo > & ACE_Array_Map< Key, Value, EqualTo >::operator= (  ACE_Array_Map< Key, Value, EqualTo > const &  map  ) 
 

Definition at line 19 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::swap(). 

00021 {
00022   // Strongly exception-safe assignment.
00023 
00024   ACE_Array_Map<Key, Value, EqualTo> temp (map);
00025   this->swap (temp);
00026   return *this;
00027 }

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
data_type& ACE_Array_Map< Key, Value, EqualTo >::operator[] (  key_type const &  k  ) 
 

Convenience array index operator.

Array index operator that allows insertion and retrieval of elements using an array index syntax, such as:

map["Foo"] = 12;

template<typename Key, typename Value, class EqualTo>
ACE_INLINE ACE_Array_Map< Key, Value, EqualTo >::const_reverse_iterator ACE_Array_Map< Key, Value, EqualTo >::rbegin (  void   )  const
 

Definition at line 73 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::const_reverse_iterator. 

00074 {
00075   return const_reverse_iterator (this->end ());
00076 }

template<typename Key, typename Value, class EqualTo>
ACE_INLINE ACE_Array_Map< Key, Value, EqualTo >::reverse_iterator ACE_Array_Map< Key, Value, EqualTo >::rbegin (  void   ) 
 

Definition at line 59 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::reverse_iterator. 

00060 {
00061   return reverse_iterator (this->end ());
00062 }

template<typename Key, typename Value, class EqualTo>
ACE_INLINE ACE_Array_Map< Key, Value, EqualTo >::const_reverse_iterator ACE_Array_Map< Key, Value, EqualTo >::rend (  void   )  const
 

Definition at line 80 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::const_reverse_iterator. 

00081 {
00082   return const_reverse_iterator (this->begin ());
00083 }

template<typename Key, typename Value, class EqualTo>
ACE_INLINE ACE_Array_Map< Key, Value, EqualTo >::reverse_iterator ACE_Array_Map< Key, Value, EqualTo >::rend (  void   ) 
 

Definition at line 66 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::reverse_iterator. 

00067 {
00068   return reverse_iterator (this->begin ());
00069 }

template<typename Key, typename Value, class EqualTo>
ACE_INLINE ACE_Array_Map< Key, Value, EqualTo >::size_type ACE_Array_Map< Key, Value, EqualTo >::size (  void   )  const
 

Return current size of map.

Returns:
The number of elements in the map.

Definition at line 87 of file Array_Map.inl.

References ACE_Array_Map< Key, Value, EqualTo >::size_.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::grow(), and operator==(). 

00088 {
00089   return this->size_;
00090 }

template<typename Key, typename Value, class EqualTo>
void ACE_Array_Map< Key, Value, EqualTo >::swap (  ACE_Array_Map< Key, Value, EqualTo > &  map  ) 
 

Swap the contents of this map with the given map in an exception-safe manner.

Definition at line 75 of file Array_Map.cpp.

References ACE_Array_Map< Key, Value, EqualTo >::capacity_, ACE_Array_Map< Key, Value, EqualTo >::nodes_, and ACE_Array_Map< Key, Value, EqualTo >::size_.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::grow(), and ACE_Array_Map< Key, Value, EqualTo >::operator=(). 

00077 {
00078   std::swap (this->size_, map.size_);
00079   std::swap (this->capacity_, map.capacity_);
00080   std::swap (this->nodes_, map.nodes_);
00081 }

Member Data Documentation

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
size_type ACE_Array_Map< Key, Value, EqualTo >::capacity_ [private]
 

Current size of underlying array.

Note:
capacity_ is always greater than or equal to size_;

Definition at line 288 of file Array_Map.h.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::grow(), and ACE_Array_Map< Key, Value, EqualTo >::swap().

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
value_type* ACE_Array_Map< Key, Value, EqualTo >::nodes_ [private]
 

Underlying array containing keys and data.

Definition at line 291 of file Array_Map.h.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::begin(), ACE_Array_Map< Key, Value, EqualTo >::end(), ACE_Array_Map< Key, Value, EqualTo >::swap(), and ACE_Array_Map< Key, Value, EqualTo >::~ACE_Array_Map().

template<typename Key, typename Value, class EqualTo = std::equal_to<Key>>
size_type ACE_Array_Map< Key, Value, EqualTo >::size_ [private]
 

Number of elements in the map.

Definition at line 282 of file Array_Map.h.

Referenced by ACE_Array_Map< Key, Value, EqualTo >::clear(), ACE_Array_Map< Key, Value, EqualTo >::end(), ACE_Array_Map< Key, Value, EqualTo >::erase(), ACE_Array_Map< Key, Value, EqualTo >::grow(), ACE_Array_Map< Key, Value, EqualTo >::is_empty(), ACE_Array_Map< Key, Value, EqualTo >::size(), and ACE_Array_Map< Key, Value, EqualTo >::swap().

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 11:19:14 2006 for ACE by doxygen 1.3.6