libvieter/src/heap/vieter_heap.c

#include "vieter_heap_internal.h"

#include <stdlib.h>

vieter_heap *vieter_heap_init() {
  vieter_heap *heap = calloc(1, sizeof(vieter_heap));

  pthread_rwlock_init(&heap->lock, NULL);

  return heap;
}

uint64_t vieter_heap_size(vieter_heap *heap) {
  uint64_t size = 0;
  vieter_heap_node *tree = heap->tree;

  while (tree != NULL) {
    size |= (uint64_t)1 << tree->order;

    tree = tree->ptr.next_tree;
  }

  return size;
}

void vieter_heap_free(vieter_heap *heap) {
  vieter_heap_node *tree = heap->tree;
  vieter_heap_node *next;

  while (tree != NULL) {
    next = tree->ptr.next_tree;
    vieter_heap_tree_free(tree);
    tree = next;
  }

  free(heap);
}

vieter_heap_error vieter_heap_insert(vieter_heap *heap, uint64_t key,
                                     void *data) {
  vieter_heap_node *new_tree = vieter_heap_node_init();
  new_tree->key = key;
  new_tree->data = data;
  new_tree->order = 0;

  if (heap->tree == NULL) {
    heap->tree = new_tree;
  } else {
    heap->tree = vieter_heap_tree_merge(heap->tree, new_tree);
  }

  return vieter_heap_ok;
}

vieter_heap_error vieter_heap_pop(void **out, vieter_heap *heap) {
  if (heap->tree == NULL) {
    return vieter_heap_empty;
  }

  heap->tree = vieter_heap_tree_pop(out, heap->tree);

  return vieter_heap_ok;
}

vieter_heap_error vieter_heap_peek(void **out, vieter_heap *heap) {
  if (heap->tree == NULL) {
    return vieter_heap_empty;
  }

  vieter_heap_node *tree = heap->tree;
  uint64_t smallest_key = tree->key;
  *out = tree->data;

  while (tree->ptr.next_tree != NULL) {
    tree = tree->ptr.next_tree;

    if (tree->key < smallest_key) {
      smallest_key = tree->key;
      *out = tree->data;
    }
  }

  return vieter_heap_ok;
}

int vieter_heap_rlock(vieter_heap *heap) {
  return pthread_rwlock_rdlock(&heap->lock);
}

int vieter_heap_wlock(vieter_heap *heap) {
  return pthread_rwlock_wrlock(&heap->lock);
}

int vieter_heap_unlock(vieter_heap *heap) {
  return pthread_rwlock_unlock(&heap->lock);
}