PUBLIC

OrientedListC::OrientedListC(void) OrientedListC::OrientedListC(const FBOrientationC &) OrientedListC::OrientedListC(const OrientedListC &) OrientedListC::Copy(void) OrientedListC::Reverse(void) OrientedListC::OrientationSet(const FBOrientationC &) OrientedListC::Orientation(void) const OrientedListC::OrientedListC(const ListC &,const FBOrientationC &) ListC::Copy(void) const ListC::operator=(const ListC &) ListC::List(void) const ListC::List(void) ListC::First(void) const ListC::Last(void) const ListC::Nth(IndexT) const ListC::InsFirstD(const DataC &) ListC::InsLastD(const DataC &) ListC::DeleteFirst(void) ListC::DeleteLast(void) ListC::GetFirst(void) ListC::GetLast(void) ListC::MoveAsFirst(ListPtrC &) ListC::MoveAsLast(ListPtrC &) ListC::MoveHeadAft(ListPtrC &) ListC::MoveHeadBef(ListPtrC &) ListC::Empty(void) ListC::operator[](IndexT) ListC::operator[](IndexT) const ListC::FirstGet(void) ListC::LastGet(void) ListC::operator+=(ListC &) ListC::operator+(const ListC &) const ListC::Head(ListPtrC &) ListC::Tail(ListPtrC &) ListC::Cut(double) ListC::InsFirst(const ListPtrC &) ListC::InsLast(const ListPtrC &) ListC::UnLinkFirst(void) ListC::UnLinkLast(void) ListC::Sort(ListC &) ListC::operator<<(ostream &,const ListC &) BaseListC::operator=(const BaseListC &) 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

OrientedListC<class DataC>
include	"amma/OList.hh"
User Level:	Default
Library:	MstdList
Example:	exComplx.cc
Section:	Obsolete
In Scope:	std

Parent Classes:

public ListC<class DataC>

FBOrientationC orientation;

OrientedListC()

OrientedListC(const FBOrientationC & orient)

OrientedListC(const OrientedListC<DataC> & list)

OrientedListC<DataC> Copy()

OrientedListC<DataC> & Reverse()

OrientedListC<DataC> & OrientationSet(const FBOrientationC & orient)

const FBOrientationC & Orientation() const

OrientedListC(const ListC<DataC> & list,const FBOrientationC & orient)

ListC<DataC> Copy() const

a physical copy of the list

const ListC<DataC> & operator=(const ListC<DataC> & list)

an assigment of a list, the old one is destroyed

const ListC<DataC> & List() const

access to the constat object

ListC<DataC> & List()

access to the object

ListPtrC<DataC> First() const

ListPtrC<DataC> Last() const

ListPtrC<DataC> Nth(IndexT i) const

return the pointer to the i-th element of the list, the First() element is the Nth(0) ---------- elementary changes in the list -------------

ListPtrC<DataC> InsFirstD(const DataC & data)

insert a new data as the first element of the list, return the pointer to the new element

ListPtrC<DataC> InsLastD(const DataC & data)

insert a new data as the last element of the list, return the pointer to the new element

ListC<DataC> & DeleteFirst()

remove the first element from the list, destroy it, return the new list

ListC<DataC> & DeleteLast()

remove the last element from the list, destroy it, return the new list

DataC GetFirst()

unlink the first element from the list, return its content and destroy it

DataC GetLast()

unlink the last element form the list, return its content and destroy it

ListPtrC<DataC> MoveAsFirst(ListPtrC<DataC> & ptr)

ListPtrC<DataC> MoveAsLast(ListPtrC<DataC> & ptr)

ListPtrC<DataC> MoveHeadAft(ListPtrC<DataC> & elm)

ListPtrC<DataC> MoveHeadBef(ListPtrC<DataC> & elm)

ListC<DataC> & Empty()

delete all elements from the list --------- access to data ------------------------------

DataC & operator[](IndexT i)

return the content of the i-th element of the list, the First() element is [0]

const DataC & operator[](IndexT i) const

return the content of the i-th element of the list, the First() element is [0]

DataC FirstGet()

return the content of the first element the element is destroyed

DataC LastGet()

return the content of the first element the element is destroyed ---------- derived lists ------------------------------

const ListC<DataC> & operator+=(ListC<DataC> & list)

concatenate the 'list' to 'this' list

ListC<DataC> operator+(const ListC<DataC> & list) const

create a copy of the 'this' list and the 'list' and concatenate both new lists

ListC<DataC> Head(ListPtrC<DataC> & ptr)

split the list into 2 parts, the list will be contain the second part (the tail) including 'ptr' return the first part (the head)

ListC<DataC> Tail(ListPtrC<DataC> & ptr)

split the list into 2 parts, the list will be contain the first part (the head) return the second part including 'ptr' (the tail) more complex operations on lists

ListC<DataC> & Cut(double ratio)

remove 'ratio' % of elements from the begin and the end of the list return the new list

const ListPtrC<DataC> & InsFirst(const ListPtrC<DataC> & elm)

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

const ListPtrC<DataC> & InsLast(const ListPtrC<DataC> & elm)

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

ListPtrC<DataC> UnLinkFirst()

unlink the first element from the list, return pointer to that element

ListPtrC<DataC> UnLinkLast()

unlink the last element from the list, return pointer to that element

ListC<DataC> & Sort(ListC<DataC> & list)

ostream & operator<<(ostream & s,const ListC<DataC> & list)

const BaseListC & operator=(const BaseListC & list)

an assigment of a list, the old one is destroyed

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.