# ACE_Ordered_MultiSet< T > Class Template Reference

Implement a simple ordered multiset of {T} of unbounded size that allows duplicates. This class template requires that < operator semantics be defined for the parameterized type {T}, but does not impose any restriction on how that ordering operator is implemented. The set is implemented as a linked list. More...

`#include <Containers_T.h>`

Collaboration diagram for ACE_Ordered_MultiSet< T >:

[legend]
List of all members.

## Public Types

typedef ACE_Ordered_MultiSet_Iterator< T > | ITERATOR

## Public Member Functions

| ACE_Ordered_MultiSet (ACE_Allocator *the_allocator=0)
| ACE_Ordered_MultiSet (const ACE_Ordered_MultiSet< T > &)
| Copy constructor.
| ~ACE_Ordered_MultiSet (void)
| Destructor.
void | operator= (const ACE_Ordered_MultiSet< T > &)
| Assignment operator.
int | is_empty (void) const
| Returns 1 if the container is empty, otherwise returns 0.
size_t | size (void) const
| Size of the set.
int | insert (const T &new_item)
int | insert (const T &new_item, ITERATOR &iter)
| Linear time insert beginning at the point specified by the provided iterator.
int | remove (const T &item)
int | find (const T &item, ITERATOR &iter) const
| Linear find operation.
void | reset (void)
| Reset the ACE_Ordered_MultiSet to be empty.
void | dump (void) const
| Dump the state of an object.

## Public Attributes

| ACE_ALLOC_HOOK_DECLARE
| Declare the dynamic allocation hooks.

## Private Member Functions

int | insert_from (const T &item, ACE_DNode< T > *start_position, ACE_DNode< T > **new_position)
int | locate (const T &item, ACE_DNode< T > *start_position, ACE_DNode< T > *&new_position) const
void | delete_nodes (void)
| Delete all the nodes in the Set.
void | copy_nodes (const ACE_Ordered_MultiSet< T > &)
| Copy nodes into this set.

## Private Attributes

ACE_DNode< T > * | head_
| Head of the bilinked list of Nodes.
ACE_DNode< T > * | tail_
| Head of the bilinked list of Nodes.
size_t | cur_size_
| Current size of the set.
ACE_Allocator * | allocator_
| Allocation strategy of the set.

## Friends

class | ACE_Ordered_MultiSet_Iterator<T>

## Detailed Description

### template<class T>
class ACE_Ordered_MultiSet< T >

Implement a simple ordered multiset of {T} of unbounded size that allows duplicates. This class template requires that < operator semantics be defined for the parameterized type {T}, but does not impose any restriction on how that ordering operator is implemented. The set is implemented as a linked list.

Requirements and Performance Characteristics

- Internal Structure Double linked list
- Duplicates allowed? Yes
- Random access allowed? No
- Search speed Linear
- Insert/replace speed Linear
- Iterator still valid after change to container? Yes
- Frees memory for removed elements? Yes
- Items inserted by Value
- Requirements for contained type
  1. Default constructor
  2. Copy constructor
  3. operator=
  4. operator==
  5. operator<

## Member Typedef Documentation

template<class T>
typedef ACE_Ordered_MultiSet_Iterator<T> ACE_Ordered_MultiSet< T >::ITERATOR

## Constructor & Destructor Documentation

template<class T>
ACE_Ordered_MultiSet< T >::ACE_Ordered_MultiSet | ( | ACE_Allocator * | the_allocator = `0` | ) |

| Initialize the set using the allocation strategy specified. If none, use the default strategy.

template<class T>
ACE_Ordered_MultiSet< T >::ACE_Ordered_MultiSet | ( | const ACE_Ordered_MultiSet< T > & |  | ) |

| Copy constructor. Initialize the set to be a copy of the provided set.

template<class T>
ACE_Ordered_MultiSet< T >::~ACE_Ordered_MultiSet | ( | void |  | ) |

| Destructor. Delete the nodes of the set.

## Member Function Documentation

template<class T>
void ACE_Ordered_MultiSet< T >::copy_nodes | ( | const ACE_Ordered_MultiSet< T > & |  | ) | `[private]`

| Copy nodes into this set.

template<class T>
void ACE_Ordered_MultiSet< T >::delete_nodes | ( | void |  | ) | `[private]`

| Delete all the nodes in the Set.

template<class T>
void ACE_Ordered_MultiSet< T >::dump | ( | void |  | ) | const

| Dump the state of an object.

template<class T>
int ACE_Ordered_MultiSet< T >::find | ( | const T & | item,
|  | ITERATOR & | iter
| ) | const

| Linear find operation. Finds first occurrence of item in the multiset, using the iterator's current position as a hint to improve performance. If find succeeds, it positions the iterator at that node and returns 0, or if it cannot locate the node, it leaves the iterator alone and just returns -1.

template<class T>
int ACE_Ordered_MultiSet< T >::insert | ( | const T & | new_item,
|  | ITERATOR & | iter
| ) |

| Linear time insert beginning at the point specified by the provided iterator. Insert new_item into the ordered multiset, starting its search at the node pointed to by the iterator, and if insertion was successful, updates the iterator to point to the newly inserted node. Returns -1 if failures occur, else 0.

template<class T>
int ACE_Ordered_MultiSet< T >::insert | ( | const T & | new_item | ) |

| Linear time, order preserving insert into the set beginning at the head.

template<class T>
int ACE_Ordered_MultiSet< T >::insert_from | ( | const T & | item,
|  | ACE_DNode< T > * | start_position,
|  | ACE_DNode< T > ** | new_position
| ) | `[private]`

| Insert item, starting its search at the position given, and if successful updates the passed pointer to point to the newly inserted item's node.

template<class T>
ACE_INLINE int ACE_Ordered_MultiSet< T >::is_empty | ( | void |  | ) | const

| Returns 1 if the container is empty, otherwise returns 0. Constant time check to determine if the set is empty.

template<class T>
int ACE_Ordered_MultiSet< T >::locate | ( | const T & | item,
|  | ACE_DNode< T > * | start_position,
|  | ACE_DNode< T > *& | new_position
| ) | const`[private]`

Looks for first occurance of item in the ordered set, using the passed starting position as a hint: if there is such an instance, it updates the new_position pointer to point to this node and returns 0; if there is no such node, then if there is a node before where the item would have been, it updates the new_position pointer to point to this node and returns -1; if there is no such node, then if there is a node after where the item would have been, it updates the new_position pointer to point to this node (or 0 if there is no such node) and returns 1;

template<class T>
void ACE_Ordered_MultiSet< T >::operator= | ( | const ACE_Ordered_MultiSet< T > & |  | ) |

| Assignment operator. Delete the nodes in lhs, and copy the nodes from the rhs.

template<class T>
int ACE_Ordered_MultiSet< T >::remove | ( | const T & | item | ) |

| Linear time search operation which removes the item from the set if found .

template<class T>
void ACE_Ordered_MultiSet< T >::reset | ( | void |  | ) |

| Reset the ACE_Ordered_MultiSet to be empty. Delete the nodes inside the set.

template<class T>
ACE_INLINE size_t ACE_Ordered_MultiSet< T >::size | ( | void |  | ) | const

| Size of the set. Constant time check to determine the size of the set.

## Friends And Related Function Documentation

template<class T>
friend class ACE_Ordered_MultiSet_Iterator<T>`[friend]`

## Member Data Documentation

template<class T>
ACE_Ordered_MultiSet< T >::ACE_ALLOC_HOOK_DECLARE

| Declare the dynamic allocation hooks.

template<class T>
ACE_Allocator* ACE_Ordered_MultiSet< T >::allocator_`[private]`

| Allocation strategy of the set.

template<class T>
size_t ACE_Ordered_MultiSet< T >::cur_size_`[private]`

| Current size of the set.

template<class T>
ACE_DNode<T>* ACE_Ordered_MultiSet< T >::head_`[private]`

| Head of the bilinked list of Nodes.

template<class T>
ACE_DNode<T>* ACE_Ordered_MultiSet< T >::tail_`[private]`

| Head of the bilinked list of Nodes.

The documentation for this class was generated from the following files:

- Containers_T.h
- Containers_T.cpp
- Containers_T.inl