List Class Reference

#include <list.h>

Inheritance diagram for List:

List of all members.

Public Member Functions
	List ()
	List class constructor.
virtual	~List ()
	List class destructor. NOTE that this does NOT destroy the list items - it simply delinks all items in the list and deletes the list header.
virtual ListItem *	RemoveHead ()
	RemoveHead does not as its name may suggest delete the ListItem at the head of the list. It instead removes pointers to and from the ListItem at the head of the list, in effect removing it from the list. RemoveHead returns a pointer to the ListItem 'removed'. It is the responsibility of the caller to delete the ListItem from memory.
virtual ListItem *	RemoveTail ()
	RemoveTail does not as its name may suggest delete the ListItem at the tail of the list. It instead removes pointers to and from the ListItem at the tail of the list, in effect removing it from the list. RemoveTail returns a pointer to the ListItem 'removed'. It is the responsibility of the caller to delete the ListItem from memory.
virtual void	DeleteAll ()
	Deletes the list, calling the destructors of all ListItems.
virtual void	AddHead (ListItem *)
	To insert a ListItem at the head of the list.
virtual void	AddTail (ListItem *)
	To insert a ListItem at the tail of the list.
ListItem *	GetHead () const
	To allow access to the ListItem at the head of the list.
LISTPOS	GetHeadPosition () const
	Gives the user the relative position of the head of the list.
ListItem *	GetTail () const
	To allow access to the ListItem at the tail of the list.
LISTPOS	GetTailPosition () const
	Gives the user the relative position of the tail of the list.
ListItem *	GetNext (const ListItem *) const
	To allow access to the next ListItem in the list after the one that has been passed in as input.
ListItem *	GetPrev (const ListItem *) const
	To allow access to the previous ListItem in the list before the one that has been passed in as input.
ListItem *	FindItem (LISTPOS) const
	Gives the user the ListItem at list position passed in.
LISTPOS	FindPosition (ListItem *) const
	Gives the user the relative position of the ListItem passed in.
virtual ListItem *	RemoveItem (ListItem *)
	Removes the ListItem passed in as a parameter. It is the responsibility of the caller to delete the removed ListItem from memory.
virtual LISTPOS	InsertBefore (LISTPOS here, ListItem *item)
	Inserts a ListItem in the list position before the one that is passed in. Notes: This function involves scanning the entire list until 'here' is found, so is much slower on average than the other flavour of InsertBefore.
virtual ListItem *	InsertBefore (ListItem *here, ListItem *item)
	Inserts the 'newItem' ListItem before 'here' ListItem in the list.
virtual LISTPOS	InsertAfter (LISTPOS here, ListItem *item)
	Inserts a ListItem in the list position after the one that is passed in. Notes: To find 'here', the list must be scanned, so this is much slower on average than the other flavour of InsertAfter.
virtual ListItem *	InsertAfter (ListItem *here, ListItem *item)
	Inserts the 'newItem' ListItem after 'here' ListItem in the list.
UINT32	GetCount () const
	To give user of list an indication of its size in terms of number of items.
BOOL	IsEmpty () const
	Allows user to see if list is empty or not.
BOOL	CreateIndex (List *IndexedList)
	Creates a list of in-order pointers into this list.
Private Attributes
ListItem *	HeadItem
ListItem *	TailItem
UINT32	ItemCount

---

Detailed Description

Definition at line 159 of file list.h.

---

Constructor & Destructor Documentation

List::List (   )

List class constructor. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 13/4/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: None Errors: None Definition at line 148 of file list.cpp. { HeadItem = NULL; TailItem = NULL; ItemCount = 0; #ifdef _DEBUG LastItemRemoved = NULL; #endif }

List::~List (   )  [virtual]

List class destructor. NOTE that this does NOT destroy the list items - it simply delinks all items in the list and deletes the list header. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 13/4/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: None When destructing a list, you should really delete all objects from within it (by deriving a class from List with a special destructor, or calling List::DeleteAll() on it first, or some other appropriate action) before calling delete on the List header. Notes: In DEBUG builds, any non-empty lists are reported to the TRACE output, in order to encourage people to discard their used lists thoughtfully. To remove this TRACE, you must either delete (DeleteAll()) or delink (RemoveItem()) the items from the list before calling the destructor. In ALL builds, any items still in the list when it is destructed are delinked (RemoveItem()) from the list, in order to ensure their next/previous pointers remain valid. Definition at line 187 of file list.cpp. { #ifdef _DEBUG if (!IsEmpty()) { TRACE( _T("NON EMPTY LIST DELETED! Its items may appear as memory leaks on exit\n") _T("The %ld items are listed below. I have delinked them from the list\n"), (INT32) GetCount()); // Dump the contents of the list ListItem *Ptr = GetHead(); while (Ptr != NULL) { TRACE( _T(" '%s' at 0x%x\n"), Ptr->GetRuntimeClass()->GetClassName(), Ptr ); Ptr = GetNext(Ptr); } TRACE( _T("\n") ); } #endif // In all builds, if the list was deleted while non-empty, we delink all items from it // to ensure that their next/previous pointers are all NULL, rather than pointing at // possibly invalid areas of memory. This will at least mean that the items can be // safely added to other lists, without causing complete screwups. // These items will show up as memory leaks if they are not properly deleted by anyone // so we don't really need to concern ourselves with alerting the programmer too much // at this point while (!IsEmpty()) RemoveHead(); }

---

Member Function Documentation

void List::AddHead (  ListItem *  newHead  )  [virtual]

To insert a ListItem at the head of the list. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: ListItem  to be inserted [INPUTS] None  [OUTPUTS] Returns: void Errors: None. Reimplemented in ColourList. Definition at line 369 of file list.cpp. { // CC_ASSERT_VALID(this); if (this->IsEmpty()) // if list is empty { newHead->Next = NULL; // init next prev pointers newHead->Previous = NULL; HeadItem = newHead; // head & tail point to first item TailItem = newHead; } else { #ifdef _DEBUG if (ListDebugLevel > 0) { ENSURE( this->FindPosition(newHead) == NOT_IN_LIST, "AddHead: New head item is already in the list"); } #endif newHead->Next = HeadItem; // new head pointed to old head newHead->Previous = NULL; // new head previous pointer nullified HeadItem->Previous = newHead; // old head pointed back to new head HeadItem = newHead; // head pointer pointed to new head } ItemCount += 1; // increment item counter #ifdef _DEBUG if (newHead == LastItemRemoved) LastItemRemoved = NULL; #endif }

void List::AddTail (  ListItem *  newTail  )  [virtual]

To insert a ListItem at the tail of the list. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: ListItem  to be inserted [INPUTS] None  [OUTPUTS] Returns: void Errors: None. Reimplemented in ColourList. Definition at line 429 of file list.cpp. { // CC_ASSERT_VALID(this); if (this->IsEmpty()) // if list is empty { newTail->Next = NULL; // init next prev pointers newTail->Previous = NULL; HeadItem = newTail; // head & tail point to first item TailItem = newTail; } else { #ifdef _DEBUG if (ListDebugLevel > 0) { ENSURE(this->FindPosition(newTail) == NOT_IN_LIST, "AddTail: New tail item is already in the list"); } #endif newTail->Previous = TailItem; // previous points old tail newTail->Next = NULL; // next is nullified TailItem->Next = newTail; // old tail next points to new tail TailItem = newTail; // update tail pointer } ItemCount += 1; // increment item counter #ifdef _DEBUG if (newTail == LastItemRemoved) LastItemRemoved = NULL; #endif }

BOOL List::CreateIndex (  List *  ListIndex  )

Creates a list of in-order pointers into this list. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/9/95 Parameters: A  List of in-order pointers into 'this' list. Each item on the list is a [OUTPUTS] ListItemIdx. Returns: FALSE if we run out of memory. All items on the output list are deleted if this occurs. This has many uses eg. You wish to scan a list repeatedly, not wasting time considering items you are not interested in. This method avoids changing the order of the items within the list. Could be used for list sorting etc. See also: ListItemIdx Definition at line 1175 of file list.cpp. { ListItem* pi = GetHead(); // pointer to this lists item ListItemIdx* ppi; // pointer to pi while (pi) { ppi = new ListItemIdx(); if (!ppi) { ListIndex->DeleteAll(); // Tidyup return FALSE; } ppi->pItem = pi; ListIndex->AddTail(ppi); pi = GetNext(pi); } return TRUE; }

void List::DeleteAll (   )  [virtual]

Deletes the list, calling the destructors of all ListItems. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 11/2/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented in ColourList, ColourRamp, TransparencyRamp, PageRectList, and MarkedStack. Definition at line 335 of file list.cpp. { while (!IsEmpty()) { delete (RemoveTail()); } }

ListItem * List::FindItem (  LISTPOS  here  )  const

Gives the user the ListItem at list position passed in. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 21/4/93 Parameters: ListItem  [INPUTS] None  [OUTPUTS] Returns: ListItem if found NULL if not found or input is less than zero or list is empty Errors: None. Definition at line 652 of file list.cpp. { // CC_ASSERT_VALID(this); if ((this->IsEmpty()) || (here < 0)) // if list is empty return a null pointer return NULL; ListItem *listIter; // list iterator LISTPOS listCount = 0; // list iterator count listIter = HeadItem; while (listCount != here && listIter != NULL) // iterate until input List position found { listIter = listIter->Next; listCount += 1; } return listIter; }

LISTPOS List::FindPosition (  ListItem *  here  )  const

Gives the user the relative position of the ListItem passed in. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: ListItem  [INPUTS] None  [OUTPUTS] Returns: ListPosition if found NOT_IN_LIST if not found or input is NULL EMPTY_LIST if list is empty Errors: None. Definition at line 606 of file list.cpp. { // CC_ASSERT_VALID(this); if (this->IsEmpty()) // if list is empty return a null pointer return EMPTY_LIST; if (here == NULL) // if input list item is NULL return NOT_IN_LIST; ListItem *listIter; // list iterator LISTPOS listCount = 0; // list iterator count listIter = HeadItem; while (listIter != here && listIter != NULL) // iterate until input ListItem found { listIter = listIter->Next; listCount += 1; } if (listIter == NULL) return NOT_IN_LIST; else return listCount; }

UINT32 List::GetCount (  void   )  const

To give user of list an indication of its size in terms of number of items. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: Number of items in the list Errors: None Reimplemented in NewColourList. Definition at line 1117 of file list.cpp. { // CC_ASSERT_VALID(this); return ItemCount; }

ListItem * List::GetHead (   )  const

To allow access to the ListItem at the head of the list. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: ListItem if not empty NULL if empty list Errors: None. Definition at line 481 of file list.cpp. { // CC_ASSERT_VALID(this); if (this->IsEmpty()) return NULL; else return HeadItem; }

LISTPOS List::GetHeadPosition (   )  const

Gives the user the relative position of the head of the list. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: ListPosition of head EMPTY_LIST error flag Errors: None. Definition at line 541 of file list.cpp. { // CC_ASSERT_VALID(this); if (this->IsEmpty()) return EMPTY_LIST; else return 0; }

ListItem * List::GetNext (  const ListItem *  here  )  const [inline]

To allow access to the next ListItem in the list after the one that has been passed in as input. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: pointer  to ListItem [INPUTS] None  [OUTPUTS] Returns: ListItem if not empty NULL if list empty or if ListItem not found or end of list or input pointer is NULL Errors: In the debug build, if SLOW_LIST_DEBUG is enabled (see list.h), this will check that the item is valid (is in the list etc), and generate ENSURE failures if not. In all debug builds, we will still check that the list is non-empty and that the passed ListItem is non-NULL. In debug, a check is also made that you are not trying to GetNext on the last item you removed from the list, as this is a common mistake to make Definition at line 290 of file list.h. { #ifdef _DEBUG CC_ASSERT_VALID(this); ENSURE(!this->IsEmpty() && here != NULL, "List::GetNext(here) - The list is empty, or 'here' is NULL"); ENSURE(here != LastItemRemoved, "List::GetNext - Serious mistake! The item has just been removed from the list!!"); if (ListDebugLevel > 1) { ListItem *listIter; // list iterator listIter = HeadItem; while (listIter != here && listIter != NULL) // iterate until input ListItem found listIter = listIter->Next; ENSURE(listIter != NULL, "List:GetNext(here) - 'here' isn't in the list!"); } #endif return here->Next; }

ListItem * List::GetPrev (  const ListItem *  here  )  const [inline]

To allow access to the previous ListItem in the list before the one that has been passed in as input. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: pointer  to a ListItem [INPUTS] None  [OUTPUTS] Returns: ListItem if found NULL if list empty or ListItem not found or beginning of list or input pointer is NULL. Errors: In the debug build, if SLOW_LIST_DEBUG is enabled (see list.h), this will check that the item is valid (is in the list etc), and generate ENSURE failures if not. In all debug builds, we will still check that the list is non-empty and that the passed ListItem is non-NULL. In debug, a check is also made that you are not trying to GetNext on the last item you removed from the list, as this is a common mistake to make Definition at line 345 of file list.h. { #ifdef _DEBUG CC_ASSERT_VALID(this); ENSURE(!this->IsEmpty() && here != NULL, "List::GetNext(here) - The list is empty, or 'here' is NULL"); ENSURE(here != LastItemRemoved, "List::GetPrev - Serious mistake! The item has just been removed from the list!!"); if (ListDebugLevel > 1) { ListItem *listIter; // list iterator listIter = HeadItem; while (listIter != here && listIter != NULL) // iterate until input ListItem found listIter = listIter->Next; ENSURE(listIter != NULL, "List:GetPrev(here) - 'here' isn't in the list!"); } #endif return(here->Previous); }

ListItem * List::GetTail (   )  const

To allow access to the ListItem at the tail of the list. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: ListItem if not empty NULL if list empty Errors: None. Definition at line 508 of file list.cpp. { // CC_ASSERT_VALID(this); if (this->IsEmpty()) return NULL; else return TailItem; }

LISTPOS List::GetTailPosition (   )  const

Gives the user the relative position of the tail of the list. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: ListPosition of tail item EMPTY_LIST error flag Errors: None. Definition at line 577 of file list.cpp. { // CC_ASSERT_VALID(this); if (this->IsEmpty()) return EMPTY_LIST; else return (ItemCount - 1); }

ListItem * List::InsertAfter (  ListItem *  here, ListItem *  newItem )  [virtual]

Inserts the 'newItem' ListItem after 'here' ListItem in the list. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 15/4/93 Parameters: ListItem  to be inserted [INPUTS] ListItem after insertion None  [OUTPUTS] Returns: ListItem inserted NULL if list empty or ListItem not found or parameters are NULL Errors: In the debug build, this checks that the item you wish to insert after is actually in the list, and that the item you are inserting is not already in the list - an ENSURE failure results if not. Reimplemented in ColourList. Definition at line 1049 of file list.cpp. { // CC_ASSERT_VALID(this); #ifdef _DEBUG if (ListDebugLevel > 0) { if (!this->IsEmpty()) ENSURE( this->FindPosition(newItem) == NOT_IN_LIST, "InsertAfter: Item to be inserted is already in the list"); } #endif if ((this->IsEmpty()) || (here == NULL) || (newItem == NULL)) return NULL; if (here == TailItem) // if tail of list { this->AddTail(newItem); // insert after tail return newItem; } #ifdef _DEBUG if (ListDebugLevel > 0) { ListItem *listIter = HeadItem; while (listIter != here && listIter != NULL) // iterate until list position found listIter = listIter->Next; if (listIter == NULL) // list position does not exist in list { return NULL; } } #endif newItem->Previous = here; // point new item to previous one in list newItem->Next = here->Next; // point new item to next one here->Next = newItem; // point after item to new one newItem->Next->Previous = newItem; // point next item back to new one #ifdef _DEBUG if (newItem == LastItemRemoved) LastItemRemoved = NULL; #endif ItemCount += 1; // increment item counter return newItem; }

LISTPOS List::InsertAfter (  LISTPOS  here, ListItem *  newItem )  [virtual]

Inserts a ListItem in the list position after the one that is passed in. Notes: To find 'here', the list must be scanned, so this is much slower on average than the other flavour of InsertAfter. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: ListItem  to be inserted [INPUTS] List position None  [OUTPUTS] Returns: List position new item is inserted at. INVALID_LISTPOS when the list position goes beyond the list size INVALID_NEWITEM when new list item is NULL Errors: This ALWAYS checks that the item you wish to insert after is actually in the list, and that the item you are inserting is not already in the list - an ENSURE failure results if not. Reimplemented in ColourList. Definition at line 965 of file list.cpp. { // CC_ASSERT_VALID(this); #ifdef _DEBUG if (ListDebugLevel > 0) { if (!this->IsEmpty()) ENSURE( this->FindPosition(newItem) == NOT_IN_LIST, "InsertAfter: Item to be inserted is already in the list"); } #endif if ((this->IsEmpty()) && (here > 0)) return INVALID_LISTPOS; if (newItem == NULL) return INVALID_NEWITEM; if (here == this->GetTailPosition()) // if tail of list { this->AddTail(newItem); // insert after tail return this->GetTailPosition(); } ListItem *listIter; // list iterator LISTPOS listCount = GetHeadPosition(); // list iterator count listIter = HeadItem; while (listCount != here && listIter != NULL) // iterate until list position found { listIter = listIter->Next; listCount += 1; } if (listIter == NULL) // list position does not exist in list return INVALID_LISTPOS; newItem->Previous = listIter; // point new item to previous one in list newItem->Next = listIter->Next; // point new item to next one listIter->Next = newItem; // point after item to new one newItem->Next->Previous = newItem; // point next item back to new one ItemCount += 1; // increment item counter #ifdef _DEBUG if (newItem == LastItemRemoved) LastItemRemoved = NULL; #endif return (listCount + 1); }

ListItem * List::InsertBefore (  ListItem *  here, ListItem *  newItem )  [virtual]

Inserts the 'newItem' ListItem before 'here' ListItem in the list. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 15/4/93 Parameters: ListItem  to be inserted [INPUTS] ListItem before insertion None  [OUTPUTS] Returns: ListItem inserted INVALID_NEWITEM when the new item is NULL NULL if list empty or ListItem not found or parameters are NULL Errors: In the debug build, this checks that the item you wish to insert before is actually in the list, and that the item you are inserting is not already in the list - an ENSURE failure results if not. Reimplemented in ColourList. Definition at line 882 of file list.cpp. { // CC_ASSERT_VALID(this); #ifdef _DEBUG if (ListDebugLevel > 0) { if (!this->IsEmpty()) ENSURE( this->FindPosition(newItem) == NOT_IN_LIST, "InsertBefore: Item to be inserted is already in the list"); } #endif if (this->IsEmpty() || (here == NULL) || (newItem == NULL)) return NULL; if (here == HeadItem) // if head of list { this->AddHead(newItem); // insert before head return newItem; } #ifdef _DEBUG if (ListDebugLevel > 0) { ListItem *listIter; // list iterator listIter = HeadItem; while (listIter != here && listIter != NULL) // iterate until list position found listIter = listIter->Next; ENSURE (listIter != NULL, "List::InsertBefore(Here) - 'Here' does not exist!"); } #endif newItem->Next = here; // point new item to before one newItem->Previous = here->Previous; // point new item to previous one here->Previous = newItem; // point before item to new one newItem->Previous->Next = newItem; // point previous item back new one #ifdef _DEBUG if (newItem == LastItemRemoved) LastItemRemoved = NULL; #endif ItemCount += 1; // increment item counter return newItem; }

LISTPOS List::InsertBefore (  LISTPOS  here, ListItem *  newItem )  [virtual]

Inserts a ListItem in the list position before the one that is passed in. Notes: This function involves scanning the entire list until 'here' is found, so is much slower on average than the other flavour of InsertBefore. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 15/4/93 Parameters: ListItem  to be inserted [INPUTS] List position None  [OUTPUTS] Returns: List position new item is inserted at. INVALID_LISTPOS when the list position goes beyond the list size INVALID_NEWITEM when the new item is NULL Errors: This ALWAYS checks that the item you wish to insert before is actually in the list, and that the item you are inserting is not already in the list - an ENSURE failure results if not. Reimplemented in ColourList. Definition at line 798 of file list.cpp. { // CC_ASSERT_VALID(this); #ifdef _DEBUG if (ListDebugLevel > 0) { if (!this->IsEmpty()) ENSURE( this->FindPosition(newItem) == NOT_IN_LIST, "InsertBefore: Item to be inserted is already in the list"); } #endif if ((this->IsEmpty()) && (here > 0)) return INVALID_LISTPOS; if (newItem == NULL) // if input parameter is NULL return INVALID_NEWITEM; if (here == this->GetHeadPosition()) // if head of list { this->AddHead(newItem); // insert before head return this->GetHeadPosition(); } ListItem *listIter; // list iterator LISTPOS listCount = this->GetHeadPosition(); // list iterator count listIter = HeadItem; while (listCount != here && listIter != NULL) // iterate until list position found { listIter = listIter->Next; listCount += 1; } if (listIter == NULL) // list position does not exist in list return INVALID_LISTPOS; newItem->Next = listIter; // point new item to before one newItem->Previous = listIter->Previous; // point new item to previous one listIter->Previous = newItem; // point before item to new one newItem->Previous->Next = newItem; // point previous item back new one ItemCount += 1; // increment item counter #ifdef _DEBUG if (newItem == LastItemRemoved) LastItemRemoved = NULL; #endif return listCount; }

BOOL List::IsEmpty (   )  const

Allows user to see if list is empty or not. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: TRUE if list is empty FALSE if list is not empty Errors: None Definition at line 1141 of file list.cpp. { // CC_ASSERT_VALID(this); if (ItemCount == 0) return TRUE; else return FALSE; }

ListItem * List::RemoveHead (   )  [virtual]

RemoveHead does not as its name may suggest delete the ListItem at the head of the list. It instead removes pointers to and from the ListItem at the head of the list, in effect removing it from the list. RemoveHead returns a pointer to the ListItem 'removed'. It is the responsibility of the caller to delete the ListItem from memory. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 13/4/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: ListItem that was head of list NULL if list is empty Errors: None. Definition at line 242 of file list.cpp. { // CC_ASSERT_VALID(this); if (this->IsEmpty()) // if list is empty return a null pointer return NULL; ListItem *oldHead; oldHead = HeadItem; HeadItem = HeadItem->Next; // list head pointed to next item in list if (HeadItem != NULL) // if list is not empty HeadItem->Previous = NULL; // pointer to old list head must be nullified else TailItem = NULL; // tail item must be nullified ItemCount -= 1; // decrement item counter #ifdef _DEBUG LastItemRemoved = oldHead; #endif return oldHead; }

ListItem * List::RemoveItem (  ListItem *  oldItem  )  [virtual]

Removes the ListItem passed in as a parameter. It is the responsibility of the caller to delete the removed ListItem from memory. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 15/4/93 Parameters: ListItem  [INPUTS] None  [OUTPUTS] Returns: ListItem removed NULL if not found or if list empty or input is NULL Errors: In debug builds, an ENSURE is triggered if the item to be removed is not actually in the list. Definition at line 706 of file list.cpp. { // CC_ASSERT_VALID(this); #ifdef _DEBUG if (ListDebugLevel > 0) { ENSURE( this->FindPosition(oldItem) != NOT_IN_LIST, "RemoveItem: List item to be removed is not in the list"); } #endif if ((this->IsEmpty()) || // if list is empty or (oldItem == NULL)) // NULL input or return NULL; ListItem *adjacentItem; if ((oldItem->Previous) != NULL) { adjacentItem = oldItem->Previous; // point to previous item in list adjacentItem->Next = oldItem->Next; // by pass old item forwards if ((oldItem->Next) != NULL) // Remove from middle of ist { // there are items both sides adjacentItem = oldItem->Next; // point to next item in list adjacentItem->Previous = oldItem->Previous; // by pass old item backwards } else { // Removal of tail of list TailItem = adjacentItem; // new tail item } } else { // Removal of head of list if ((oldItem->Next) != NULL) { adjacentItem = oldItem->Next; // next item in list adjacentItem->Previous = NULL; // nullify prev pointer to old item HeadItem = adjacentItem; // new head item } else { HeadItem = NULL; // nullify head and tail pointers TailItem = NULL; } } ItemCount -= 1; // decrement item counter #ifdef _DEBUG LastItemRemoved = oldItem; // Check for stupidity - see GetNext/Prev #endif oldItem->Previous = NULL; // Er, we should vape the disused links oldItem->Next = NULL; // shouldn't we? return oldItem; }

ListItem * List::RemoveTail (   )  [virtual]

RemoveTail does not as its name may suggest delete the ListItem at the tail of the list. It instead removes pointers to and from the ListItem at the tail of the list, in effect removing it from the list. RemoveTail returns a pointer to the ListItem 'removed'. It is the responsibility of the caller to delete the ListItem from memory. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 13/4/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: ListItem that was tail of list NULL if it is an empty list Errors: None. Definition at line 292 of file list.cpp. { // CC_ASSERT_VALID(this); if (this->IsEmpty()) // if list is empty return a null pointer return NULL; ListItem *oldTail; oldTail = TailItem; TailItem = TailItem->Previous; // list tail pointed to previous item in list if (TailItem != NULL) // if list is not empty TailItem->Next = NULL; // pointer to old list tail must be nullified else HeadItem = NULL; // head item must be nullified ItemCount -= 1; // decrement item counter #ifdef _DEBUG LastItemRemoved = oldTail; #endif return oldTail; }

---

Member Data Documentation

ListItem* List::HeadItem [private]

Definition at line 164 of file list.h.

UINT32 List::ItemCount [private]

Definition at line 166 of file list.h.

ListItem* List::TailItem [private]

Definition at line 165 of file list.h.

---

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

• Kernel/list.h (r1785/r751)
• Kernel/list.cpp (r1785/r1282)

---