hash.c

Go to the documentation of this file.

#include "config.h"
#include <ctype.h>
#include <stdbool.h>
#include "hash.h"
#include "memory.h"
#include "string2.h"

#define SOME_PRIME 149711

static size_t gen_string_hash(union HashKey key, size_t n)
{
  size_t h = 0;
  const unsigned char *s = (const unsigned char *) key.strkey;

  while (*s)
    h += ((h << 7) + *s++);
  h = (h * SOME_PRIME) % n;

  return h;
}

static int cmp_string_key(union HashKey a, union HashKey b)
{
  return mutt_str_strcmp(a.strkey, b.strkey);
}

static size_t gen_case_string_hash(union HashKey key, size_t n)
{
  size_t h = 0;
  const unsigned char *s = (const unsigned char *) key.strkey;

  while (*s)
    h += ((h << 7) + tolower(*s++));
  h = (h * SOME_PRIME) % n;

  return h;
}

static int cmp_case_string_key(union HashKey a, union HashKey b)
{
  return mutt_str_strcasecmp(a.strkey, b.strkey);
}

static size_t gen_int_hash(union HashKey key, size_t n)
{
  return key.intkey % n;
}

static int cmp_int_key(union HashKey a, union HashKey b)
{
  if (a.intkey == b.intkey)
    return 0;
  if (a.intkey < b.intkey)
    return -1;
  return 1;
}

static struct Hash *hash_new(size_t nelem)
{
  struct Hash *table = mutt_mem_calloc(1, sizeof(struct Hash));
  if (nelem == 0)
    nelem = 2;
  table->nelem = nelem;
  table->table = mutt_mem_calloc(nelem, sizeof(struct HashElem *));
  return table;
}

static struct HashElem *union_hash_insert(struct Hash *table, union HashKey key,
                                          int type, void *data)
{
  if (!table)
    return NULL;

  struct HashElem *he = mutt_mem_malloc(sizeof(struct HashElem));
  unsigned int h = table->gen_hash(key, table->nelem);
  he->key = key;
  he->data = data;
  he->type = type;

  if (table->allow_dups)
  {
    he->next = table->table[h];
    table->table[h] = he;
  }
  else
  {
    struct HashElem *tmp = NULL, *last = NULL;

    for (tmp = table->table[h], last = NULL; tmp; last = tmp, tmp = tmp->next)
    {
      const int r = table->cmp_key(tmp->key, key);
      if (r == 0)
      {
        FREE(&he);
        return NULL;
      }
      if (r > 0)
        break;
    }
    if (last)
      last->next = he;
    else
      table->table[h] = he;
    he->next = tmp;
  }
  return he;
}

static struct HashElem *union_hash_find_elem(const struct Hash *table, union HashKey key)
{
  if (!table)
    return NULL;

  int hash = table->gen_hash(key, table->nelem);
  struct HashElem *he = table->table[hash];
  for (; he; he = he->next)
  {
    if (table->cmp_key(key, he->key) == 0)
      return he;
  }
  return NULL;
}

static void *union_hash_find(const struct Hash *table, union HashKey key)
{
  if (!table)
    return NULL;
  struct HashElem *he = union_hash_find_elem(table, key);
  if (he)
    return he->data;
  return NULL;
}

static void union_hash_delete(struct Hash *table, union HashKey key, const void *data)
{
  if (!table)
    return;

  int hash = table->gen_hash(key, table->nelem);
  struct HashElem *he = table->table[hash];
  struct HashElem **last = &table->table[hash];

  while (he)
  {
    if (((data == he->data) || !data) && (table->cmp_key(he->key, key) == 0))
    {
      *last = he->next;
      if (table->free_hdata)
        table->free_hdata(he->type, he->data, table->hdata);
      if (table->strdup_keys)
        FREE(&he->key.strkey);
      FREE(&he);

      he = *last;
    }
    else
    {
      last = &he->next;
      he = he->next;
    }
  }
}

struct Hash *mutt_hash_new(size_t nelem, HashFlags flags)
{
  struct Hash *table = hash_new(nelem);
  if (flags & MUTT_HASH_STRCASECMP)
  {
    table->gen_hash = gen_case_string_hash;
    table->cmp_key = cmp_case_string_key;
  }
  else
  {
    table->gen_hash = gen_string_hash;
    table->cmp_key = cmp_string_key;
  }
  if (flags & MUTT_HASH_STRDUP_KEYS)
    table->strdup_keys = true;
  if (flags & MUTT_HASH_ALLOW_DUPS)
    table->allow_dups = true;
  return table;
}

struct Hash *mutt_hash_int_new(size_t nelem, HashFlags flags)
{
  struct Hash *table = hash_new(nelem);
  table->gen_hash = gen_int_hash;
  table->cmp_key = cmp_int_key;
  if (flags & MUTT_HASH_ALLOW_DUPS)
    table->allow_dups = true;
  return table;
}

void mutt_hash_set_destructor(struct Hash *table, hashelem_free_t fn, intptr_t fn_data)
{
  if (!table)
    return;
  table->free_hdata = fn;
  table->hdata = fn_data;
}

struct HashElem *mutt_hash_typed_insert(struct Hash *table, const char *strkey,
                                        int type, void *data)
{
  if (!table || !strkey)
    return NULL;

  union HashKey key;
  key.strkey = table->strdup_keys ? mutt_str_strdup(strkey) : strkey;
  return union_hash_insert(table, key, type, data);
}

struct HashElem *mutt_hash_insert(struct Hash *table, const char *strkey, void *data)
{
  return mutt_hash_typed_insert(table, strkey, -1, data);
}

struct HashElem *mutt_hash_int_insert(struct Hash *table, unsigned int intkey, void *data)
{
  if (!table)
    return NULL;
  union HashKey key;
  key.intkey = intkey;
  return union_hash_insert(table, key, -1, data);
}

void *mutt_hash_find(const struct Hash *table, const char *strkey)
{
  if (!table || !strkey)
    return NULL;
  union HashKey key;
  key.strkey = strkey;
  return union_hash_find(table, key);
}

struct HashElem *mutt_hash_find_elem(const struct Hash *table, const char *strkey)
{
  if (!table || !strkey)
    return NULL;
  union HashKey key;
  key.strkey = strkey;
  return union_hash_find_elem(table, key);
}

void *mutt_hash_int_find(const struct Hash *table, unsigned int intkey)
{
  if (!table)
    return NULL;
  union HashKey key;
  key.intkey = intkey;
  return union_hash_find(table, key);
}

struct HashElem *mutt_hash_find_bucket(const struct Hash *table, const char *strkey)
{
  if (!table || !strkey)
    return NULL;

  union HashKey key;

  key.strkey = strkey;
  int hash = table->gen_hash(key, table->nelem);
  return table->table[hash];
}

void mutt_hash_delete(struct Hash *table, const char *strkey, const void *data)
{
  if (!table || !strkey)
    return;
  union HashKey key;
  key.strkey = strkey;
  union_hash_delete(table, key, data);
}

void mutt_hash_int_delete(struct Hash *table, unsigned int intkey, const void *data)
{
  if (!table)
    return;
  union HashKey key;
  key.intkey = intkey;
  union_hash_delete(table, key, data);
}

void mutt_hash_free(struct Hash **ptr)
{
  if (!ptr || !*ptr)
    return;

  struct Hash *hash = *ptr;
  struct HashElem *elem = NULL, *tmp = NULL;

  for (size_t i = 0; i < hash->nelem; i++)
  {
    for (elem = hash->table[i]; elem;)
    {
      tmp = elem;
      elem = elem->next;
      if (hash->free_hdata)
        hash->free_hdata(tmp->type, tmp->data, hash->hdata);
      if (hash->strdup_keys)
        FREE(&tmp->key.strkey);
      FREE(&tmp);
    }
  }
  FREE(&hash->table);
  FREE(ptr);
}

struct HashElem *mutt_hash_walk(const struct Hash *table, struct HashWalkState *state)
{
  if (!table || !state)
    return NULL;

  if (state->last && state->last->next)
  {
    state->last = state->last->next;
    return state->last;
  }

  if (state->last)
    state->index++;

  while (state->index < table->nelem)
  {
    if (table->table[state->index])
    {
      state->last = table->table[state->index];
      return state->last;
    }
    state->index++;
  }

  state->index = 0;
  state->last = NULL;
  return NULL;
}