PUBLIC

BaseListC::BaseListC(void) BaseListC::BaseListC(const BaseListC &) BaseListC::operator=(const BaseListC &) BaseListC::~BaseListC(void) BaseListC::operator==(const BaseListC &) const BaseListC::operator!=(const BaseListC &) const BaseListC::IsEmpty(void) const BaseListC::First(void) const BaseListC::Last(void) const BaseListC::InsFirst(const BaseListPtrC &) BaseListC::InsLast(const BaseListPtrC &) BaseListC::MoveAsFirst(BaseListPtrC &) BaseListC::MoveAsLast(BaseListPtrC &) BaseListC::MoveHeadAft(BaseListPtrC &) BaseListC::MoveHeadBef(BaseListPtrC &) BaseListC::UnLinkFirst(void) BaseListC::UnLinkLast(void) BaseListC::PointerList(void) BaseListC::Concat(BaseListC &) BaseListC::operator+=(BaseListC &) BaseListC::Reverse(void) BaseListC::Size(void) const BaseListC::Tail(BaseListPtrC &) BaseListC::FixBackwardLinks(void) BaseListC::Apply(const BaseListPtrC &,BooleanT (*)(FuncArgList)) BaseListC::FindFirst(BooleanT (*)(FuncArgList)) BaseListC::FindNext(const BaseListPtrC &,BooleanT (*)(FuncArgList)) BaseListC::MapplyL(const BaseListPtrC &,BaseListPtrC (*)(FuncArgList)) BaseListC::DebugHeadPrint(void) const BaseListC::operator<<(ostream &,const BaseListC &) BaseListC::DebugBaseListCSize(const BaseListC &) RefCounterC::ToBeDeleted(void) const RefCounterC::Count(void) const RefCounterC::IsSingleReference(void) RefCounterC::operator=(const RefCounterC &) RefCounterC::ToBeDeletedUpdate(const RefCounterC &) RefCounterC::ReportInvalidObject(char *) RefCounterBaseC::Label(void) const

BaseListC
pure double-linked circular list handling
include	"amma/BaseList.hh"
User Level:	Default
Library:	Mold
Example:	exBiHash.cc
Section:	Obsolete
In Scope:	std

Parent Classes:

public RefCounterC

ListC

ListLinkC * element;

the pointer to the head of the list

BaseListC()

an empty list

BaseListC(const BaseListC & li)

another identifier for the list

const BaseListC & operator=(const BaseListC & list)

an assigment of a list, the old one is destroyed

~BaseListC()

the destructor of the list, each list element is destroyed !! BUG GNU C++ 2.2.2 ... 'virtual' cannot be used for member data ---------- status -------------------------------------

BooleanT operator==(const BaseListC & list) const

Do both lists represent the same list?

BooleanT operator!=(const BaseListC & list) const

Are lists independent two lists?

BooleanT IsEmpty() const

Is the list empty? ---------- pointers -----------------------------------

BaseListPtrC First() const

return the pointer to the first element of the list

BaseListPtrC Last() const

return the pointer to the last element of the list ---------- elementary changes in the list -------------

const BaseListPtrC & InsFirst(const BaseListPtrC & elm)

insert a new element at the beginning of the list, return the pointer to the new element

const BaseListPtrC & InsLast(const BaseListPtrC & elm)

insert a new element at the end of the list, return the pointer to the new element

BaseListPtrC & MoveAsFirst(BaseListPtrC & elm)

move the list element, which 'elm' points to, into the list as the first element, return 'elm'

BaseListPtrC & MoveAsLast(BaseListPtrC & elm)

move the list element, which 'elm' points to, into the list as the last element, return 'elm'

BaseListPtrC & MoveHeadAft(BaseListPtrC & elm)

BaseListPtrC & MoveHeadBef(BaseListPtrC & elm)

BaseListPtrC UnLinkFirst()

unlink the First element from a list

BaseListPtrC UnLinkLast()

unlink Last element from a list

BaseListC PointerList()

construct a list of pointers to elements in the list

const BaseListC & Concat(BaseListC & list2)

append list2 to list1 (list2 will be empty ) return pointer to the list1 */

const BaseListC & operator+=(BaseListC & list)

concatenate the 'list' to 'this' list

BaseListC & Reverse()

reverse the list *

long int Size() const

length of a list; does not check the long int counter overflow.

BaseListC Tail(BaseListPtrC & elm)

split a list into two parts, return the tail list including elm

BaseListC & FixBackwardLinks()

------------- MORE COMPLEX LIST OPERATIONS ---------------------

BaseListPtrC Apply(const BaseListPtrC & start,BooleanT (*)(FuncArgList) ApplyElm)

applies "ApplyElm" to "start" and all its succesors until "ApplyElm" is hold or the list end is reached; returns the element of the list that satisfied "ApplyElm"

BaseListPtrC FindFirst(BooleanT (*)(FuncArgList) ApplyElm)

find the first element of a list for which "BooleanT test(ListElmC *)" is hold; return NULL if no such element exists

BaseListPtrC FindNext(const BaseListPtrC & first,BooleanT (*)(FuncArgList) ApplyElm)

find next element in a list for which BooleanT test(ListElmC *) is hold; return NULL if no such element exists

BaseListC MapplyL(const BaseListPtrC & start,BaseListPtrC (*)(FuncArgList) Construct)

apply "Construct" to a portion of a list starting with "start", link results to the new list; "Construct" can return empty BaseListPtrC

void DebugHeadPrint() const

print information about the head of the list into the 'cerrAMMA'

ostream & operator<<(ostream & s,const BaseListC & list)

void DebugBaseListCSize(const BaseListC & list)

BooleanT ToBeDeleted() const

Returns TRUE if the content should be deleted.

RCCountT Count() const

Returns the number of refrences to this object. NB. The following definition is now obsolete, The value 0 means there is no other reference to this object.

BooleanT IsSingleReference()

Tests is there is only one reference to this object.

const RefCounterC & operator=(const RefCounterC & rC)

BooleanT ToBeDeletedUpdate(const RefCounterC & rC)

This function is the condition and the assigment together. It returns TRUE if the content should be deleted before assigning of the new object. The function automatically solves the reference counter of this object as well as the other object reference counter 'rC'.

void ReportInvalidObject(char * Msg = 0)

This function reports an error to the user if a problem is detected in the refrence counting mechanism.

LabelT Label() const

Returns the label of this reference counter.
The member function is useful mainly to recognize objects during debugging. The value of the label is uniquely defined pointer.