diff options
Diffstat (limited to 'utils/List.cc')
| -rw-r--r-- | utils/List.cc | 320 |
1 files changed, 154 insertions, 166 deletions
diff --git a/utils/List.cc b/utils/List.cc index 37c11eb..c954ca7 100644 --- a/utils/List.cc +++ b/utils/List.cc @@ -17,51 +17,49 @@ #include <stdlib.h> #include <stdio.h> -/*?class CcuList +/*?class IvlList \begin{figure}[hbtp] \hfil -\psfig{figure=FIGURES/CcuList.epsf}\par \caption{Internal structure of \typ{CcuList}s} +\psfig{figure=FIGURES/IvlList.epsf}\par \caption{Internal structure of \typ{IvlList}s} \hfil \end{figure} ?*/ #ifdef CPLUS_BUG20 -class CcuListLink { -static CcuAllocator* ListLinkMem; +class IvlListLink { +static IvlAllocator* ListLinkMem; static void ClassInit (); public: - CcuListItem* Entry; - CcuListLink* Next; -inline CcuListLink (CcuListItem* e, CcuListLink* n = 0) { Entry = e; Next = n ? n : this; } - CcuListLink* Previous (); + IvlListItem* Entry; + IvlListLink* Next; +inline IvlListLink (IvlListItem* e, IvlListLink* n = 0) { Entry = e; Next = n ? n : this; } + IvlListLink* Previous (); void* operator new (size_t); void operator delete (void*); }; #endif - - #ifdef CPLUS_BUG20 -CcuAllocator* CcuListLink::ListLinkMem = 0; +IvlAllocator* IvlListLink::ListLinkMem = 0; #else -CcuAllocator* CcuList::CcuListLink::ListLinkMem = 0; +IvlAllocator* IvlList::IvlListLink::ListLinkMem = 0; #endif /*?nodoc?*/ void* #ifdef CPLUS_BUG20 -CcuListLink :: operator new (size_t) +IvlListLink :: operator new (size_t) #else -CcuList::CcuListLink :: operator new (size_t) +IvlList::IvlListLink :: operator new (size_t) #endif { if (!ListLinkMem) #ifdef CPLUS_BUG20 - ListLinkMem = new CcuAllocator (sizeof (CcuListLink)); + ListLinkMem = new IvlAllocator (sizeof (IvlListLink)); #else - ListLinkMem = new CcuAllocator (sizeof (CcuList::CcuListLink)); + ListLinkMem = new IvlAllocator (sizeof (IvlList::IvlListLink)); #endif return ListLinkMem->Alloc (); } @@ -69,31 +67,30 @@ CcuList::CcuListLink :: operator new (size_t) /*?nodoc?*/ void #ifdef CPLUS_BUG20 -CcuListLink :: operator delete (void* that) +IvlListLink :: operator delete (void* that) #else -CcuList::CcuListLink :: operator delete (void* that) +IvlList::IvlListLink :: operator delete (void* that) #endif { ListLinkMem->Free (that); } - /*! Get the link whose next link is this one. !*/ /*?hidden?*/ #ifndef CPLUS_BUG20 -CcuList::CcuListLink* -CcuList::CcuListLink :: Previous () +IvlList::IvlListLink* +IvlList::IvlListLink :: Previous () #else -CcuListLink* -CcuListLink :: Previous () +IvlListLink* +IvlListLink :: Previous () #endif { #ifndef CPLUS_BUG20 - register CcuList::CcuListLink* pl = this; + register IvlList::IvlListLink* pl = this; #else - register CcuListLink* pl = this; + register IvlListLink* pl = this; #endif while (pl->Next != this) pl = pl->Next; @@ -104,7 +101,7 @@ CcuListLink :: Previous () /*? Create an empty list. ?*/ -CcuList :: CcuList () +IvlList :: IvlList () { } #endif @@ -112,27 +109,26 @@ CcuList :: CcuList () /*? Create a list with one element \var{e}. ?*/ -CcuList :: CcuList (CcuListItem* e) -: LastLink (new CcuListLink (e)), +IvlList :: IvlList (IvlListItem* e) +: LastLink (new IvlListLink (e)), StatusFlag (NoError) { } /*?nodoc?*/ -CcuList :: CcuList (const CcuList& l) +IvlList :: IvlList (const IvlList& l) : LastLink (0), StatusFlag (NoError) { - CcuListIter li (l); + IvlListIter li (l); while (++li) Append (*li); } - /*? Destructor for lists. No operation is performed on the elements. ?*/ -CcuList :: ~CcuList () +IvlList :: ~IvlList () { Clear (); } @@ -141,11 +137,11 @@ CcuList :: ~CcuList () Empty a list. ?*/ void -CcuList :: Clear () +IvlList :: Clear () { - CcuListLink* del = LastLink; + IvlListLink* del = LastLink; while (del) { - CcuListLink* next = del->Next; + IvlListLink* next = del->Next; if (next == LastLink) next = 0; delete del; @@ -155,12 +151,12 @@ CcuList :: Clear () } /*?nodoc?*/ -CcuList& -CcuList :: operator = (const CcuList& l) +IvlList& +IvlList :: operator = (const IvlList& l) { if (this != &l) { Clear (); - CcuListIter li (l); + IvlListIter li (l); while (++li) Append (*li); } @@ -169,21 +165,21 @@ CcuList :: operator = (const CcuList& l) #ifdef DOC /*? -Get the status flag of a list. This can be one of \var{CcuList::NoError, CcuList::WasEmpty, -CcuList::TooEarly, CcuList::TooFar} or \var{CcuList::BadIterator}. +Get the status flag of a list. This can be one of \var{IvlList::NoError, IvlList::WasEmpty, +IvlList::TooEarly, IvlList::TooFar} or \var{IvlList::BadIterator}. The status flag is modified by most operations on lists. Those which -modify it when errors are encountered also set it to \var{CcuList::NoError} +modify it when errors are encountered also set it to \var{IvlList::NoError} when there is no error. ?*/ list_status -CcuList :: GetStatus () const +IvlList :: GetStatus () const { } #endif /* DOC */ /*?nextdoc?*/ -CcuListItem* -CcuList :: First () +IvlListItem* +IvlList :: First () { if (!LastLink) { StatusFlag = WasEmpty; @@ -197,10 +193,10 @@ CcuList :: First () Return the first (resp. last) element in the list, or 0 if the list was empty. The case of a null element can be distinguished from the case when the list is empty with the function \fun{GetStatus}: the status flag is -set to \var{CcuList::WasEmpty} in the latter case. +set to \var{IvlList::WasEmpty} in the latter case. ?*/ -CcuListItem* -CcuList :: Last () +IvlListItem* +IvlList :: Last () { if (!LastLink) { StatusFlag = WasEmpty; @@ -212,16 +208,16 @@ CcuList :: Last () /*? Get the \var{n}-th element of a list. If \var{n} is greater than the length of the list -this function returns 0 and sets the status to \var{CcuList::TooFar}. If \var{n} is negative, -this function returns 0 but sets the status to \var{CcuList::NoError}. +this function returns 0 and sets the status to \var{IvlList::TooFar}. If \var{n} is negative, +this function returns 0 but sets the status to \var{IvlList::NoError}. ?*/ -CcuListItem* -CcuList :: Nth (int n) +IvlListItem* +IvlList :: Nth (int n) { StatusFlag = NoError; if (n <= 0) return 0; - CcuListIter li (*this); + IvlListIter li (*this); while (n > 0 && ++li) --n; if (n != 0) @@ -233,10 +229,10 @@ CcuList :: Nth (int n) Compute the number of elements in a list. ?*/ int -CcuList :: Length () const +IvlList :: Length () const { int result = 0; - CcuListIter li (*this); + IvlListIter li (*this); while (++li) ++result; return result; @@ -247,12 +243,12 @@ Check whether an item is present in a list. If \var{rank} is not null, it is fil rank of the first occurence of \var{e} in the list. ?*/ int -CcuList :: Find (CcuListItem* e, int* rank) const +IvlList :: Find (IvlListItem* e, int* rank) const { int rk = 0; int ret = 0; - CcuListIter li (*this); + IvlListIter li (*this); while (++rk, ++li) if (*li == e) { ret = 1; @@ -265,36 +261,36 @@ CcuList :: Find (CcuListItem* e, int* rank) const } /*?nextdoc?*/ -CcuListIndex -CcuList :: Prepend (CcuListItem* e) +IvlListIndex +IvlList :: Prepend (IvlListItem* e) { if (LastLink) /* remember that LastLink->Next is the first */ - LastLink->Next = new CcuListLink (e, LastLink->Next); + LastLink->Next = new IvlListLink (e, LastLink->Next); else - LastLink = new CcuListLink (e); + LastLink = new IvlListLink (e); return LastLink; } /*? Add an element at the beginning (resp. end) of a list. ?*/ -CcuListIndex -CcuList :: Append (CcuListItem* e) +IvlListIndex +IvlList :: Append (IvlListItem* e) { if (LastLink) { - LastLink = LastLink->Next = new CcuListLink (e, LastLink->Next); + LastLink = LastLink->Next = new IvlListLink (e, LastLink->Next); } else - LastLink = new CcuListLink (e); + LastLink = new IvlListLink (e); return LastLink; } /*? Remove the first element of a list and return it. The status flag is set to -\var{CcuList::WasEmpty} when the list was empty. +\var{IvlList::WasEmpty} when the list was empty. ?*/ -CcuListItem* -CcuList :: RemoveFirst () +IvlListItem* +IvlList :: RemoveFirst () { /* Handle the case when the list is empty */ if (!LastLink) { @@ -304,8 +300,8 @@ CcuList :: RemoveFirst () StatusFlag = NoError; /* Get the first element and its data */ - CcuListLink* first = LastLink->Next; - CcuListItem* data = first->Entry; + IvlListLink* first = LastLink->Next; + IvlListItem* data = first->Entry; /* Remove it from the chain */ if (LastLink == first) LastLink = 0; @@ -317,14 +313,13 @@ CcuList :: RemoveFirst () return data; } - /*? Remove the last element of a list and return it. The status flag is set to -\var{CcuList::WasEmpty} when the list was empty. This function has to locate the last +\var{IvlList::WasEmpty} when the list was empty. This function has to locate the last element, and hence has a linear cost. ?*/ -CcuListItem* -CcuList :: RemoveLast () +IvlListItem* +IvlList :: RemoveLast () { /* Handle the case when the list is empty */ if (!LastLink) { @@ -334,11 +329,11 @@ CcuList :: RemoveLast () StatusFlag = NoError; /* Find the element that will be the new LastLink */ - register CcuListLink* newlast = LastLink->Previous (); + register IvlListLink* newlast = LastLink->Previous (); /* Save the element to be deleted and its data */ - CcuListLink* del = LastLink; - CcuListItem* data = LastLink->Entry; + IvlListLink* del = LastLink; + IvlListItem* data = LastLink->Entry; /* Remove it from the chain */ if (newlast == LastLink) LastLink = 0; @@ -356,24 +351,23 @@ CcuList :: RemoveLast () Insert an element before the link \var{l}. This function has a linear cost. !*/ /*?hidden?*/ -CcuListIndex -CcuList :: InsertBeforeLink (CcuListLink* l, CcuListItem* e) +IvlListIndex +IvlList :: InsertBeforeLink (IvlListLink* l, IvlListItem* e) { - CcuListLink* prev = l->Previous (); - CcuListLink* newlink = new CcuListLink (e, l); + IvlListLink* prev = l->Previous (); + IvlListLink* newlink = new IvlListLink (e, l); prev->Next = newlink; return newlink; } - /*! Insert an element after the link \var{l}. !*/ /*?hidden?*/ -CcuListIndex -CcuList :: InsertAfterLink (CcuListLink* l, CcuListItem* e) +IvlListIndex +IvlList :: InsertAfterLink (IvlListLink* l, IvlListItem* e) { - CcuListLink* newlink = new CcuListLink (e, l->Next); + IvlListLink* newlink = new IvlListLink (e, l->Next); l->Next = newlink; if (LastLink == l) LastLink = newlink; @@ -385,11 +379,11 @@ Remove the link which is after \var{l} and return its entry. If \var{l} is the l the list, the first one is removed. !*/ /*?hidden?*/ -CcuListItem* -CcuList :: RemoveAfterLink (CcuListLink* l) +IvlListItem* +IvlList :: RemoveAfterLink (IvlListLink* l) { - CcuListLink* del = l->Next; - CcuListItem* data = del->Entry; + IvlListLink* del = l->Next; + IvlListItem* data = del->Entry; if (del == l) { LastLink = 0; } else { @@ -407,11 +401,11 @@ Remove an element from a list. This function iterates through the list until it If \var{num} is \var{All} or is negative, all appearances of \var{entry} are deleted. ?*/ int -CcuList :: Remove (CcuListItem* entry, int num) +IvlList :: Remove (IvlListItem* entry, int num) { int removed = 0; - CcuListIter li (*this); - CcuListIter lj (*this); + IvlListIter li (*this); + IvlListIter lj (*this); while ((num < 0 || removed < num) && ++li) { if (*li == entry) { RemoveAfter (lj); @@ -430,11 +424,11 @@ The actual number of removals is returned. If \var{num} is \var{All} or is negative, all matching elements are deleted. ?*/ int -CcuList :: Remove (int (*p) (CcuListItem*), int num) +IvlList :: Remove (int (*p) (IvlListItem*), int num) { int removed = 0; - CcuListIter li (*this); - CcuListIter lj (*this); + IvlListIter li (*this); + IvlListIter lj (*this); while ((num < 0 || removed < num) && ++li) { if ((*p) (*li)) { RemoveAfter (lj); @@ -446,25 +440,24 @@ CcuList :: Remove (int (*p) (CcuListItem*), int num) return removed; } - /*?nextdoc?*/ -CcuListIndex -CcuList :: InsertAfter (const CcuListIter& li, CcuListItem* e) +IvlListIndex +IvlList :: InsertAfter (const IvlListIter& li, IvlListItem* e) { if (li.TheList != this) { StatusFlag = BadIterator; return 0; } StatusFlag = NoError; - CcuListIndex idx = 0; + IvlListIndex idx = 0; if (!li.CurLink) { - if (li.StatusFlag == CcuListIter::StartOfList) { + if (li.StatusFlag == IvlListIter::StartOfList) { idx = Prepend (e); } else { - fprintf (stderr, "abnormal status in CcuList::InsertAfter\n"); + fprintf (stderr, "abnormal status in IvlList::InsertAfter\n"); abort (); } - } else if (li.StatusFlag == CcuListIter::EndOfList) { + } else if (li.StatusFlag == IvlListIter::EndOfList) { idx = Append (e); } else { idx = InsertAfterLink (li.CurLink, e); @@ -474,29 +467,29 @@ CcuList :: InsertAfter (const CcuListIter& li, CcuListItem* e) /*? Insert an element before (resp. after) the current position of the iterator \var{li}. -These functions are both equivalent to \fun{CcuList::Prepend} if the iterator is at the +These functions are both equivalent to \fun{IvlList::Prepend} if the iterator is at the beginning of the list (ie. before the first element). \fun{InsertAfter} is performed in a constant time, while \fun{InsertBefore} has a linear cost. If \var{li} is not an iterator on this list, the status flag of the list -is set to \var{CcuList::BadIterator}. +is set to \var{IvlList::BadIterator}. ?*/ -CcuListIndex -CcuList :: InsertBefore (const CcuListIter& li, CcuListItem* e) +IvlListIndex +IvlList :: InsertBefore (const IvlListIter& li, IvlListItem* e) { if (li.TheList != this) { StatusFlag = BadIterator; return 0; } StatusFlag = NoError; - CcuListIndex idx = 0; + IvlListIndex idx = 0; if (!li.CurLink) { - if (li.StatusFlag == CcuListIter::StartOfList) { + if (li.StatusFlag == IvlListIter::StartOfList) { idx = Prepend (e); } else { - fprintf (stderr, "abnormal status in CcuList::InsertAfter\n"); + fprintf (stderr, "abnormal status in IvlList::InsertAfter\n"); abort (); } - } else if (li.StatusFlag == CcuListIter::EndOfList) { + } else if (li.StatusFlag == IvlListIter::EndOfList) { idx = Append (e); } else { idx = InsertBeforeLink (li.CurLink, e); @@ -507,15 +500,15 @@ CcuList :: InsertBefore (const CcuListIter& li, CcuListItem* e) /*? Remove the element after the current element of the iterator \var{li}. If \var{li} points before the beginning of the list, the first element is removed. -If \var{li} points at the last element, the status flag is set to \var{CcuList::TooFar}. -If the list is empty, the flag is set to \var{CcuList::EmptyList}. In both cases, the +If \var{li} points at the last element, the status flag is set to \var{IvlList::TooFar}. +If the list is empty, the flag is set to \var{IvlList::EmptyList}. In both cases, the return value is null. If \var{li} is not an iterator -on this list, the flag is set to \var{CcuList::BadIterator}. +on this list, the flag is set to \var{IvlList::BadIterator}. This function may be used when one wants to iterate through a list and remove some elements: \begin{ccode} - CcuListIter li = l; - CcuListIter lj = l; + IvlListIter li = l; + IvlListIter lj = l; while (++li) if (do_remove (*li)) { l.RemoveAfter (lj); @@ -525,8 +518,8 @@ when one wants to iterate through a list and remove some elements: } \end{ccode} ?*/ -CcuListItem* -CcuList :: RemoveAfter (const CcuListIter& li) +IvlListItem* +IvlList :: RemoveAfter (const IvlListIter& li) { if (li.TheList != this) { StatusFlag = BadIterator; @@ -544,11 +537,10 @@ CcuList :: RemoveAfter (const CcuListIter& li) } } - #ifdef DOC -/*?class CcuListIter -The class \typ{CcuListIter} allows iterations on lists. +/*?class IvlListIter +The class \typ{IvlListIter} allows iterations on lists. Several iterators may be used at a time on the same list. It is dangerous to modify a list that is being iterated. Refer to the implementation figure for more details. Of course, the functions such as \var{InsertAfter} or \var{RemoveAfter} are designed @@ -556,8 +548,8 @@ to be harmless. However, they may be dangerous if another iterator is used at th time on the same list. The basic usage of an iterator is the following: \begin{ccode} - extern CcuList& l; - CcuListIter li = l; + extern IvlList& l; + IvlListIter li = l; while (++li) foo (*li); // *li is the value that was stored with Append \end{ccode} @@ -567,7 +559,7 @@ The basic usage of an iterator is the following: Initialize an iterator associated to the list \var{l}. That iterator will point at the beginning of the list, {\em before} the first element. ?*/ -CcuListIter :: CcuListIter (const CcuList& l) +IvlListIter :: IvlListIter (const IvlList& l) { } #endif /* DOC */ @@ -576,25 +568,24 @@ CcuListIter :: CcuListIter (const CcuList& l) Build an iterator on list \var{l}, pointing at the element denoted by \var{idx}. No check is done on whether \var{idx} is a valid index of list \var{l}. ?*/ -CcuListIter :: CcuListIter (const CcuList& l, CcuListIndex idx) +IvlListIter :: IvlListIter (const IvlList& l, IvlListIndex idx) : TheList (&l), #ifdef CPLUS_BUG20 - CurLink ((CcuListLink*) idx), + CurLink ((IvlListLink*) idx), #else - CurLink ((CcuList::CcuListLink*) idx), + CurLink ((IvlList::IvlListLink*) idx), #endif StatusFlag (idx ? Normal : StartOfList) { } - #ifdef DOC /*? -Get the status of an iterator. The status may be one of \var{CcuListIter::Normal, -CcuListIter::StartOfList}, or \var{CcuListIter::EndOfList} +Get the status of an iterator. The status may be one of \var{IvlListIter::Normal, +IvlListIter::StartOfList}, or \var{IvlListIter::EndOfList} ?*/ listiter_status -CcuListIter :: GetStatus () const +IvlListIter :: GetStatus () const { } @@ -602,39 +593,37 @@ CcuListIter :: GetStatus () const Reset an iterator to the beginning of the list. ?*/ void -CcuListIter :: Reset () +IvlListIter :: Reset () { } #endif /* DOC */ - /*? Get the current entry pointed by an iterator. This operator returns 0 if the iterator is at the beginning or the end of the list. To distinguish those cases from the case when the entry is null, you can use the method \fun{GetStatus}. ?*/ -CcuListItem* -CcuListIter :: operator * () const +IvlListItem* +IvlListIter :: operator * () const { return (CurLink && StatusFlag == Normal) ? CurLink->Entry : 0; } #ifdef DOC /*? -Check whether the status of an iterator is \var{CcuListIter::Normal}. +Check whether the status of an iterator is \var{IvlListIter::Normal}. ?*/ -CcuListIter :: operator int () const +IvlListIter :: operator int () const { } #endif /* DOC */ - /*? Take one step of iteration. ?*/ -CcuListIter& -CcuListIter :: operator ++ () +IvlListIter& +IvlListIter :: operator ++ () { /* This test covers all the cases : - the iteration has already begun, and is at its end. @@ -654,8 +643,8 @@ CcuListIter :: operator ++ () Post-increment equivalent of the previous operator. This operator is just here as a placeholder: it does the same thing as the previous one. ?*/ -CcuListIter& -CcuListIter :: operator ++ (int) +IvlListIter& +IvlListIter :: operator ++ (int) { ++(*this); return *this; @@ -669,7 +658,7 @@ If \var{e} is present in the list, the iterator will be correctly positionned. If not, it will have reached the end of the list. ?*/ int -CcuListIter :: Find (CcuListItem* e) +IvlListIter :: Find (IvlListItem* e) { while (++(*this)) if (**this == e) @@ -679,125 +668,124 @@ CcuListIter :: Find (CcuListItem* e) #ifdef DOC -/*?class CcuListOf -The generic classes \typ{CcuListOf} and \typ{CcuListIterOf} are derived classes -of \typ{CcuList} and \typ{CcuListIter} that provide lists of pointers to class objects. +/*?class IvlListOf +The generic classes \typ{IvlListOf} and \typ{IvlListIterOf} are derived classes +of \typ{IvlList} and \typ{IvlListIter} that provide lists of pointers to class objects. When parameterized by the class \typ{ITEM}, the following functions are redefined: ?*/ /*?nextdoc?*/ -CcuListOf :: CcuListOf (ITEM* it) +IvlListOf :: IvlListOf (ITEM* it) { } /*?nextdoc?*/ ITEM* -CcuListOf :: First () +IvlListOf :: First () { } /*?nextdoc?*/ ITEM* -CcuListOf :: Last () +IvlListOf :: Last () { } /*?nextdoc?*/ ITEM* -CcuListOf :: Nth (int n) +IvlListOf :: Nth (int n) { } /*?nextdoc?*/ int -CcuListOf :: Find (ITEM* it) const +IvlListOf :: Find (ITEM* it) const { } /*?nextdoc?*/ void -CcuListOf :: Append (ITEM* it) +IvlListOf :: Append (ITEM* it) { } /*?nextdoc?*/ void -CcuListOf :: Prepend (ITEM* it) +IvlListOf :: Prepend (ITEM* it) { } /*?nextdoc?*/ -CcuListOf& -CcuListOf :: operator << (ITEM* it) +IvlListOf& +IvlListOf :: operator << (ITEM* it) { } /*?nextdoc?*/ ITEM* -CcuListOf :: RemoveFirst () +IvlListOf :: RemoveFirst () { } /*?nextdoc?*/ ITEM* -CcuListOf :: RemoveLast () +IvlListOf :: RemoveLast () { } /*?nextdoc?*/ int -CcuListOf :: Remove (ITEM* it, int nb = 1) +IvlListOf :: Remove (ITEM* it, int nb = 1) { } /*?nextdoc?*/ int -CcuListOf :: Remove (int (*p) (ITEM*), int nb = 1) +IvlListOf :: Remove (int (*p) (ITEM*), int nb = 1) { } /*?nextdoc?*/ void -CcuListOf :: InsertAfter (const CcuListIterOf <ITEM>& li, ITEM*it) +IvlListOf :: InsertAfter (const IvlListIterOf <ITEM>& li, ITEM*it) { } /*?nextdoc?*/ void -CcuListOf :: InsertBefore (const CcuListIterOf <ITEM>& li, ITEM* it) +IvlListOf :: InsertBefore (const IvlListIterOf <ITEM>& li, ITEM* it) { } /*? -These functions are equivalent to their homonyms in the class \typ{CcuList}, +These functions are equivalent to their homonyms in the class \typ{IvlList}, except that they are customized in order to manipulate pointers to \typ{ITEM} instead of \typ{void*}. ?*/ ITEM* -CcuListOf :: RemoveAfter (const CcuListIterOf <ITEM>& li) +IvlListOf :: RemoveAfter (const IvlListIterOf <ITEM>& li) { } /*?nextdoc?*/ -CcuListIterOf :: CcuListIterOf (const CcuListOf <ITEM>& l) +IvlListIterOf :: IvlListIterOf (const IvlListOf <ITEM>& l) { } /*?nextdoc?*/ ITEM* -CcuListIterOf :: operator * () const +IvlListIterOf :: operator * () const { } /*? -These functions are equivalent to their homonyms in the class \typ{CcuListIter}, +These functions are equivalent to their homonyms in the class \typ{IvlListIter}, except that they are customized in order to manipulate pointers to \typ{ITEM} instead of \typ{void*}. ?*/ int -CcuListIterOf :: Find (ITEM* it) +IvlListIterOf :: Find (ITEM* it) { } - #endif /* DOC */ |