hashmap.h File Reference

Contains the structures and procedures for hashmap-related operations. More...

#include "task.h"

Go to the source code of this file.

Classes
struct	Entry
	Linked list node definition of an entry in a hash map. More...
struct	HashMap
	Hashmap structure. More...

Typedefs
typedef struct Entry	Entry
	Linked list node definition of an entry in a hash map.
typedef struct HashMap	HashMap
	Hashmap structure.

Functions
HashMap *	hashmap_create (size_t table_size)
	Creates a hashmap of a fixed size.
void	hashmap_set (HashMap *map, char *key, void *value)
	Adds an entry to a hashmap by a key string and value.
void *	hashmap_get (HashMap *map, char *key)
	Finds an entry in a non-empty hashmap by a key.
void	hashmap_elem_remove (HashMap *map, char *key)
	Removes an entry in a hashmap by its key.
void	hashmap_destroy (HashMap *map)
	Frees a hashmap to memory.

Detailed Description

Contains the structures and procedures for hashmap-related operations.

Definition in file hashmap.h.

Typedef Documentation

HashMap

typedef struct HashMap HashMap

Hashmap structure.

Contains an array of Entry pointer nodes with a fixed size

Function Documentation

hashmap_create()

HashMap * hashmap_create

(

size_t

table_size

)

Creates a hashmap of a fixed size.

Parameters

table_size

Size of the hash table

Returns

Pointer to the created hashmap

Definition at line 32 of file hashmap.c.

{
    HashMap* map = (HashMap*)malloc(sizeof(HashMap));
    // Allocate memory for the array of buckets
    map->buckets = (Entry**)calloc(table_size, sizeof(Entry*));
 
    map->table_size = table_size;
    return map;
}

hashmap_destroy()

void hashmap_destroy

(

HashMap *

map

)

Frees a hashmap to memory.

Parameters

map	Pointer to the hashmap

Definition at line 132 of file hashmap.c.

{
  size_t table_size = map->table_size;
  for (size_t i = 0; i < table_size; i++) {
    Entry* current = map->buckets[i];
    while (current != NULL) {
      Entry* temp = current;
      current = current->next;
      free(temp->key); // Free the duplicated key
      free(temp);      // Free the entry node
    }
  }
  free(map->buckets); // Free the buckets array
  free(map);          // Free the map structure
}

hashmap_elem_remove()

void hashmap_elem_remove	(	HashMap *	map,
		char *	key )

Removes an entry in a hashmap by its key.

Parameters

map	Pointer to the hashmap
key	Pointer to the key string

Definition at line 102 of file hashmap.c.

{
  unsigned long hash = hash_function(key);  
  size_t index = hash % map->table_size;
  Entry* current = map->buckets[index];
  Entry* prev = NULL;
  while (current != NULL)
  {
    if (strcmp(current->key, key) == 0)
    {
      break;
    }
    prev = current;
    current = current->next;
  }
  if (current == NULL)
  {
    printf("Hashmap error: delete node cannot be found\n");
    return;
  }
  if (prev == NULL)
  {
    map->buckets[index] = current->next;
  } else {
    prev->next = current->next; 
  }
  free(current->key);
  free(current);
}

hashmap_get()

void * hashmap_get	(	HashMap *	map,
		char *	key )

Finds an entry in a non-empty hashmap by a key.

Utilizes the standard approach of hashing and appending to non-empty entries.

Parameters

map	Pointer to the hashmap
key	Pointer to the key string

Returns

Pointer to the found element. NULL if not found

Definition at line 80 of file hashmap.c.

{
  if (map->table_size <= 0) // invalid table size fallback
  {
    printf("Hashmap error: Invalid table size (%zu)\n", map->table_size);
    return NULL;
  }
 
  unsigned long hash = hash_function(key);
  int index = hash % map->table_size;
 
  Entry* current = map->buckets[index];
  while (current != NULL) {
    if (strcmp(current->key, key) == 0) {
      return current->value; // Key found
    }
    current = current->next;
  }
 
  return NULL;
}

hashmap_set()

void hashmap_set	(	HashMap *	map,
		char *	key,
		void *	value )

Adds an entry to a hashmap by a key string and value.

Parameters

map	Pointer to the hashmap
key	Pointer to the key string
value	Pointer to the value

Note

This function utilizes the standard approach in inserting elements into the hash table. The private hash function is used for transforming the key into a hash. The modulo of the hash with the table size is the unique index of the key.

There are two cases in setting entries:

• (Case 1) The entry is empty, where it is replaced with the valid entry
• (Case 2) An existing entry exists. Append to the end of the linked list.

Definition at line 42 of file hashmap.c.

{
  unsigned long hash = hash_function(key);
  int index = hash % map->table_size;

 
  // Case 2: with hash collision
  Entry* current = map->buckets[index];
  while (current != NULL) {
    if (strcmp(current->key, key) == 0) {
      current->value = value;
      return;
    }
    current = current->next;
  }
 
  // Case 1: no hash collision
  Entry* new_entry = (Entry*)malloc(sizeof(Entry));
  new_entry->key = strdup(key); // Use strdup to copy the key
  new_entry->value = value;
  new_entry->next = NULL;
 
  new_entry->next = map->buckets[index];
  map->buckets[index] = new_entry;
}