path: root/src/pds.h

#ifndef _PDS_H
#define _PDS_H

/* pointer data structures */
/* Simple stack with psuh/pop */
/* Simple hashmap with char * as key */

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

#ifdef __cplusplus
extern "C"
{
#endif

#ifndef PDSDEF
#ifdef PDS_STATIC
#define PDSDEF static
#else
#define PDSDEF extern
#endif
#endif

#define PSTACK_RESIZE_FACTOR 2
#define PSTACK_INIT_CAPACITY 16

  typedef struct pstack
  {
    uint64_t cap;
    uint64_t size;
    uint64_t stride;
    void*    data;
  } pstack;

  /* Exported API */
  /* Stack */
  PDSDEF void* _pstack_create(uint64_t length, uint64_t stride);
#ifndef pstack_create
#define pstack_create(type) _pstack_create(PSTACK_INIT_CAPACITY, sizeof(type));
#endif

#ifndef pstack_create_ex
#define pstack_create_ex(type, cap) _pstack_create(cap, sizeof(type));
#endif

  PDSDEF void* _pstack_push(void* list, const void* value_ptr);
#ifndef pstack_push
#define pstack_push(list, val)                                                 \
  do {                                                                         \
    typeof(val) tmp = val;                                                     \
    list            = _pstack_push(list, &tmp);                                \
  } while (0);
#endif

  PDSDEF uint64_t pstack_capacity(void* list);
  PDSDEF uint64_t pstack_size(void* list);
  PDSDEF uint64_t pstack_stride(void* list);
  PDSDEF void     pstack_length_set(void* list, uint64_t value);
  PDSDEF void     pstack_destroy(void* list);
  PDSDEF void*    pstack_resize(void* list);

  /* Hashmap */

  typedef struct phash
  {
    uint64_t element_size;
    uint32_t element_count;
    int8_t   is_pointer_type;
    void*    memory;
  } phash;

  /* Exported API */

  PDSDEF void   phash_create(uint64_t element_size,
                             uint32_t element_count,
                             void*    memory,
                             int8_t   is_pointer_type,
                             phash*   out_phash);
  PDSDEF void   phash_destroy(phash* table);
  PDSDEF int8_t phash_set(phash* table, const char* name, void* value);
  PDSDEF int8_t phash_set_ptr(phash* table, const char* name, void** value);
  PDSDEF int8_t phash_get(phash* table, const char* name, void* out_value);
  PDSDEF int8_t phash_get_ptr(phash* table, const char* name, void** out_value);

#ifdef __cplusplus
}
#endif

/* End header file */
#endif /* _PDS_H */

#ifdef PDS_IMPLEMENTATION

PDSDEF void*
_pstack_create(uint64_t length, uint64_t stride)
{
  uint64_t header_size = sizeof(pstack);
  uint64_t list_size   = length * stride;

  pstack* list = (pstack*)malloc(header_size + list_size);
  list->cap    = length;
  list->size   = 0;
  list->stride = stride;
  list->data   = NULL;

  return (void*)((uint8_t*)list + header_size);
}

PDSDEF uint64_t
pstack_capacity(void* list)
{
  uint64_t header_size = sizeof(pstack);
  pstack*  header      = (pstack*)((uint8_t*)list - header_size);
  return header->cap;
}

PDSDEF uint64_t
pstack_size(void* list)
{
  uint64_t header_size = sizeof(pstack);
  pstack*  header      = (pstack*)((uint8_t*)list - header_size);
  return header->size;
}

PDSDEF uint64_t
pstack_stride(void* list)
{
  uint64_t header_size = sizeof(pstack);
  pstack*  header      = (pstack*)((uint8_t*)list - header_size);
  return header->stride;
}

PDSDEF void
pstack_length_set(void* list, uint64_t value)
{
  uint64_t header_size = sizeof(pstack);
  pstack*  header      = (pstack*)((uint8_t*)list - header_size);
  header->size         = value;
}

PDSDEF void
pstack_destroy(void* list)
{
  if (list) {
    uint64_t header_size = sizeof(pstack);
    pstack*  header      = (pstack*)((uint8_t*)list - header_size);
    free(header);
  }
}

PDSDEF void*
pstack_resize(void* list)
{
  uint64_t header_size = sizeof(pstack);
  pstack*  header      = (pstack*)((uint8_t*)list - header_size);
  if (header->cap == 0) {
    fprintf(stderr,
            "pstack_resize called on an list with 0 capacity. This should not "
            "be possible.\n");
    return 0;
  }
  void* temp =
    _pstack_create((PSTACK_RESIZE_FACTOR * header->cap), header->stride);

  pstack* new_header = (pstack*)((uint8_t*)temp - header_size);
  new_header->size   = header->size;

  memcpy(temp, list, header->size * header->stride);

  pstack_destroy(list);
  return temp;
}

PDSDEF void*
_pstack_push(void* list, const void* value_ptr)
{
  uint64_t header_size = sizeof(pstack);
  pstack*  header      = (pstack*)((uint8_t*)list - header_size);
  if (header->size >= header->cap) {
    list = pstack_resize(list);
  }
  header = (pstack*)((uint8_t*)list - header_size);

  uint64_t addr = (uint64_t)list;
  addr += (header->size * header->stride);
  memcpy((void*)addr, value_ptr, header->stride);
  pstack_length_set(list, header->size + 1);
  return list;
}

PDSDEF int
pstack_pop(void* list, void* dest)
{
  uint64_t size   = pstack_size(list);
  uint64_t stride = pstack_stride(list);
  if (size < 1) {
    // fprintf(stderr, "pstack_pop called on an empty pstack. Nothing to be
    // done.\n");
    return 1;
  }
  uint64_t addr = (uint64_t)list;
  addr += ((size - 1) * stride);
  memcpy(dest, (void*)addr, stride);
  pstack_length_set(list, size - 1);
  return 0;
}

/* int */
/* main() */
/* { */
/*   int* lst = pstack_create(int); */
/*   pstack_push(lst, 1); */
/*   pstack_push(lst, 2); */

/*   int i; */
/*   while (!pstack_pop(lst, &i)) { */
/*     printf("%d\n", i); */
/*   } */

/*   char** lst2 = pstack_create(char*); */
/*   pstack_push(lst2, &"Hello"); */
/*   pstack_push(lst2, &"you!"); */

/*   char *s; */
/*   while (!pstack_pop(lst2, &s)) { */
/*     printf("%s\n", s); */
/*   } */

/*   pstack_destroy(lst); */
/*   pstack_destroy(lst2); */

/*   return 0; */
/* }   */

static uint64_t
hash_name(const char* name, uint32_t element_count)
{
  // A multipler to use when generating a hash. Prime to hopefully avoid
  // collisions.
  static const uint64_t multiplier = 97;

  unsigned const char* us;
  uint64_t             hash = 0;

  for (us = (unsigned const char*)name; *us; us++) {
    hash = hash * multiplier + *us;
  }

  // Mod it against the size of the table.
  hash %= element_count;

  return hash;
}

PDSDEF void
phash_create(uint64_t element_size,
             uint32_t element_count,
             void*    memory,
             int8_t   is_pointer_type,
             phash*   out_phash)
{
  if (!memory || !out_phash) {
    fprintf(
      stderr,
      "phash_create failed! Pointer to memory and out_phash are required.\n");
    return;
  }
  if (!element_count || !element_size) {
    fprintf(
      stderr,
      "element_size and element_count must be a positive non-zero value.\n");
    return;
  }

  out_phash->memory          = memory;
  out_phash->element_count   = element_count;
  out_phash->element_size    = element_size;
  out_phash->is_pointer_type = is_pointer_type;
  memset(out_phash->memory, 0, element_size * element_count);
}

PDSDEF void
phash_destroy(phash* table)
{
  if (table) {
    memset(table->memory, 0, table->element_size * table->element_count);
  }
}

PDSDEF int8_t
phash_set(phash* table, const char* name, void* value)
{
  if (!table || !name || !value) {
    fprintf(stderr, "phash_set requires table, name and value to exist.");
    return 0;
  }
  if (table->is_pointer_type) {
    fprintf(stderr,
            "phash_set should not be used with tables that have pointer types. "
            "Use phash_set_ptr instead.\n");
    return 0;
  }

  uint64_t hash = hash_name(name, table->element_count);
  memcpy(
    table->memory + (table->element_size * hash), value, table->element_size);
  return 1;
}

PDSDEF int8_t
phash_set_ptr(phash* table, const char* name, void** value)
{
  if (!table || !name) {
    fprintf(stderr, "phash_set_ptr requires table and name  to exist.\n");
    return 0;
  }
  if (!table->is_pointer_type) {
    fprintf(stderr,
            "phash_set_ptr should not be used with tables that do not have "
            "pointer types. Use phash_set instead.\n");
    return 0;
  }

  uint64_t hash                 = hash_name(name, table->element_count);
  ((void**)table->memory)[hash] = value ? *value : 0;
  return 1;
}

PDSDEF int8_t
phash_get(phash* table, const char* name, void* out_value)
{
  if (!table || !name || !out_value) {
    fprintf(stderr, "phash_get requires table, name and out_value to exist.\n");
    return 0;
  }
  if (table->is_pointer_type) {
    fprintf(stderr,
            "phash_get should not be used with tables that have pointer types. "
            "Use phash_set_ptr instead.\n");
    return 0;
  }

  uint64_t hash = hash_name(name, table->element_count);
  memcpy(out_value,
         table->memory + (table->element_size * hash),
         table->element_size);
  return 1;
}

PDSDEF int8_t
phash_get_ptr(phash* table, const char* name, void** out_value)
{
  if (!table || !name || !out_value) {
    fprintf(stderr,
            "phash_get_ptr requires table, name and out_value to exist.\n");
    return 0;
  }
  if (!table->is_pointer_type) {
    fprintf(stderr,
            "phash_get_ptr should not be used with tables that do not have "
            "pointer types. Use phash_get instead.\n");
    return 0;
  }

  uint64_t hash = hash_name(name, table->element_count);
  *out_value    = ((void**)table->memory)[hash];
  return *out_value != 0;
}

/* struct test */
/* { */
/*   int  a; */
/*   char b[15]; */
/* }; */

/* int */
/* main() */
/* { */
/*   phash tbl; */
/*   int   mem[2]; */
/*   phash_create(sizeof(int), 2, &mem, 0, &tbl); */

/*   int x = 2; */
/*   phash_set(&tbl, "Val", &x); */
/*   x = 3; */
/*   phash_set(&tbl, "Val1", &x); */
/*   x = 4; */
/*   phash_set(&tbl, "Val2", &x); */

/*   int y; */
/*   phash_get(&tbl, "Val", &y); */
/*   printf("%d\n", y); */
/*   phash_get(&tbl, "Val1", &y); */
/*   printf("%d\n", y); */
/*   phash_get(&tbl, "Val2", &y); */
/*   printf("%d\n", y); */

/*   phash_destroy(&tbl); */

/*   phash       tbl2; */
/*   struct test mem2[15]; */
/*   phash_create(sizeof(struct test), 15, &mem2, 1, &tbl2); */

/*   struct test  a  = { .a = 5, .b = "Yooo" }; */
/*   struct test* aa = &a; */
/*   phash_set_ptr(&tbl2, "aha", (void**)&aa); */

/*   struct test* get; */
/*   phash_get_ptr(&tbl2, "aha", (void**)&get); */
/*   printf("{ a: %d, b: %s }\n", get->a, get->b); */

/*   return 0; */
/* } */

#endif /* PDS_IMPLEMENTATION */