mntd_volume_hash.c

/***************************************************************************
 * CVSID: $Id: mntd_volume_hash.c,v 1.14 2004/08/07 15:10:47 stefanb Exp $
 *
 * mntd_volume_hash.c : Volume Manager hash functions for MNT daemon
 *
 * Copyright (C) 2004 Stefan Bambach, <sbambach@gmx.net>
 *
 * Licensed under the GNU General Public License 2.0
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 **************************************************************************/
 
#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "mntd_volume_hash.h"
#include "errmanager.h"
#include "dbug_mem.h"


/* private prototypes */
PHASHMAPELEMENT new_HashMapElement(PHASHMAP phm, 
                                                void (*cb_free_element)(void *data), 
                                                const char *key, void *userdata);
void hashmapelement_destroy(PHASHMAPELEMENT phme);
int hashmap_init(PHASHMAP phm);
void hashmap_destroy(PHASHMAP phm);
int hashmap_hash_element(const void *obj);
int hashmap_compare_element(const void *obj1, const void *obj2);
void hashmap_free_element(void *userdata);

/* public prototypes */
int hashmap_add(PHASHMAP phm, const char *key, void *data);
int hashmap_remove(PHASHMAP phm, const char *key);
int hashmap_size(PHASHMAP phm);
int hashmap_contains(PHASHMAP phm, const char *key);
int hashmap_get(PHASHMAP phm, const char *key, void **userdata);
int hashmap_update(PHASHMAP phm, const char *key, void *userdata);
int hashmap_foreach_call_function(PHASHMAP phm, int (*func)(void *data, void *userdata), void *userdata);


PHASHMAPELEMENT 
new_HashMapElement(PHASHMAP phm, void (*cb_free_element)(void *userdata), const char *key, void *userdata)
{
    PHASHMAPELEMENT phme = NULL;
    
    g_assert(phm!=NULL);
    g_assert(cb_free_element!=NULL);
    g_assert(key!=NULL);
    
    //MSG_DEBUG("new_HashMapElement('%s', %p) called", key, userdata);
    
    phme = (PHASHMAPELEMENT) malloc(sizeof(HASHMAPELEMENT));
    if (phme == NULL) {
        MSG_ERR("Out of memory");
        return NULL;
    }
    
    // clear structure
    memset(phme, 0, sizeof(HASHMAPELEMENT));
    
    // initialize data
    phme->phm = phm;
    phme->key = strdup(key);
    phme->userdata = userdata;
    
    // private methods
    phme->destroy = hashmapelement_destroy;
    phme->cb_free_element = cb_free_element;
    
    //MSG_DEBUG("new_HashMapElement('%s', %p) returned %p", key, userdata, phme);
    
    // return object
    return phme;
}


void
hashmapelement_destroy(PHASHMAPELEMENT phme)
{
    g_assert(phme!=NULL);
    
    //MSG_DEBUG("hashmapelement_destroy(%p) called (key='%s', userdata=%p)", phme, phme->key, phme->userdata);

    // free memory for key
    if (phme->key != NULL) {
        free(phme->key);
        phme->key = NULL;
    }
    
    // call user defined functions
    if ((phme->cb_free_element != NULL) && (phme->userdata != NULL)) {
        phme->cb_free_element(phme->userdata);
        phme->cb_free_element = NULL;
        phme->userdata = NULL;
    }
    
    // clear structure
    if (phme != NULL) {
        memset(phme, 0, sizeof(HASHMAPELEMENT));
        free(phme);
        phme = NULL;
    }
    
    return;
}


PHASHMAP 
new_HashMap(unsigned int bucket, 
    void (*cb_free_element)(void *userdata)
    )
{
    PHASHMAP phm = NULL;
    
    g_assert(cb_free_element!=NULL);
    
    phm = (PHASHMAP) malloc(sizeof(HASHMAP));
    if (phm == NULL) {
        MSG_ERR("Out of memory");
        return NULL;
    }
    
    // clear structure
    memset(phm, 0, sizeof(HASHMAP));
    
    // no. of buckets (should be prime num)
    if (bucket>0) {
        phm->bucket = bucket;
    } else {
        MSG_INF("bucket not correctly setup. Using %d as default.", DEFAULT_BUCKETS);
        phm->bucket = DEFAULT_BUCKETS;
    }

    // private methods
    phm->init = hashmap_init;
    phm->destroy = hashmap_destroy;
    // hash, compare, free methods (implemented for each object)
    phm->hash = hashmap_hash_element;
    phm->compare = hashmap_compare_element;
    phm->free = hashmap_free_element;
    phm->cb_free_element = cb_free_element;
    
    // public methods
    phm->add = hashmap_add;
    phm->remove = hashmap_remove;
    phm->size = hashmap_size;
    phm->contains = hashmap_contains;
    phm->get = hashmap_get;
    phm->update = hashmap_update;
    phm->foreach = hashmap_foreach_call_function;
    
    // call constructor
    if(phm->init(phm) == -1) {
        free(phm);
        phm = NULL;
    }

    // return object
    return phm;
}


int
hashmap_init(PHASHMAP phm)
{
    CHTbl *htbl = NULL;

    if (phm==NULL) {
        return -1;
    }
    
    // get mem for structure
    htbl = (CHTbl *) malloc(sizeof(CHTbl));
    if (htbl == NULL) {
        MSG_ERR("not enough mem for hash table");
        return -1;
    }
    
    // initialize table
    if (chtbl_init(htbl, phm->bucket, phm->hash, phm->compare, phm->free) != 0) {
        MSG_ERR("could not initialize hash table");
        if (htbl!=NULL) free(htbl);
        return -1;
    }
    
    // store table pointer
    phm->hm = htbl;
    
    // return success
    return 0;
}


void
hashmap_destroy(PHASHMAP phm)
{
    CHTbl *htbl = NULL;
    
    if (phm == NULL) {
        return;
    }
    
    if (phm->hm != NULL) {
        htbl = phm->hm;
        chtbl_destroy(htbl);
        free(htbl);
        phm->hm = NULL;
    }
    
    if (phm != NULL) {
        memset(phm, 0, sizeof(HASHMAP));
        free(phm);
        phm = NULL;
    }
    
    return;
}


int
hashmap_hash_element(const void *obj)
{
    char *key = NULL;
    unsigned int crc = 0;
    
    if (obj==NULL) {
        MSG_EMERG("Hashmap HASH function called with wrong parameter ! (obj=0x%08x)", obj);
        return 0;
    }
    
    key = ((PHASHMAPELEMENT)obj)->key;
    while(*key!='\0') {
        crc += *key++;
    }
    
    return crc;
}


int
hashmap_compare_element(const void *obj1, const void *obj2)
{
    char *key1 = NULL;
    char *key2 = NULL;
    int res = 0;
    
    if ((obj1==NULL) || (obj2==NULL)) {
        MSG_EMERG("Hashmap MATCH function called with wrong parameters ! (obj1=0x%08x, obj2=0x%08x)", obj1, obj2);
        return 0;
    }
        
    if (obj1==obj2) {
        MSG_EMERG("Hashmap MATCH function called with identical parameters ! (obj1=obj2=0x%08x)", obj1);
        return 0;
    }
        
    key1 = ((PHASHMAPELEMENT)obj1)->key;
    key2 = ((PHASHMAPELEMENT)obj2)->key;

    res = strcmp(key1, key2);

    return res == 0 ? 1 : 0;
}


void
hashmap_free_element(void *userdata)
{
    PHASHMAPELEMENT phme = NULL;
    
    //MSG_DEBUG("hashmap_free_element(%p) called.", userdata);
    
    if (userdata != NULL) {
        phme = (PHASHMAPELEMENT) userdata;
        phme->destroy(phme);
        phme = NULL;
    }
    
    return;
}


int
hashmap_add(PHASHMAP phm, const char *key, void *data)
{
    PHASHMAPELEMENT phme = NULL;
    int retval;
    
    if ((phm==NULL) || (key==NULL)) {
        return -1;
    }

    phme = new_HashMapElement(phm, phm->cb_free_element, key, data);
    if (phme == NULL) {
        return -1;
    }
    
    retval = chtbl_insert(phm->hm, phme);
    
    return retval;
}


int
hashmap_remove(PHASHMAP phm, const char *key)
{
    PHASHMAPELEMENT tmp = NULL;
    PHASHMAPELEMENT phme = NULL;
    void *chtbl_data = NULL;
    int retval;
    
    if ((phm==NULL) || ((phm->hm)==NULL) || (key==NULL)) {
        return -1;
    }

    tmp = new_HashMapElement(phm, phm->cb_free_element, key, NULL);
    if (tmp == NULL) {
        return -1;
    }
    
    chtbl_data = (void *)tmp;
    retval = chtbl_remove(phm->hm, &chtbl_data);
    if (retval == 0) {
        if (chtbl_data != NULL) {
            phme = (PHASHMAPELEMENT)chtbl_data;
            if (phme != tmp) {
                if (phme != NULL) {
                    phme->destroy(phme);
                }
            }
        }
    }
    tmp->destroy(tmp); tmp=NULL;
    
    return retval;
}


int
hashmap_size(PHASHMAP phm)
{
    if ((phm==NULL) || ((phm->hm)==NULL)) {
        return -1;
    }
    
    return chtbl_size(phm->hm);
}


int
hashmap_contains(PHASHMAP phm, const char *key)
{
    PHASHMAPELEMENT tmp = NULL;
    void *data = NULL;
    int retval;
    
    if ((phm==NULL) || ((phm->hm)==NULL)) {
        return 0;
    }
    
    tmp = new_HashMapElement(phm, phm->cb_free_element, key, NULL);
    if (tmp == NULL) {
        return 0;
    }
    
    data = (void *)tmp;
    retval = chtbl_lookup(phm->hm, &data);
    tmp->destroy(tmp); tmp=NULL;
    
    return (retval==0) ? 1 : 0;
}


int
hashmap_get(PHASHMAP phm, const char *key, void **userdata)
{
    PHASHMAPELEMENT tmp = NULL;
    void *data = NULL;
    int retval;
    
    if ((phm==NULL) || ((phm->hm)==NULL)) {
        return -1;
    }
    
    tmp = new_HashMapElement(phm, phm->cb_free_element, key, NULL);
    if (tmp == NULL) {
        return -1;
    }
    
    data = (void *)tmp;
    retval = chtbl_lookup(phm->hm, &data);
    tmp->destroy(tmp); tmp=NULL;
    
    if (retval != 0) {
        *userdata = NULL;
        return -1;
    }
    
    // return data
    *userdata = ((PHASHMAPELEMENT)data)->userdata;
    return 0;
}


int
hashmap_update(PHASHMAP phm, const char *key, void *userdata)
{
    PHASHMAPELEMENT tmp = NULL;
    PHASHMAPELEMENT phme = NULL;
    void *data = NULL;
    int retval;
    
    if ((phm==NULL) || (key==NULL)) {
        return -1;
    }

    if (phm->contains(phm, key)) {
        tmp = new_HashMapElement(phm, phm->cb_free_element, key, NULL);
        if (tmp == NULL) {
            return -1;
        }
    
        data = (void *)tmp;
        retval = chtbl_lookup(phm->hm, &data);
        tmp->destroy(tmp); tmp=NULL;
        
        if (retval == 0) {
            phme = (PHASHMAPELEMENT)data;
            if (phme != NULL) {
                phme->cb_free_element(phme->userdata);
                phme->userdata = userdata;
            }
        }
    }
    
    return -1;
}


int
hashmap_foreach_call_function(PHASHMAP phm, 
    int (*func)(void *data, void *userdata), 
   void *userdata)
{
    int i=0;
    
    if ((phm==NULL) || (func==NULL) || (phm->hm==NULL)) {
        return -1;
    }

    for (i=0; i<phm->hm->buckets; i++) {
        list_for_each_call(&phm->hm->table[i], func, userdata);
    }
    
    return 0;
}

---