/* Destroys a table, deallocating all the memory it uses.
* table - Pointer to the table. After the function completes this pointer
* will be invalid for further use. */
void table_free(Table *table){
ArrayTable *t = (ArrayTable*)table;
TableElement *i;
// get loop boundaries for array
// array_high and array_low return
// arrays
array *aHigh = array_high(t->values);
array *aLow = array_low(t->values);
int high = *((int*)array_inspectValue(aHigh,0));
int low = *((int*)array_inspectValue(aLow,0));
array_free(aHigh);
array_free(aLow);
// traversing through the array and freeing
// memory for table elements if the memory handler
// was set
for (int pos = low; pos < high; pos++){
i = array_inspectValue(t->values, pos);
if(array_hasValue(t->values, pos)){
if(t->keyFree!=NULL) {
t->keyFree(i->key);
}
if(t->valueFree!=NULL) {
t->valueFree(i->value);
}
}
}
// freeing memory for the array and the table struct
array_free(t->values);
free(t);
}
// Syfte: table_isEmpty ar en funktion som anvands for att kolla
// om tabellen ar tom eller inte.
// Returnerar: Returnerar sant om tabellen ar tom. Falskt om tabellen
// innehaller nagot element.
bool table_isEmpty(Table *table) {
ArrayTable *t = (ArrayTable*)table;
// Kontrollera det forsta indexet i arrayen,
// om det forsta indexet ar null returnera sant dvs ArrayTable ar tom.
// Annars returneras false, dvs. inte tom.
return !array_hasValue(t->values,0);
}
// Syfte: Anvands for att ta bort element i tabellen.
// Genom att frigora minnesallokeringen for key
// och flyttar det sista elementet till den tomma
// positionen. Haller aven reda pa hur manga element
// som finns i tabellen.
// Inparametrar: Pekare till en tabell och pekare till en nyckel.
// Returnerar: Ingenting.
void table_remove(Table *table, KEY key) {
ArrayTable *t = (ArrayTable*)table;
TableElement *i = calloc(1,sizeof(TableElement));
int position;
// loopar ingenom arrayen till slutet av listan. Avbryter
// om slutet av listan dvs. NULL eller om vardet aterfinns.
// Om vardet aterfinns sa returneras detta.
for (position=0;array_hasValue(t->values,position);position++) {
i = array_inspectValue(t->values,position);
if (t->cf(i->key,key)==0) {
// Flytta sista vardet till platsen for det borttagna vardet.
// Har refererar t->count-1 till en intexering.
array_setValue(t->values, array_inspectValue(t->values,t->count-1),
position);
// Frigor minne for key och value pa den gamla positionen.
if(t->keyFree!=NULL)
t->keyFree(i->key);
if(t->valueFree!=NULL)
t->valueFree(i->value);
// Ersatter den gamla positionen med NULL.
// Har refererar t->count-1 inte som count utan som en indexering.
array_setValue(t->values, NULL, t->count-1);
t->count--; // Raknar ner count efter allt gjorts. *
break;
}
}
}
// Syfte: Att aterge vardet for en specifik nyckel.
// Inparametrar: Pekare till en tabell och pekare till nyckel.
// Returnerar: NULL om elementet saknas. Vardet om det aterfinns.
VALUE table_lookup(Table *table, KEY key) {
ArrayTable *t = (ArrayTable*)table;
TableElement *i = calloc(1,sizeof(TableElement));
int position;
// Lopar igenom arrayen tills dess att compare_function
// har hittat vardet. Om null avbryts lopen och NULL returneras.
// Om compare_function hittar igen vardet returneras detta.
for (position=0;array_hasValue(t->values,position);position++){
i=array_inspectValue(t->values,position);
if (t->cf(i->key,key)==0)
return i->value;
}
return NULL;
}
// Syfte: Funktionen tar bort tabellen och frigor minne.
// Inparametrar: Pekare till en tabell.
// Returnerar: Ingenting.
void table_free(Table *table) {
ArrayTable *t = (ArrayTable*)table;
TableElement *i = calloc(1,sizeof(TableElement));
int position;
// Loopar genom hela arrayen for att ta bort minne.
// Avslutas nar vi natt slutet, dvs NULL.
// Tar bort minnesallokering for nycklar, keys, och
// minnesallokering for varden, value.
for (position=0;array_hasValue(t->values,position);position++) {
i=array_inspectValue(t->values,position);
if(t->keyFree!=NULL)
t->keyFree(i->key);
if(t->valueFree!=NULL)
t->valueFree(i->value);
table_remove(t,i->key);
}
array_free(t->values);
// Frigor slutligen allokerat minne for tabellen.
free(t);
}
// Syfte: Lagger till ett element i arrayen. Darmed bade ett varde,
// value, och en nyckel, key. Haller aven reda pa hur
// manga element som finns i arrayen.
// Inparametrar: Pekare till tabellen, pekare till nyckel, pekare till vardet.
// Returnerar: Returnerar inget.
void table_insert(Table *table, KEY key,VALUE value) {
ArrayTable *t = (ArrayTable*)table;
TableElement *i = malloc(sizeof(TableElement));
TableElement *replaceElement = malloc(sizeof(TableElement));
i->key = key;
i->value = value;
int setNewValue = true;
int position;
// For att behalla unika nycklar.
// For varje element som har ett varde...
for (position=0;array_hasValue(t->values,position);position++) {
// ...kolla om nyckeln ar den samma.
// Om samma, byt ut vardet med samma nyckel.
replaceElement = array_inspectValue(t->values,position);
if (t->cf(replaceElement->key,key)==0) {
// Frigor minne for tidigare nyckel for tidigare element.
if(t->keyFree!=NULL)
t->keyFree(i->key);
if(t->valueFree!=NULL)
t->valueFree(i->value);
replaceElement->value = value;
// Satt det nya vardet pa plats.
array_setValue(t->values,replaceElement,position);
// Behover inte satta in ett nytt element med samma nyckel.
setNewValue = false;
// Eftersom ingenting flyttas behover count inte forandras.
}
}
// Om ingen likadan nyckel finns
// Satt in elementet i arrayen. Nyckel och varde.
if (setNewValue) {
array_setValue(t->values,i,t->count);
// Rakna upp count for varje instoppat
t->count++;
}
}