Pillow/src/libImaging/QuantHash.c

/*
 * The Python Imaging Library
 * $Id$
 *
 * hash tables used by the image quantizer
 *
 * history:
 * 98-09-10 tjs  Contributed
 * 98-12-29 fl   Added to PIL 1.0b1
 *
 * Written by Toby J Sargeant <tjs@longford.cs.monash.edu.au>.
 *
 * Copyright (c) 1998 by Toby J Sargeant
 * Copyright (c) 1998 by Secret Labs AB
 *
 * See the README file for information on usage and redistribution.
 */

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

#include "QuantHash.h"

typedef struct _HashNode {
    struct _HashNode *next;
    HashKey_t key;
    HashVal_t value;
} HashNode;

struct _HashTable {
    HashNode **table;
    uint32_t length;
    uint32_t count;
    HashFunc hashFunc;
    HashCmpFunc cmpFunc;
    void *userData;
};

#define MIN_LENGTH 11
#define RESIZE_FACTOR 3

static int
_hashtable_insert_node(HashTable *, HashNode *, int, int, CollisionFunc);

HashTable *
hashtable_new(HashFunc hf, HashCmpFunc cf) {
    HashTable *h;
    h = malloc(sizeof(HashTable));
    if (!h) {
        return NULL;
    }
    h->hashFunc = hf;
    h->cmpFunc = cf;
    h->length = MIN_LENGTH;
    h->count = 0;
    h->userData = NULL;
    h->table = malloc(sizeof(HashNode *) * h->length);
    if (!h->table) {
        free(h);
        return NULL;
    }
    memset(h->table, 0, sizeof(HashNode *) * h->length);
    return h;
}

static uint32_t
_findPrime(uint32_t start, int dir) {
    static int unit[] = {0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0};
    uint32_t t;
    while (start > 1) {
        if (!unit[start & 0x0f]) {
            start += dir;
            continue;
        }
        for (t = 2; t < sqrt((double)start); t++) {
            if (!start % t) {
                break;
            }
        }
        if (t >= sqrt((double)start)) {
            break;
        }
        start += dir;
    }
    return start;
}

static void
_hashtable_rehash(HashTable *h, CollisionFunc cf, uint32_t newSize) {
    HashNode **oldTable = h->table;
    uint32_t i;
    HashNode *n, *nn;
    uint32_t oldSize;
    oldSize = h->length;
    h->table = malloc(sizeof(HashNode *) * newSize);
    if (!h->table) {
        h->table = oldTable;
        return;
    }
    h->length = newSize;
    h->count = 0;
    memset(h->table, 0, sizeof(HashNode *) * h->length);
    for (i = 0; i < oldSize; i++) {
        for (n = oldTable[i]; n; n = nn) {
            nn = n->next;
            _hashtable_insert_node(h, n, 0, 0, cf);
        }
    }
    free(oldTable);
}

static void
_hashtable_resize(HashTable *h) {
    uint32_t newSize;
    uint32_t oldSize;
    oldSize = h->length;
    newSize = oldSize;
    if (h->count * RESIZE_FACTOR < h->length) {
        newSize = _findPrime(h->length / 2 - 1, -1);
    } else if (h->length * RESIZE_FACTOR < h->count) {
        newSize = _findPrime(h->length * 2 + 1, +1);
    }
    if (newSize < MIN_LENGTH) {
        newSize = oldSize;
    }
    if (newSize != oldSize) {
        _hashtable_rehash(h, NULL, newSize);
    }
}

static int
_hashtable_insert_node(
    HashTable *h, HashNode *node, int resize, int update, CollisionFunc cf) {
    uint32_t hash = h->hashFunc(h, node->key) % h->length;
    HashNode **n, *nv;
    int i;

    for (n = &(h->table[hash]); *n; n = &((*n)->next)) {
        nv = *n;
        i = h->cmpFunc(h, nv->key, node->key);
        if (!i) {
            if (cf) {
                nv->key = node->key;
                cf(h, &(nv->key), &(nv->value), node->key, node->value);
                free(node);
                return 1;
            } else {
                nv->key = node->key;
                nv->value = node->value;
                free(node);
                return 1;
            }
        } else if (i > 0) {
            break;
        }
    }
    if (!update) {
        node->next = *n;
        *n = node;
        h->count++;
        if (resize) {
            _hashtable_resize(h);
        }
        return 1;
    } else {
        return 0;
    }
}

static int
_hashtable_insert(HashTable *h, HashKey_t key, HashVal_t val, int resize, int update) {
    HashNode **n, *nv;
    HashNode *t;
    int i;
    uint32_t hash = h->hashFunc(h, key) % h->length;

    for (n = &(h->table[hash]); *n; n = &((*n)->next)) {
        nv = *n;
        i = h->cmpFunc(h, nv->key, key);
        if (!i) {
            nv->value = val;
            return 1;
        } else if (i > 0) {
            break;
        }
    }
    if (!update) {
        t = malloc(sizeof(HashNode));
        if (!t) {
            return 0;
        }
        t->next = *n;
        *n = t;
        t->key = key;
        t->value = val;
        h->count++;
        if (resize) {
            _hashtable_resize(h);
        }
        return 1;
    } else {
        return 0;
    }
}

int
hashtable_insert_or_update_computed(
    HashTable *h, HashKey_t key, ComputeFunc newFunc, ComputeFunc existsFunc) {
    HashNode **n, *nv;
    HashNode *t;
    int i;
    uint32_t hash = h->hashFunc(h, key) % h->length;

    for (n = &(h->table[hash]); *n; n = &((*n)->next)) {
        nv = *n;
        i = h->cmpFunc(h, nv->key, key);
        if (!i) {
            if (existsFunc) {
                existsFunc(h, nv->key, &(nv->value));
            } else {
                return 0;
            }
            return 1;
        } else if (i > 0) {
            break;
        }
    }
    t = malloc(sizeof(HashNode));
    if (!t) {
        return 0;
    }
    t->key = key;
    t->next = *n;
    *n = t;
    if (newFunc) {
        newFunc(h, t->key, &(t->value));
    } else {
        free(t);
        return 0;
    }
    h->count++;
    _hashtable_resize(h);
    return 1;
}

int
hashtable_insert(HashTable *h, HashKey_t key, HashVal_t val) {
    return _hashtable_insert(h, key, val, 1, 0);
}

void
hashtable_foreach_update(HashTable *h, IteratorUpdateFunc i, void *u) {
    HashNode *n;
    uint32_t x;

    if (h->table) {
        for (x = 0; x < h->length; x++) {
            for (n = h->table[x]; n; n = n->next) {
                i(h, n->key, &(n->value), u);
            }
        }
    }
}

void
hashtable_foreach(HashTable *h, IteratorFunc i, void *u) {
    HashNode *n;
    uint32_t x;

    if (h->table) {
        for (x = 0; x < h->length; x++) {
            for (n = h->table[x]; n; n = n->next) {
                i(h, n->key, n->value, u);
            }
        }
    }
}

void
hashtable_free(HashTable *h) {
    HashNode *n, *nn;
    uint32_t i;

    if (h->table) {
        for (i = 0; i < h->length; i++) {
            for (n = h->table[i]; n; n = nn) {
                nn = n->next;
                free(n);
            }
        }
        free(h->table);
    }
    free(h);
}

void
hashtable_rehash_compute(HashTable *h, CollisionFunc cf) {
    _hashtable_rehash(h, cf, h->length);
}

int
hashtable_lookup(const HashTable *h, const HashKey_t key, HashVal_t *valp) {
    uint32_t hash = h->hashFunc(h, key) % h->length;
    HashNode *n;
    int i;

    for (n = h->table[hash]; n; n = n->next) {
        i = h->cmpFunc(h, n->key, key);
        if (!i) {
            *valp = n->value;
            return 1;
        } else if (i > 0) {
            break;
        }
    }
    return 0;
}

uint32_t
hashtable_get_count(const HashTable *h) {
    return h->count;
}

void *
hashtable_get_user_data(const HashTable *h) {
    return h->userData;
}

void *
hashtable_set_user_data(HashTable *h, void *data) {
    void *r = h->userData;
    h->userData = data;
    return r;
}