OOP_PROJECT.CPP : ELEMENT, LISTID
public : listid::~listid()

destructor
public : void listid::add(tip * d)

adauga un element la sfarsitul listei; threading safe; functie supraincarcata
tip *d : pointer la un tip generic
public : void listid::add(tip * d, int index)

adauga un element dupa elementul de la pozitia absoluta "index"; threading safe; functie supraincarcata
tip * d :pointer la elementul generic
int index : pozitia dupa care se adauga(numaratoarea incepe cu elementul de pe pozitia "0"
public : void listid::add(tip d)

adauga un element la sfarsitul listei; threading safe; functie supraincarcata
tip d : element generic trimis prin stiva
public : void listid::add(tip d, int index)

adauga un element dupa elementul de la pozitia absoluta "index"; threading safe; functie supraincarcata
tip d :data generica incarcat in stiva
int index : pozitia dupa care se adauga(numaratoarea incepe cu elementul de pe pozitia "0"
public : void listid::attachAfter(element* e, element* dupa)

ataseaza un element deja exista dupa un alt element aflat deja in lista; threading safe
element * e : pointer la clasa element generica
element * dupa : pointer la un element generic deja existent in lista
OBS: elementul care se ataseaza trebui sa existe deja; spre deosebire de "add" care creaza un element si ii atribuie o data generica
public : void listid::attachBefore(element* e, element* dupa)

ataseaza un element deja existent inaintea altui element aflat deja in lista; threading safe
public : void listid::clearlist()

sterge si dealocheaza toate elementele din lista; threading save
public : void listid::deattach(element* e)

de-ataseaza un element din lista fara al si distruge; elementul poate mai departe sa fie procesat dupa nevoi;threading safe
public : void listid::exchange(element* a, element* d)

inter-schimba doua elemente intre ele; functia trateaza toate cazurile [diferitele relatii intre primul si al doilea element];threading safe
public : element* listid::get_first()

returneaza pointer la primul element din lista;threading safe
public : element* listid::get_last()

returneaza pointer la ultimul element din lista;threading safe
public : int listid::indexOf(element* e)

intoarce pozitia unui element din lista;threading safe
public : void listid::insert(tip * d)

aduga un element la inceputul liste; elementul inserat devine primul din lista;threading safe
public : void listid::insert(tip * d, int index)

aduga(insereaza) un element inaitea elementului de pe pozitia "index";threading safe
public : void listid::insert(tip d)

aduga un element la inceputul liste; elementul inserat devine primul din lista;threading safe
public : void listid::insert(tip d, int index)

aduga(insereaza) un element inaitea elementului de pe pozitia "index";threading safe
public : void listid::insertionsort(int start, int end)

sorteaza alfabetic crescator elementele din lista;threading safe
public : void listid::insertionsortrev(int start, int end)

dorteaza descrescator elementele din lista;threading safe
public : int listid::length()

intoarece lungime listei;threading safe
public : listid::listid()

CONSTRUCTOR IMPLICIT; initializeaza o lista noua;threading safe
public : listid::listid(listid* p)

constructor de COPIERE; copieaza datele din elementele listei precizate in noii elemente create in lista "this";threading safe
public : void listid::print()

Afiseaza continul listei pe ecran
public : void listid::print(char * msg)

afiseaza continul listei pe ecran impreuna cu mesajul utilizatorului
public : void listid::randomizelist(unsigned seed)

randomizeaza pozitiile tuturor elementelor din lista
public : void listid::read()

citeste de la tastatura elementele listei
public : void listid::read(char * msg1)

citeste de la tastatura elementele listei si afiseaza si mesajul utilizatorului
public : void listid::read_inverse()

citeste elementele listei de la tastatura de la sfarsit listei la inceputul listei
public : void listid::read_inverse(char * msg)

citeste elemete listei de la coada la cap si afiseaza si mesajul utilizatorului
public : int listid::remove(element* a)

sterge elementul specificat din lista;threading safe
public : int listid::remove(int i)

sterge elementul de la pozita "i" din lista; numaratoare incepe de la "0";threading safe
public : int listid::removeallequal(tip * d)

sterge toate elementele care au aceeasi data in lista;threading safe
public : int listid::removeallequal(tip d)

sterge toate elementele care au aceeasi data in lista;threading safe
public : int listid::removeoneequal(tip * d)

sterge primul element intalnit care area aceasi data;threading safe
public : int listid::removeoneequal(tip d)

sterge primul element intalnit care are aceeasi data;threading safe
public : int listid::removeoneequalrev(tip * d)

sterge ultimul element intalnit[sau de la coada la cap cum se mai spune];threading safe
public : int listid::removeoneequalrev(tip d)

sterge ultimul element intalnit[sau de la coada la cap cum se mai spune];threading safe
public : void listid::rotate_left(int i)

roteste la stanga elementele listei cu "i" pozitii; threading safe
public : void listid::rotate_right(int i)

roteste la dreapta elementele listei cu "i" pozitii threading safe
public : element* listid::search(tip * d, int & index)

cauta primul element [incepand cu pozitia "index"] care area aceeasi data generica si il intoarce ca rezultat; deasemenea "index" este setat corespunzator cu pozitia elementului gasit;threading safe
public : element* listid::search(tip d, int & index)

cauta primul element [incepand cu pozitia "index"] care area aceeasi data generica si il intoarce ca rezultat; deasemenea "index" este setat corespunzator cu pozitia elementului gasit;threading safe
public : element* listid::searchrev(tip * d, int & index)

cauta de la coada la cap ultimul element care are aceeasi data generica si il intoarce ca rezultat; deasemenea varibila "index" trimisa prin referinta este setata in mod corespunzator cu pozitia elementului gasit;threading safe
public : element* listid::searchrev(tip d, int & index)

cauta de la coada la cap ultimul element care are aceeasi data generica si il intoarce ca rezultat; deasemenea varibila "index" trimisa prin referinta este setata in mod corespunzator cu pozitia elementului gasit;threading safe
public : void listid::set_first(element* d)

seteaza elementul dat ca fiind primul din lista;threading safe
public : void listid::set_last(element* d)

seteaza elementul dat ca fiind ultimul din lista;threading safe
public : listid* listid::splitLeft(element* e)

imparte lista in doua de la elementul specificat elementele din dreapta sunt intorse intr-o noua lista;threading safe
public : listid* listid::splitLeft(int index)

imparte lista in doua;threading safe
public : listid* listid::splitRight(element* e)

imparte lista in doua; elementele din stanga listei sunt intoarse intr-o noua lista;threading safe
public : listid* listid::splitRight(int index)

;threading safe
public : listid* listid::operator-(listid* p)

scaderea a doua liste;threading safe
public : listid::operator element*()

conversia unui element intr-o lista;threading safe
public : listid* listid::operator*(listid* p)

imultirea listelor;threading safe
public : element* listid::operator[](int i)

intoarce elementul de pe pozitia "i";threading safe
public : listid* listid::operator+(listid* p)

adunarea listelor;threading safe
public : int listid::operator<(listid* p)

compara daca mai mic;threading safe
public : void listid::operator<<(int i)

deplasarea spre stanga; se insereaza "i" elemente cu data nula la coada;threading safe
public : int listid::operator<=(listid* p)

compara mai mic sau egal;threading safe
public : listid* listid::operator=(listid* p)

atribuire;threading safe
public : int listid::operator==(listid* p)

compara daca elementele primei lista sunt egale cu elementele celei dea doua lista - la nivel de date generice;threading safe
public : int listid::operator>(listid* p)

compara mai mare strict;threading safe
public : int listid::operator>=(listid* p)

compara mai mare sau egal;threading safe
public : void listid::operator>>(int i)

deplasarea spre dreapta; ultimele "i" elemente se vor pierde;threading safe


;threading safe
private : listid* listid::addListsPrivate(listid* p)

adauga lista din partea stanga la stanga primei liste; functie supraincarcata; functie privata, care nu implementeaza mutexuri
listid *p : pointer la clasa generica de acelasi tip
private : void listid::addPrivate(tip * d)

implementeaza la nivel practic adaugarea unui element la sfarsitul listei; functie supraincarcata; functie privata, care nu implementeaza mutexuri
tip * d : pointer la data generica
private : void listid::addPrivate(tip * d, int index)

implementeaza la nivel practic adaugarea unui element dupa pozitia "index"; functie supraincarcata; functie privata, care nu implementeaza mutexuri
tip *d : pointer la data generica
int index: pozite absoluta [inclusiv "0"]
private : void listid::addPrivate(tip d)

implementeaza practic adugarea unui element la sfarsitul listei; functie supraincarcata; functie privata, care nu implementeaza mutexuri
private : void listid::addPrivate(tip d, int index)

implemeteaza practic adugarea unui element dupa pozitia "index'; functie privata, care nu implementeaza mutexuri
tip d : data generica trimisa prin stiva
int index : pozitia absoluta
private : void listid::attachAfterPrivate(element* e, element* dupa)

implementeaza practic atasarea unei element generica existent dupa un altul din lista generica; functie privata, care nu implementeaza mutexuri
private : void listid::attachBeforePrivate(element* e, element* dupa)

implementeaza practic aduagarea unui element deja existent inaintea altuia din lista; functie privata, care nu implementeaza mutexuri
private : int listid::biggerEqualPrivate(listid* p)

testeaza mai mare sau egal; functie privata, care nu implementeaza mutexuri
private : int listid::biggerPrivate(listid* p)

testeaza daca prima lista este mai mare strict ca a doua; functie privata, care nu implementeaza mutexuri
private : void listid::clearlistPrivate()

sterge si dealocheaza toate elementele din lista; functie privata, care nu implementeaza mutexuri
private : void listid::deattachPrivate(element* e)

de-ataseaza un element din lista fara al dealoca; elementul devine liber; functie privata, care nu implementeaza mutexuri
private : listid* listid::equalPrivate(listid* p)

atribuire; functie privata, care nu implementeaza mutexuri
private : void listid::exchangePrivate(element* a, element* d)

interschimba doua elemente; functia treateaza si toate cazurile particulare in care se pot afla cele 2 elemente; functie privata, care nu implementeaza mutexuri
private : element* listid::getElementPrivate(int i)

returneaza elementul aflat la pozitia "i"; functie privata, care nu implementeaza mutexuri
private : int listid::indexOfPrivate(element* e)

implementarea practica pt a intoarce pozitia unui element din lista; functie privata, care nu implementeaza mutexuri
private : void listid::insertionsortPrivate(int start, int end)

implementeaza practic sortarea alfabetica crescatoare a elementelor din lista; functie privata, care nu implementeaza mutexuri
private : void listid::insertionsortrevPrivate(int start, int end)

implementeaza practic sortarea descrescatoare a elementelor din lista; functie privata, care nu implementeaza mutexuri
private : void listid::insertPrivate(tip * d)

implementeaza practic insertia unui element la inceputul listei; functie privata, care nu implementeaza mutexuri
private : void listid::insertPrivate(tip * d, int index)

implementeaza practic insertia unei element inaintea unuia din lista; functie privata, care nu implementeaza mutexuri
private : void listid::insertPrivate(tip d)

implementeaza practic insereaza un element la inceputul listei; functie privata, care nu implementeaza mutexuri
private : void listid::insertPrivate(tip d, int index)

implementeaza practic insertia unui element inaintea unui din lista; functie privata, care nu implementeaza mutexuri
private : int listid::isEqualPrivate(listid* p)

implementeaza practic testarea egalitatii a doua liste; functie privata, care nu implementeaza mutexuri
private : int listid::lengthPrivate()

implementeaza practic numarearea elementelor din lista; functie privata, care nu implementeaza mutexuri
private : listid* listid::minusListsPrivate(listid* p)

implementeaza practic scaderea a doua liste [comform specificatiei cerintei problemei]; functie privata, care nu implementeaza mutexuri
private : listid* listid::mulListsPrivate(listid* p)

implementeaza practic imultirea a doua liste [comform specificatiei cerintei problemei]; functie privata, care nu implementeaza mutexuri
private : void listid::randomizelistPrivate(unsigned seed)

implementeaza practic randomizarea pozitiilor elementelor din lista; functie privata, care nu implementeaza mutexuri
private : int listid::removeallequalPrivate(tip * d)

implementeaza practic stergerea elementelor cu aceeasi data generica specificata; functie privata, care nu implementeaza mutexuri
private : int listid::removeallequalPrivate(tip d)

implementeaza practic stergerea tuturor elementelor cu aceeasi data generica; functie privata, care nu implementeaza mutexuri
private : int listid::removeoneequalPrivate(tip * d)

implementeaza practic stergerea primului element cu aceeasi data generica din lista; functie privata, care nu implementeaza mutexuri
private : int listid::removeoneequalPrivate(tip d)

implementeaza practic stergerea primului element cu aceeasi data generica din lista; functie privata, care nu implementeaza mutexuri
private : int listid::removeoneequalrevPrivate(tip * d)

implementeaza practic stergerea ultimului element cu aceeasi data din lista [sau de la coada la cap cum i se mai spune]; functie privata, care nu implementeaza mutexuri
private : int listid::removeoneequalrevPrivate(tip d)

implementeaza practic stergerea ultimului element cu aceeasi data din lista [sau de la coada la cap cum i se mai spune]; functie privata, care nu implementeaza mutexuri
private : int listid::removePrivate(element* a)

implementeaza practic stergerea unui element din lista; functie privata, care nu implementeaza mutexuri
private : int listid::removePrivate(int i)

implementeaza practic stergerea elementului de la pozitia "i"; functie privata, care nu implementeaza mutexuri
private : void listid::rotate_leftPrivate(int i)

implementeaza practic rotirea la stanga a elementelor liste cu "i" pozitii; functie privata, care nu implementeaza mutexuri
private : void listid::rotate_rightPrivate(int i)

implementeaza practic rotirea la dreapta a elementelor listei cu "i" pozitii; functie privata, care nu implementeaza mutexuri
private : element* listid::searchPrivate(tip * d, int & index)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
private : element* listid::searchPrivate(tip d, int & index)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
private : element* listid::searchrevPrivate(tip * d, int & index)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
private : element* listid::searchrevPrivate(tip d, int & index)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
private : void listid::shiftLeftPrivate(int i)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
private : void listid::shiftRightPrivate(int i)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
private : int listid::smallerEqualPrivate(listid* p)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
private : int listid::smallerPrivate(listid* p)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
private : listid* listid::splitLeftPrivate(element* e)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
private : listid* listid::splitLeftPrivate(int index)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
private : listid* listid::splitRightPrivate(element* e)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
private : listid* listid::splitRightPrivate(int index)

implementeaza practic ; functie privata, care nu implementeaza mutexuri
protected : element* listid::first

retine lista prin primul sau element; data protejata, care nu implementeaza mutexuri
protected : element* listid::last

retina lista prin ultimul sau element; data protejata, care nu implementeaza mutexuri
protected : HANDLE listid::mutex

HANDLE windows care contine id-ul mutexului folosit pentru a face operatiile publice threading safe; functie privata, care nu implementeaza mutexuri


implementeaza practic ; functie privata, care nu implementeaza mutexuri