Real Time Battle: List< T > Class Template Reference

00035   : list_head(new ListNode<T>), responsible_for_deletion(resp)
00036 {
00037 }

00041 {
00042   delete_list();     // delete the actual list
00043   delete list_head;  // delet the header node
00044 }

00049 {
00050   ListNode<T>*  p = list_head->next;  // keep the header node
00051   ListNode<T>*  temp;  
00052 
00053   while ( p != NULL )
00054     {
00055       temp = p->next;
00056       if( responsible_for_deletion && p->element ) delete p->element;
00057       delete p;
00058       p = temp;
00059     }
00060   
00061   list_head->next = NULL;
00062   list_head->prev = NULL;
00063 }

00128 {
00129   for( first(li); li.ok(); li++ )
00130     {
00131       if ( li() == x )
00132         {
00133           return true;
00134         }
00135     }
00136 
00137   return false; 
00138 }

00072 { li.listp = list_head->next; };

00096 {
00097   ListNode<T>*  p;
00098   int index = 1;
00099 
00100   if( n < 1 ) Error(true, "n < 1", "List::get_nth");
00101 
00102   for( p=list_head->next; p != NULL && index < n; p=p->next ) index++;
00103     
00104   if( p == NULL ) Error(true, "No such element", "List::get_nth");
00105 
00106   return p->element;
00107 }

00202 {
00203   ListNode<T>*  p = new ListNode<T>(x, list_head->next, NULL);
00204 
00205   if( p == NULL ) Error(true, "Out of memory", "List::insert_first");
00206 
00207   if( list_head->next == NULL ) list_head->prev = p;
00208   if( p->next ) p->next->prev = p;
00209   list_head->next = p;
00210 }

00215 {
00216   ListNode<T>*  p = new ListNode<T>(x, NULL, list_head->prev);
00217 
00218   if( p == NULL ) Error(true, "Out of memory", "List::insert_last");
00219 
00220   if( list_head->prev == NULL ) list_head->next = p;
00221   if( p->prev ) p->prev->next = p;
00222   list_head->prev = p;
00223 }

00067 { return list_head->next == NULL; }

00073 { li.listp = list_head->prev; };

00144 {
00145   ListNode<T>* p;
00146   int index=0;
00147 
00148   for( p=list_head->next; p != NULL; p=p->next ) index++;
00149 
00150   return(index);
00151 }

00072 {
00073   if( this == &old ) return *this; // don't copy yourself!
00074   
00075   if( list_head != NULL )
00076     delete_list();  // delete all nodes but the header node. 
00077   else
00078     list_head = new ListNode<T>;
00079 
00080 
00081   ListNode<T>* p;
00082 
00083   for( p=old.list_head->next; p != NULL; p=p->next )
00084     insert_last(p->element);
00085 
00086   return *this;
00087 }

00113 {
00114   ListNode<T>*  p;
00115 
00116   for( p=list_head->next; p != NULL; p=p->next );
00117     //    os << *(p->element) << " ";
00118 }

00187 {
00188   ListIterator<T> li;
00189   if ( find(x, li) )
00190     {
00191       remove(li);
00192       return true;
00193     }
00194   
00195   return false;
00196 }

00158 {
00159   if( li.listp == NULL ) Error(true, "Nothing to remove", "List::remove");
00160 
00161   ListNode<T>* current_pos = li.listp;
00162 
00163   if( current_pos->prev )
00164     {
00165       current_pos->prev->next = current_pos->next;
00166       li.listp = current_pos->prev;
00167     }
00168   else
00169     {
00170       list_head->next = current_pos->next;
00171       li.listp = list_head;
00172     }
00173 
00174   if( current_pos->next )
00175     current_pos->next->prev = current_pos->prev;
00176   else
00177     list_head->prev = current_pos->prev;
00178   
00179   if( responsible_for_deletion && current_pos->element ) delete current_pos->element;
00180   delete current_pos;
00181 }


Public Member Functions
	List (const bool resp=true)
	~List ()
const List &	operator= (const List &)
void	print_list (ostream &) const
bool	is_empty () const
bool	find (const T *, ListIterator< T > &)
T *	get_nth (const int n) const
int	number_of_elements () const
void	first (ListIterator< T > &li) const
void	last (ListIterator< T > &li) const
void	remove (ListIterator< T > &)
bool	remove (const T *)
void	insert_first (T *)
void	insert_last (T *)
void	delete_list ()
void	set_deletion_responsibility (const bool r)
Private Attributes
ListNode< T > *	list_head
bool	responsible_for_deletion

List< T > Class Template Reference

Public Member Functions

Private Attributes

template<class T>
class List< T >

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation

List< T > Class Template Reference

Public Member Functions

Private Attributes

template<class T> class List< T >

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation

template<class T>
class List< T >