libtdata/lib/usrtc.c

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 2; tab-width: 2 -*- */
/*
 * usrtc.c
 * Copyright (C) 2006, 2013 Alexander Vdolainen <avdolainen@zoho.com>
 *
 * libtdata is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * libtdata is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.";
 */

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

#include <tdata/usrtc.h>
#include <tdata/macro.h>

/* so, if you want to add your implementation of the data
 * structure please add this here, like the following.
 */

#define MAX_IMPL  4

extern usrtc_functions_t usrtc_list_fu;
extern usrtc_functions_t usrtc_tree_fu;
extern usrtc_functions_t usrtc_redblack_fu;
extern usrtc_functions_t usrtc_splay_fu;
extern usrtc_functions_t usrtc_avl_fu;

static usrtc_functions_t *impl_table[] = {
  &usrtc_list_fu,&usrtc_tree_fu,
  &usrtc_redblack_fu,&usrtc_splay_fu,
  &usrtc_avl_fu };

static usrtc_node_t *default_node_alloc(void *context)
{
  return malloc(sizeof *default_node_alloc(context));
}

static void default_node_free(void *context, usrtc_node_t *node)
{
  free(node);
	return;
}

void usrtc_init(usrtc_t *us, int impl, usrtc_count_t maxcount,
								usrtc_compare_t compare)
{
  if(!us)
    return;
  if(impl>MAX_IMPL)
    return;

  us->nodecount = 0;
  us->maxcount = maxcount;
  us->dupes_allowed = 0;
  us->compare = compare;
  us->node_alloc = default_node_alloc;
  us->node_free = default_node_free;
  us->context = 0;
  us->futable = impl_table[impl];
  us->futable->usrtc_init(us);
	return;
}

usrtc_t *usrtc_create(int impl, usrtc_count_t maxcount,
											usrtc_compare_t compare)
{
  usrtc_t *newrtc = (usrtc_t *) malloc(sizeof *newrtc);

  if(newrtc)
    usrtc_init(newrtc, impl, maxcount, compare);

  return newrtc;
}

void usrtc_destroy(usrtc_t *us)
{
  /*assert(usrtc_isempty(us));*/
  if(!us)
    return;

  free(us);
	return;
}

void usrtc_convert_to(usrtc_t *us,int impl)
{
  if(impl_table[impl] == us->futable)
    return;

  if((us->futable->usrtc_type == usrtc_bst) &&
		 (impl == USRTC_BST || impl == USRTC_SPLAY)) {
    us->futable = impl_table[impl];
    return;
  }

  us->futable->usrtc_convert_to_list(us);
  us->futable = impl_table[impl];

  if(impl_table[impl]->usrtc_type == usrtc_lst)
    return;

  us->futable->usrtc_convert_from_list(us);
	return;
}

usrtc_count_t usrtc_count(usrtc_t *us)
{
  return us->nodecount;
}

int usrtc_isempty(usrtc_t *us)
{
  return us->nodecount == 0;
}

int usrtc_isfull(usrtc_t *us)
{
  return us->nodecount == us->maxcount;
}

int usrtc_alloc_insert(usrtc_t *us, const void *key, void *data)
{
  usrtc_node_t *newnode = us->node_alloc(us->context);

  if(newnode != NULL) {
    newnode->data = data;
    us->futable->usrtc_insert(us, newnode, key);
  }

  return newnode != NULL;
}

void usrtc_delete_free(usrtc_t *us, usrtc_node_t *node)
{
  us->futable->usrtc_delete(us, node);
  us->node_free(us->context, node);
	return;
}

void usrtc_set_allocator(usrtc_t *us, usrtc_node_alloc_t alloc,
												 usrtc_node_free_t n_free, void *context)
{
  us->node_alloc = alloc;
  us->node_free = n_free;
  us->context = context;
	return;
}

void usrtc_allow_dupes(usrtc_t *us)
{
  /*assert(us->nodecount == 0);*/
  if(!us->nodecount)
    return;

  us->dupes_allowed = 1;
	return;
}

void usrtc_node_init(usrtc_node_t *node, void *data)
{
  node->data = data;
  node->impl_specific.usrtc_dummy = 0;
  node->left = NULL;
  node->right = NULL;
  node->parent = NULL;
}

usrtc_node_t *usrtc_node_create(void *data)
{
  usrtc_node_t *newnode = (usrtc_node_t *) malloc(sizeof *newnode);

  if(newnode != NULL)
    newnode->data = data;

  return newnode;
}

void usrtc_node_destroy(usrtc_node_t *node)
{
  free(node);
	return;
}

void *usrtc_node_getdata(usrtc_node_t *node)
{
  return node->data;
}

void usrtc_node_setdata(usrtc_node_t *node, void *data)
{
  node->data = data;
	return;
}

const void *usrtc_node_getkey(usrtc_node_t *node)
{
  return node->key;
}

void usrtc_insert(usrtc_t *us, usrtc_node_t *node, const void *key)
{
  us->futable->usrtc_insert(us, node, key);
	return;
}

void usrtc_delete(usrtc_t *us, usrtc_node_t *node)
{
  us->futable->usrtc_delete(us, node);
	return;
}

usrtc_node_t *usrtc_lookup(usrtc_t *us, const void *key)
{
  return us->futable->usrtc_lookup(us, key);
}

usrtc_node_t *usrtc_lower_bound(usrtc_t *us, const void *key)
{
  return us->futable->usrtc_lower_bound(us, key);
}

usrtc_node_t *usrtc_upper_bound(usrtc_t *us, const void *key)
{
  return us->futable->usrtc_upper_bound(us, key);
}

usrtc_node_t *usrtc_first(usrtc_t *us)
{
  return us->futable->usrtc_first(us);
}

usrtc_node_t *usrtc_last(usrtc_t *us)
{
  return us->futable->usrtc_last(us);
}

usrtc_node_t *usrtc_next(usrtc_t *us, usrtc_node_t *node)
{
  return us->futable->usrtc_next(us, node);
}

usrtc_node_t *usrtc_prev(usrtc_t *us, usrtc_node_t *node)
{
  return us->futable->usrtc_prev(us, node);
}