Example #1
0
/* 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);
}
Example #2
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;
        }
    }
}
Example #3
0
// 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);
}
Example #4
0
// 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++;
    }
}