source: trunk/greenstone3-extensions/vishnu/src/ckindexer/hash.c@ 8189

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>


#include "hash.h"

int prime(size_t n)
{
        size_t i;

        if (n % 2 == 0)
                return (n==2);
        if (n % 3 == 0)
                return (n==3);
        if (n % 5 == 0)
                return (n==5);
        for (i=7; i*i <= n; i+=2)
                if (n % i == 0)
                        return 0;
        return 1;
}



size_t getBiggerPrime(size_t val)
{
    while(prime(++val)==0);
    return val;
}


size_t hashSize;

HashPtr *initHash(size_t val)
{
    size_t c;
    HashPtr *table;
    hashSize=getBiggerPrime(val+(val/2));
    table =(HashPtr *)malloc(sizeof(HashPtr)*hashSize);
    if(table==NULL)
    {
        hashSize=getBiggerPrime(val);
        fprintf(stderr,"Having to use smaller hash %d table size\n",
                 hashSize);
        table =(HashPtr *)malloc(sizeof(HashPtr)*hashSize);
    }
    assert(table);
    for(c=0;c<hashSize;c++) table[c]=NULL;
    return table;
}



size_t hash(char *s)
{
    size_t h = 0;
    while (*s)
       h+=*s++;
    return abs(h % hashSize);
}


HashNode *hRetrieve(HashPtr *table, char *target)
{
    return hSeqSearch(table[hash(target)],target);
}

void hInsert(HashPtr *table, HashNode *node)
{
    int h;
    h= hash(node->inf.key);
    node->next=table[h];
    table[h]=node;
}

HashNode *hSeqSearch(HashPtr node, char *target)
{
    HashPtr location;
    for (location=node;location!=NULL;location=location->next)
        if (!strcmp(location->inf.key,target)) return location;
    return NULL;
}

void vapeHashNode(HashPtr node)
{
    if(node->next) vapeHashNode(node->next);
    free(node);
}

void vapeHash(HashPtr *table)
{
    size_t c;
    for (c=0;c<hashSize;c++)
        if(table[c]) vapeHashNode(table[c]);
    free(table);
}