Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

ACE_Intrusive_List Class Template Reference

Implement an intrusive double linked list. More...

#include <Intrusive_List.h>

Collaboration diagram for ACE_Intrusive_List:

Collaboration graph
[legend]
List of all members.

Public Methods

 ACE_Intrusive_List (void)
 Constructor. Use user specified allocation strategy if specified. More...

 ~ACE_Intrusive_List (void)
 Destructor. More...

int empty (void) const
 Returns 1 if the container is empty, otherwise returns 0. More...

void push_front (T *node)
 Insert an element at the beginning of the list. More...

void push_back (T *node)
 Insert an element at the end of the list. More...

T * pop_front (void)
 Remove the element at the beginning of the list. More...

T * pop_back (void)
 Remove the element at the end of the list. More...

T * head (void) const
 Get the element at the head of the queue. More...

T * tail (void) const
 Get the element at the tail of the queue. More...

void remove (T *node)
 Remove a element from the list. More...


Private Methods

void remove_i (T *node)
 Remove a element from the list. More...

Disallow copying
 ACE_Intrusive_List (const ACE_Intrusive_List< T > &)
ACE_Intrusive_List< T > & operator= (const ACE_Intrusive_List< T > &)

Private Attributes

T * head_
 Head of the list. More...

T * tail_
 Tail of the list. More...


Detailed Description

template<class T>
class ACE_Intrusive_List< T >

Implement an intrusive double linked list.

Intrusive lists assume that the elements they contain the pointers required to build the list. They are useful as light-weight containers and free-lists.

The template argument T must implement the following methods:

A simple way to satisfy the Intrusive_List requirements would be to implement a helper class:

class My_Object : public ACE_Intrusive_List_Node<My_Object> {
....
};

typedef ACE_Intrusive_List<My_Object> My_Object_List;

However, ACE is supported on platforms that would surely get confused using such templates.

Todo:
The ACE_Message_Queue is an example of an intrusive list (or queue) but it is not implemented in terms of this class.

Definition at line 56 of file Intrusive_List.h.


Constructor & Destructor Documentation

template<class T>
ACE_Intrusive_List< T >::ACE_Intrusive_List void   
 

Constructor. Use user specified allocation strategy if specified.

Definition at line 19 of file Intrusive_List.cpp.

00020   : head_ (0)
00021   , tail_ (0)
00022 {
00023 }

template<class T>
ACE_Intrusive_List< T >::~ACE_Intrusive_List void   
 

Destructor.

Definition at line 26 of file Intrusive_List.cpp.

00027 {
00028 }

template<class T>
ACE_Intrusive_List< T >::ACE_Intrusive_List const ACE_Intrusive_List< T > &    [private]
 


Member Function Documentation

template<class T>
ACE_INLINE int ACE_Intrusive_List< T >::empty void    const
 

Returns 1 if the container is empty, otherwise returns 0.

Definition at line 4 of file Intrusive_List.inl.

References head_.

00005 {
00006   return this->head_ == 0;
00007 }

template<class T>
ACE_INLINE T * ACE_Intrusive_List< T >::head void    const
 

Get the element at the head of the queue.

Definition at line 10 of file Intrusive_List.inl.

References head_.

00011 {
00012   return this->head_;
00013 }

template<class T>
ACE_Intrusive_List<T>& ACE_Intrusive_List< T >::operator= const ACE_Intrusive_List< T > &    [private]
 

template<class T>
T * ACE_Intrusive_List< T >::pop_back void   
 

Remove the element at the end of the list.

Definition at line 77 of file Intrusive_List.cpp.

References remove_i, and tail_.

00078 {
00079   T *node = this->tail_;
00080   if (node == 0)
00081     return 0;
00082   this->remove_i (node);
00083   return node;
00084 }

template<class T>
T * ACE_Intrusive_List< T >::pop_front void   
 

Remove the element at the beginning of the list.

Definition at line 67 of file Intrusive_List.cpp.

References head_, and remove_i.

00068 {
00069   T *node = this->head_;
00070   if (node == 0)
00071     return 0;
00072   this->remove_i (node);
00073   return node;
00074 }

template<class T>
void ACE_Intrusive_List< T >::push_back T *    node
 

Insert an element at the end of the list.

Definition at line 31 of file Intrusive_List.cpp.

References head_, and tail_.

00032 {
00033   if (this->tail_ == 0)
00034     {
00035       this->tail_ = node;
00036       this->head_ = node;
00037       node->next (0);
00038       node->prev (0);
00039       return;
00040     }
00041 
00042   this->tail_->next (node);
00043   node->prev (this->tail_);
00044   node->next (0);
00045   this->tail_ = node;
00046 }

template<class T>
void ACE_Intrusive_List< T >::push_front T *    node
 

Insert an element at the beginning of the list.

Definition at line 49 of file Intrusive_List.cpp.

References head_, and tail_.

00050 {
00051   if (this->head_ == 0)
00052     {
00053       this->tail_ = node;
00054       this->head_ = node;
00055       node->next (0);
00056       node->prev (0);
00057       return;
00058     }
00059 
00060   this->head_->prev (node);
00061   node->next (this->head_);
00062   node->prev (0);
00063   this->head_ = node;
00064 }

template<class T>
void ACE_Intrusive_List< T >::remove T *    node
 

Remove a element from the list.

Verify that the element is still in the list before removing it.

Definition at line 87 of file Intrusive_List.cpp.

References head_, and remove_i.

00088 {
00089   for (T *i = this->head_; i != 0; i = i->next ())
00090     {
00091       if (node == i)
00092         {
00093           this->remove_i (node);
00094           return;
00095         }
00096     }
00097 }

template<class T>
void ACE_Intrusive_List< T >::remove_i T *    node [private]
 

Remove a element from the list.

No attempts are performed to check if T* really belongs to the list. The effects of removing an invalid element are unspecified

Definition at line 100 of file Intrusive_List.cpp.

References head_, and tail_.

Referenced by pop_back, pop_front, and remove.

00101 {
00102   if (node->prev () != 0)
00103     node->prev ()->next (node->next ());
00104   else
00105     this->head_ = node->next ();
00106 
00107   if (node->next () != 0)
00108     node->next ()->prev (node->prev ());
00109   else
00110     this->tail_ = node->prev ();
00111 
00112   node->next (0);
00113   node->prev (0);
00114 }

template<class T>
ACE_INLINE T * ACE_Intrusive_List< T >::tail void    const
 

Get the element at the tail of the queue.

Definition at line 16 of file Intrusive_List.inl.

References tail_.

00017 {
00018   return this->tail_;
00019 }


Member Data Documentation

template<class T>
T* ACE_Intrusive_List::head_ [private]
 

Head of the list.

Definition at line 114 of file Intrusive_List.h.

Referenced by empty, head, pop_front, push_back, push_front, remove, and remove_i.

template<class T>
T* ACE_Intrusive_List::tail_ [private]
 

Tail of the list.

Definition at line 117 of file Intrusive_List.h.

Referenced by pop_back, push_back, push_front, remove_i, and tail.


The documentation for this class was generated from the following files:
Generated on Mon Jun 16 12:49:06 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002