public/libtdata
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

..

No commits in common. "master" and "0.2.4" have entirely different histories.
master ... 0.2.4

22 changed files with 554 additions and 810 deletions

2
Makefile.am

@ -7,7 +7,7 @@ if BUILD_TESTS
EXTRA += tests EXTRA += tests
endif endif
SUBDIRS = include lib man $(EXTRA) SUBDIRS = include lib $(EXTRA)
libtdatadocdir = ${prefix}/doc/libtdata libtdatadocdir = ${prefix}/doc/libtdata
libtdatadoc_DATA = \ libtdatadoc_DATA = \

2
VERSION

@ -1 +1 @@
0.2.5 0.2.4

3
configure.ac

@ -62,5 +62,4 @@ Makefile
lib/libtdata.pc lib/libtdata.pc
lib/Makefile lib/Makefile
tests/Makefile tests/Makefile
include/Makefile include/Makefile])
man/Makefile])

1
debian/.gitignore vendored

@ -1 +0,0 @@
.debhelper

6
debian/README.Debian vendored

@ -1,6 +0,0 @@
libtdata for Debian
-------------------
This packages has been built with older versions of the autotools
-- Alexander Vdolainen <alex@vapaa.xyz> Wed, 5 Nov 2025 16:52:48 +0200

9
debian/README.source vendored

@ -1,9 +0,0 @@
libtdata for Debian
-------------------
<this file describes information about the source package, see Debian policy
manual section 4.14. You WILL either need to modify or delete this file>

6
debian/changelog vendored

@ -1,6 +0,0 @@
libtdata (0.2.5) stable; urgency=medium
* Release 0.2.5 minor fixes, documentation
* Updates to the new and uptodate libraries
-- Alexander Vdolainen <alex@vapaa.xyz> Mon, 3 Jun 2019 23:34:56 +0100

1
debian/compat vendored

@ -1 +0,0 @@
8

23
debian/control vendored

@ -1,23 +0,0 @@
Source: libtdata
Priority: extra
Maintainer: Alexander Vdolainen <alex@vapaa.xyz>
Build-Depends: debhelper (>= 8.0.0), autotools-dev, libc-dev
Standards-Version: 3.9.3
Section: libs
Homepage: https://vapaa.work/public/libtdata
#Vcs-Git: git://git.debian.org/collab-maint/libsexpr.git
#Vcs-Browser: http://git.debian.org/?p=collab-maint/libsexpr.git;a=summary
Package: libtdata-dev
Section: libdevel
Architecture: any
Depends: libtdata (= ${binary:Version}), libc-dev
Description: Development files for libtdata
Development files for library implements various data structure implementation
Package: libtdata
Section: libs
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: Implements various data structures
Library implements various data structure implementations

38
debian/copyright vendored

@ -1,38 +0,0 @@
Upstream-Name: libtdata
Source: <https://vapaa.work/public/libtdata>
Files: *
Copyright: 2004 - 2019 Alexander Vdolainen <alex@vapaa.xyz>
License: LGPL-2
Additionally, this library 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.
This library 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 library; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, U SA
Files: debian/*
Copyright: 2014, 2025 Alexander Vdolainen <alex@vapaa.xyz>
License: GPL-2+
This package is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
.
This package 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 General Public License for more details.
.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
.
On Debian systems, the complete text of the GNU General
Public License version 2 can be found in "/usr/share/common-licenses/GPL-2".

2
debian/docs vendored

@ -1,2 +0,0 @@
NEWS
README

13
debian/rules vendored

@ -1,13 +0,0 @@
#!/usr/bin/make -f
# -*- makefile -*-
# Sample debian/rules that uses debhelper.
# This file was originally written by Joey Hess and Craig Small.
# As a special exception, when this file is copied by dh-make into a
# dh-make output file, you may use that output file without restriction.
# This special exception was added by Craig Small in version 0.37 of dh-make.
# Uncomment this to turn on verbose mode.
#export DH_VERBOSE=1
%:
dh $@ --with autotools-dev

18
include/tdata/usrtc.h

@ -22,11 +22,14 @@
#define USRTC_COUNT_T_MAX ((1 << (sizeof(unsigned long)*(sizeof(char) << 1)))-1) #define USRTC_COUNT_T_MAX ((1 << (sizeof(unsigned long)*(sizeof(char) << 1)))-1)
/* count and some misc typedefs */ /*count and some misc typedefs*/
typedef unsigned long usrtc_count_t; typedef unsigned long usrtc_count_t;
typedef unsigned int usrtc_impl_id_t; typedef unsigned int usrtc_impl_id_t;
/* implementation's typedefs */ /* implementations ids,
* if you want to add some
* add the id here, don't forget to do it.
*/
#define USRTC_LIST 0 #define USRTC_LIST 0
#define USRTC_BST 1 #define USRTC_BST 1
#define USRTC_REDBLACK 2 #define USRTC_REDBLACK 2
@ -99,14 +102,9 @@ typedef struct __usrtc_functions_t {
usrtc_impltype_t usrtc_type; usrtc_impltype_t usrtc_type;
} usrtc_functions_t; } usrtc_functions_t;
/* basic usrtc functions */ /*basic rtc functions*/
/* initialize usrtc core structure */ void usrtc_init(usrtc_t *us,int impl,usrtc_count_t maxcount,usrtc_compare_t compare);
void usrtc_init(usrtc_t *us, int impl, usrtc_count_t maxcount, usrtc_t *usrtc_create(int impl,usrtc_count_t maxcount,usrtc_compare_t compare);
usrtc_compare_t compare);
/* allocate and initialize core structure: going to be deprecated */
usrtc_t *usrtc_create(int impl, usrtc_count_t maxcount,
usrtc_compare_t compare);
/* destroy(free) usrtc core structure: going to be deprecated */
void usrtc_destroy(usrtc_t *us); void usrtc_destroy(usrtc_t *us);
void usrtc_convert_to(usrtc_t *us,int impl); void usrtc_convert_to(usrtc_t *us,int impl);

377
lib/redblack.c

@ -32,19 +32,19 @@ static void redblack_delete(usrtc_t *, usrtc_node_t *);
static void redblack_convert_from_list(usrtc_t *); static void redblack_convert_from_list(usrtc_t *);
usrtc_functions_t usrtc_redblack_fu = { usrtc_functions_t usrtc_redblack_fu = {
redblack_init, redblack_init,
redblack_insert, redblack_insert,
redblack_delete, redblack_delete,
usrtc_tree_lookup, usrtc_tree_lookup,
usrtc_tree_lower_bound, usrtc_tree_lower_bound,
usrtc_tree_upper_bound, usrtc_tree_upper_bound,
usrtc_tree_first, usrtc_tree_first,
usrtc_tree_last, usrtc_tree_last,
usrtc_tree_next, usrtc_tree_next,
usrtc_tree_prev, usrtc_tree_prev,
usrtc_tree_convert_to_list, usrtc_tree_convert_to_list,
redblack_convert_from_list, redblack_convert_from_list,
usrtc_bst usrtc_bst
}; };
/*implementation*/ /*implementation*/
@ -59,254 +59,251 @@ static void redblack_insert(usrtc_t *us, usrtc_node_t *node, const void *key)
usrtc_node_t *parent; usrtc_node_t *parent;
/* simple bt insert */ /* simple bt insert */
usrtc_tree_insert(us, node, key); usrtc_tree_insert(us,node,key);
/* implementation specific insert */ /* implementation specific insert */
node->color = usrtc_red; node->color = usrtc_red;
parent = node->parent; parent=node->parent;
while(parent->color == usrtc_red) { while(parent->color==usrtc_red) {
usrtc_node_t *grandpa = parent->parent; usrtc_node_t *grandpa=parent->parent;
if(parent == grandpa->left) { if(parent==grandpa->left) {
usrtc_node_t *uncle = grandpa->right; usrtc_node_t *uncle=grandpa->right;
if(uncle->color == usrtc_red) { /*red parent->red uncle*/ if(uncle->color==usrtc_red) { /*red parent->red uncle*/
parent->color = usrtc_black; parent->color=usrtc_black;
uncle->color = usrtc_black; uncle->color=usrtc_black;
grandpa->color = usrtc_red; grandpa->color=usrtc_red;
node = grandpa; node=grandpa;
parent = grandpa->parent; parent=grandpa->parent;
} else { /*red parent->black uncle */ } else { /*red parent->black uncle */
if(node == parent->right) { if(node==parent->right) {
usrtc_tree_rotate_left(node, parent); usrtc_tree_rotate_left(node,parent);
parent = node; parent=node;
if(grandpa != parent->parent) if(grandpa!=parent->parent)
return; return;
} }
parent->color = usrtc_black; parent->color=usrtc_black;
grandpa->color = usrtc_red; grandpa->color=usrtc_red;
usrtc_tree_rotate_right(parent, grandpa); usrtc_tree_rotate_right(parent,grandpa);
break; break;
} }
} else { /* parent == parent->parent->right */ } else { /*ooh,parent == parent->parent->right*/
usrtc_node_t *uncle = grandpa->left; usrtc_node_t *uncle=grandpa->left;
if(uncle->color == usrtc_red) { if(uncle->color==usrtc_red) {
parent->color = usrtc_black; parent->color=usrtc_black;
uncle->color = usrtc_black; uncle->color=usrtc_black;
grandpa->color = usrtc_red; grandpa->color=usrtc_red;
node = grandpa; node=grandpa;
parent = grandpa->parent; parent=grandpa->parent;
} else { } else {
if(node == parent->left) { if(node==parent->left) {
usrtc_tree_rotate_right(node, parent); usrtc_tree_rotate_right(node,parent);
parent = node; parent=node;
if(grandpa != parent->parent) if(grandpa!=parent->parent)
return; return;
} }
parent->color = usrtc_black; parent->color=usrtc_black;
grandpa->color = usrtc_red; grandpa->color=usrtc_red;
usrtc_tree_rotate_left(parent, grandpa); usrtc_tree_rotate_left(parent,grandpa);
break; break;
} }
} }
} }
tree_root_priv(us)->color = usrtc_black; tree_root_priv(us)->color=usrtc_black;
} }
static void redblack_delete(usrtc_t *us, usrtc_node_t *node) static void redblack_delete(usrtc_t *us,usrtc_node_t *node)
{ {
usrtc_node_t *swap; usrtc_node_t *swap;
usrtc_node_t *child; usrtc_node_t *child;
usrtc_rb_color_t savecolor; usrtc_rb_color_t savecolor;
/*basic bt delete*/ /*basic bt delete*/
usrtc_tree_delete(us, node, &swap, &child); usrtc_tree_delete(us,node,&swap,&child);
/*implementation specific deletion*/ /*implementation specific deletion*/
savecolor = node->color; savecolor=node->color;
node->color = swap->color; node->color=swap->color;
swap->color = savecolor; swap->color=savecolor;
if(node->color == usrtc_black) { /*black*/ if(node->color==usrtc_black) { /*black*/
usrtc_node_t *parent; usrtc_node_t *parent;
usrtc_node_t *sister; usrtc_node_t *sister;
tree_root_priv(us)->color = usrtc_red; tree_root_priv(us)->color=usrtc_red;
while(child->color == usrtc_black) { while(child->color==usrtc_black) {
parent = child->parent; parent=child->parent;
if(child == parent->left) { if(child==parent->left) {
sister = parent->right; sister=parent->right;
if(sister == tree_null_priv(us)) if(sister==tree_null_priv(us))
return; return;
if(sister->color == usrtc_red) { if(sister->color==usrtc_red) {
sister->color = usrtc_black; sister->color=usrtc_black;
parent->color = usrtc_red; parent->color=usrtc_red;
usrtc_tree_rotate_left(sister, parent); usrtc_tree_rotate_left(sister,parent);
sister = parent->right; sister=parent->right;
if(sister == tree_null_priv(us)) if(sister==tree_null_priv(us))
return; return;
} }
if((sister->left->color == usrtc_black) && if(sister->left->color==usrtc_black && sister->right->color==usrtc_black) {
(sister->right->color == usrtc_black)) { sister->color=usrtc_red;
sister->color = usrtc_red; child=parent;
child = parent; } else {
} else { if(sister->right->color==usrtc_black) {
if(sister->right->color == usrtc_black) { if(sister->left->color!=usrtc_red)
if(sister->left->color != usrtc_red) return;
return;
sister->left->color = usrtc_black; sister->left->color=usrtc_black;
sister->color = usrtc_red; sister->color=usrtc_red;
usrtc_tree_rotate_right(sister->left, sister); usrtc_tree_rotate_right(sister->left,sister);
sister = parent->right; sister=parent->right;
if(sister == tree_null_priv(us)) if(sister==tree_null_priv(us))
return; return;
} }
sister->color = parent->color; sister->color=parent->color;
sister->right->color = usrtc_black; sister->right->color=usrtc_black;
parent->color = usrtc_black; parent->color=usrtc_black;
usrtc_tree_rotate_left(sister, parent); usrtc_tree_rotate_left(sister,parent);
break; break;
} }
} else { /*!child == child->parent->right*/ } else { /*!child == child->parent->right*/
if(child != parent->right) if(child!=parent->right)
return; return;
sister = parent->left; sister=parent->left;
if(sister == tree_null_priv(us)) if(sister==tree_null_priv(us))
return; return;
if(sister->color == usrtc_red) { if(sister->color==usrtc_red) {
sister->color = usrtc_black; sister->color=usrtc_black;
parent->color = usrtc_red; parent->color=usrtc_red;
usrtc_tree_rotate_right(sister, parent); usrtc_tree_rotate_right(sister,parent);
sister = parent->left; sister = parent->left;
if(sister == tree_null_priv(us)) if(sister==tree_null_priv(us))
return; return;
} }
if((sister->right->color == usrtc_black) && if(sister->right->color==usrtc_black && sister->left->color==usrtc_black) {
(sister->left->color == usrtc_black)) { sister->color=usrtc_red;
sister->color = usrtc_red; child=parent;
child = parent; } else {
} else { if(sister->left->color == usrtc_black) {
if(sister->left->color == usrtc_black) { if(sister->right->color!=usrtc_red)
if(sister->right->color != usrtc_red) return;
return;
sister->right->color = usrtc_black; sister->right->color=usrtc_black;
sister->color = usrtc_red; sister->color=usrtc_red;
usrtc_tree_rotate_left(sister->right, sister); usrtc_tree_rotate_left(sister->right, sister);
sister = parent->left; sister=parent->left;
if(sister == tree_null_priv(us)) if(sister==tree_null_priv(us))
return; return;
} }
sister->color = parent->color; sister->color=parent->color;
sister->left->color = usrtc_black; sister->left->color=usrtc_black;
parent->color = usrtc_black; parent->color=usrtc_black;
usrtc_tree_rotate_right(sister, parent); usrtc_tree_rotate_right(sister,parent);
break; break;
} }
} }
} }
child->color = usrtc_black; child->color=usrtc_black;
tree_root_priv(us)->color = usrtc_black; tree_root_priv(us)->color=usrtc_black;
} }
return;
} }
static void redblack_convert_from_list(usrtc_t *us) static void redblack_convert_from_list(usrtc_t *us)
{ {
usrtc_node_t *tree[TREE_DEPTH_MAX] = { NULL }; usrtc_node_t *tree[TREE_DEPTH_MAX] = { NULL };
usrtc_node_t *curr; usrtc_node_t *curr;
usrtc_node_t *nil = tree_null_priv(us); usrtc_node_t *nil=tree_null_priv(us);
usrtc_node_t *next; usrtc_node_t *next;
usrtc_node_t *complete = NULL; usrtc_node_t *complete=NULL;
usrtc_count_t fullcount = (usrtc_count_t) USRTC_COUNT_T_MAX; usrtc_count_t fullcount=(usrtc_count_t)USRTC_COUNT_T_MAX;
usrtc_count_t nodecount = us->nodecount; usrtc_count_t nodecount=us->nodecount;
usrtc_count_t botrowcount; usrtc_count_t botrowcount;
unsigned int baselevel = 0; unsigned int baselevel=0;
unsigned int level = 0; unsigned int level=0;
unsigned int i; unsigned int i;
if((usrtc_red!=0) && (usrtc_black != 1)) if(usrtc_red!=0 && usrtc_black!=1)
return; return;
while((fullcount >= nodecount) && fullcount) /*calc*/ while(fullcount>=nodecount && fullcount) /*calc*/
fullcount >>= 1; fullcount >>= 1;
botrowcount = nodecount-fullcount; botrowcount=nodecount-fullcount;
for(curr = nil->next; curr!=nil; curr=next) { for(curr=nil->next;curr!=nil;curr=next) {
next=curr->next; next=curr->next;
if((complete == NULL) && (botrowcount-- == 0)) { if(complete==NULL && botrowcount--==0) {
baselevel = level = 1; baselevel=level=1;
complete = tree[0]; complete=tree[0];
if(complete != NULL) { if(complete!=NULL) {
tree[0] = NULL; tree[0]=NULL;
complete->right = nil; complete->right=nil;
while(tree[level] != 0) { while(tree[level]!=0) {
tree[level]->right = complete; tree[level]->right=complete;
complete->parent = tree[level]; complete->parent=tree[level];
complete = tree[level]; complete=tree[level];
tree[level++] = NULL; tree[level++]=NULL;
} }
} }
} }
if(complete == NULL) { if(complete==NULL) {
curr->left = nil; curr->left=nil;
curr->right = nil; curr->right=nil;
curr->color = level%2; curr->color=level%2;
complete = curr; complete=curr;
if(level != baselevel) if(level!=baselevel)
return; return;
while(tree[level] != NULL) { while(tree[level]!=NULL) {
tree[level]->right = complete; tree[level]->right=complete;
complete->parent = tree[level]; complete->parent=tree[level];
complete = tree[level]; complete=tree[level];
tree[level++] = NULL; tree[level++]=NULL;
} }
} else { } else {
curr->left = complete; curr->left=complete;
curr->color = (level + 1)%2; curr->color=(level+1)%2;
complete->parent = curr; complete->parent=curr;
tree[level] = curr; tree[level]=curr;
complete = NULL; complete=NULL;
level = baselevel; level=baselevel;
} }
} }
if(complete == NULL) if(complete==NULL)
complete = nil; complete=nil;
for (i = 0; i < TREE_DEPTH_MAX; i++) { for (i=0;i<TREE_DEPTH_MAX;i++) {
if (tree[i] != NULL) { if (tree[i]!=NULL) {
tree[i]->right = complete; tree[i]->right=complete;
complete->parent = tree[i]; complete->parent=tree[i];
complete = tree[i]; complete=tree[i];
} }
} }
nil->right = nil; nil->right=nil;
nil->left = complete; nil->left=complete;
nil->color = usrtc_black; nil->color=usrtc_black;
complete->parent = nil; complete->parent=nil;
complete->color = usrtc_black; complete->color=usrtc_black;
return;
} }

155
lib/splay.c

@ -22,132 +22,121 @@
#include <tdata/tree.h> #include <tdata/tree.h>
/*prototypes*/ /*prototypes*/
static void splay_insert(usrtc_t *, usrtc_node_t *, const void *); static void splay_insert(usrtc_t *,usrtc_node_t *,const void *);
static void splay_delete(usrtc_t *, usrtc_node_t *); static void splay_delete(usrtc_t *,usrtc_node_t *);
static usrtc_node_t *splay_lookup(usrtc_t *, const void *); static usrtc_node_t *splay_lookup(usrtc_t *,const void *);
usrtc_functions_t usrtc_splay_fu = { usrtc_functions_t usrtc_splay_fu = {
usrtc_tree_init, usrtc_tree_init,
splay_insert, splay_insert,
splay_delete, splay_delete,
splay_lookup, splay_lookup,
usrtc_tree_lower_bound, usrtc_tree_lower_bound,
usrtc_tree_upper_bound, usrtc_tree_upper_bound,
usrtc_tree_first, usrtc_tree_first,
usrtc_tree_last, usrtc_tree_last,
usrtc_tree_next, usrtc_tree_next,
usrtc_tree_prev, usrtc_tree_prev,
usrtc_tree_convert_to_list, usrtc_tree_convert_to_list,
usrtc_tree_convert_from_list, usrtc_tree_convert_from_list,
usrtc_bst usrtc_bst
}; };
static void right_zig_zig(usrtc_node_t *, usrtc_node_t *, usrtc_node_t *); static void right_zig_zig(usrtc_node_t *,usrtc_node_t *,usrtc_node_t *);
static void left_zig_zig(usrtc_node_t *, usrtc_node_t *, usrtc_node_t *); static void left_zig_zig(usrtc_node_t *,usrtc_node_t *,usrtc_node_t *);
static void right_zig_zag(usrtc_node_t *, usrtc_node_t *, usrtc_node_t *); static void right_zig_zag(usrtc_node_t *,usrtc_node_t *,usrtc_node_t *);
static void left_zig_zag(usrtc_node_t *, usrtc_node_t *, usrtc_node_t *); static void left_zig_zag(usrtc_node_t *,usrtc_node_t *,usrtc_node_t *);
static void splay_node(usrtc_t *, usrtc_node_t *); static void splay_node(usrtc_t *,usrtc_node_t *);
/*implementation*/ /*implementation*/
static void splay_insert(usrtc_t *us, usrtc_node_t *node, const void *key) static void splay_insert(usrtc_t *us,usrtc_node_t *node,const void *key)
{ {
usrtc_tree_insert(us, node, key); usrtc_tree_insert(us,node,key);
while(node != tree_root_priv(us)) while(node!=tree_root_priv(us))
splay_node(us, node); splay_node(us,node);
return;
} }
static void splay_delete(usrtc_t *us, usrtc_node_t *node) static void splay_delete(usrtc_t *us,usrtc_node_t *node)
{ {
usrtc_node_t *dummy; usrtc_node_t *dummy;
usrtc_tree_delete(us, node, &dummy, &dummy); usrtc_tree_delete(us,node,&dummy,&dummy);
return;
} }
static usrtc_node_t *splay_lookup(usrtc_t *us, const void *key) static usrtc_node_t *splay_lookup(usrtc_t *us,const void *key)
{ {
usrtc_node_t *node=usrtc_tree_lookup(us, key); usrtc_node_t *node=usrtc_tree_lookup(us,key);
if(node) if(node)
while(node != tree_root_priv(us)) while(node!=tree_root_priv(us))
splay_node(us, node); splay_node(us,node);
return node; return node;
} }
static void right_zig_zig(usrtc_node_t *child, usrtc_node_t *parent, static void right_zig_zig(usrtc_node_t *child,usrtc_node_t *parent,usrtc_node_t *grandpa)
usrtc_node_t *grandpa)
{ {
usrtc_tree_rotate_right(parent, grandpa); usrtc_tree_rotate_right(parent,grandpa);
usrtc_tree_rotate_right(child, parent); usrtc_tree_rotate_right(child,parent);
return;
} }
static void left_zig_zig(usrtc_node_t *child, usrtc_node_t *parent, static void left_zig_zig(usrtc_node_t *child,usrtc_node_t *parent,usrtc_node_t *grandpa)
usrtc_node_t *grandpa)
{ {
usrtc_tree_rotate_left(parent, grandpa); usrtc_tree_rotate_left(parent,grandpa);
usrtc_tree_rotate_left(child, parent); usrtc_tree_rotate_left(child,parent);
return;
} }
static void right_zig_zag(usrtc_node_t *child, usrtc_node_t *parent, static void right_zig_zag(usrtc_node_t *child,usrtc_node_t *parent,usrtc_node_t *grandpa)
usrtc_node_t *grandpa)
{ {
usrtc_tree_rotate_right(child, parent); usrtc_tree_rotate_right(child,parent);
usrtc_tree_rotate_left(child, grandpa); usrtc_tree_rotate_left(child,grandpa);
return;
} }
static void left_zig_zag(usrtc_node_t *child, usrtc_node_t *parent, static void left_zig_zag(usrtc_node_t *child,usrtc_node_t *parent,usrtc_node_t *grandpa)
usrtc_node_t *grandpa)
{ {
usrtc_tree_rotate_left(child, parent); usrtc_tree_rotate_left(child,parent);
usrtc_tree_rotate_right(child, grandpa); usrtc_tree_rotate_right(child,grandpa);
return;
} }
static void splay_node(usrtc_t *us, usrtc_node_t *node) static void splay_node(usrtc_t *us,usrtc_node_t *node)
{ {
usrtc_node_t *root = tree_root_priv(us); usrtc_node_t *root=tree_root_priv(us);
usrtc_node_t *parent = node->parent; usrtc_node_t *parent=node->parent;
if(parent->left == node) { if(parent->left==node) {
if(parent == root) { if(parent==root) {
usrtc_tree_rotate_right(node, parent); usrtc_tree_rotate_right(node,parent);
} else { } else {
usrtc_node_t *grandpa = parent->parent; usrtc_node_t *grandpa=parent->parent;
if(grandpa->left == parent) if(grandpa->left==parent)
right_zig_zig(node, parent, grandpa); right_zig_zig(node,parent,grandpa);
else { else {
if(grandpa->right != parent) if(grandpa->right!=parent)
return; return;
right_zig_zag(node, parent, grandpa); right_zig_zag(node,parent,grandpa);
} }
} }
} else { } else {
if(parent->right != node) if(parent->right!=node)
return; return;
if(parent == root) { if(parent==root) {
usrtc_tree_rotate_left(node, parent); usrtc_tree_rotate_left(node,parent);
} else { } else {
usrtc_node_t *grandpa = parent->parent; usrtc_node_t *grandpa=parent->parent;
if(grandpa->right == parent) { if(grandpa->right==parent) {
left_zig_zig(node, parent, grandpa); left_zig_zig(node,parent,grandpa);
} else { } else {
if(grandpa->left != parent) if(grandpa->left!=parent)
return; return;
left_zig_zag(node, parent, grandpa); left_zig_zag(node,parent,grandpa);
} }
} }
} }
return;
} }

451
lib/tree.c

@ -27,107 +27,104 @@
static void tree_delete(usrtc_t *, usrtc_node_t *); static void tree_delete(usrtc_t *, usrtc_node_t *);
usrtc_functions_t usrtc_tree_fu = { usrtc_functions_t usrtc_tree_fu = {
usrtc_tree_init, usrtc_tree_init,
usrtc_tree_insert, usrtc_tree_insert,
tree_delete, tree_delete,
usrtc_tree_lookup, usrtc_tree_lookup,
usrtc_tree_lower_bound, usrtc_tree_lower_bound,
usrtc_tree_upper_bound, usrtc_tree_upper_bound,
usrtc_tree_first, usrtc_tree_first,
usrtc_tree_last, usrtc_tree_last,
usrtc_tree_next, usrtc_tree_next,
usrtc_tree_prev, usrtc_tree_prev,
usrtc_tree_convert_to_list, usrtc_tree_convert_to_list,
usrtc_tree_convert_from_list, usrtc_tree_convert_from_list,
usrtc_bst usrtc_bst
}; };
/*implementation*/ /*implementation*/
void usrtc_tree_init(usrtc_t *us) void usrtc_tree_init(usrtc_t *us)
{ {
us->sentinel.left = &us->sentinel; us->sentinel.left=&us->sentinel;
us->sentinel.right = &us->sentinel; us->sentinel.right=&us->sentinel;
us->sentinel.parent = &us->sentinel; us->sentinel.parent=&us->sentinel;
us->sentinel.impl_specific.usrtc_dummy = 0; us->sentinel.impl_specific.usrtc_dummy=0;
us->sentinel.data = 0; us->sentinel.data=0;
us->sentinel.key = 0; us->sentinel.key=0;
return;
} }
void usrtc_tree_insert(usrtc_t *us, usrtc_node_t *node, const void *key) void usrtc_tree_insert(usrtc_t *us,usrtc_node_t *node,const void *key)
{ {
usrtc_node_t *where = tree_root_priv(us); usrtc_node_t *where=tree_root_priv(us);
usrtc_node_t *nil = tree_null_priv(us); usrtc_node_t *nil=tree_null_priv(us);
usrtc_node_t *parent = nil; usrtc_node_t *parent=nil;
long res = -1; long res=-1;
node->key = key; node->key=key;
while(where != nil) { while(where!=nil) {
parent = where; parent=where;
res = us->compare(key, where->key); res=us->compare(key,where->key);
if(us->dupes_allowed && !res) /*trying to put duplicate to the disabled dupe tree*/ if(us->dupes_allowed && !res) /*trying to put duplicate to the disabled dupe tree*/
return; return;
if(res<0) if(res<0)
where = where->left; where=where->left;
else else
where = where->right; where=where->right;
} }
/*assert(where==nil);*/ /*assert(where==nil);*/
if(res < 0) if(res<0)
parent->left = node; parent->left=node;
else else
parent->right = node; parent->right=node;
node->parent = parent; node->parent=parent;
node->left = nil; node->left=nil;
node->right = nil; node->right=nil;
us->nodecount++; us->nodecount++;
return;
} }
void usrtc_tree_delete(usrtc_t *us, usrtc_node_t *node, usrtc_node_t **pswap, void usrtc_tree_delete(usrtc_t *us,usrtc_node_t *node,usrtc_node_t **pswap,usrtc_node_t **pchild)
usrtc_node_t **pchild)
{ {
usrtc_node_t *nil = tree_null_priv(us); usrtc_node_t *nil=tree_null_priv(us);
usrtc_node_t *child; usrtc_node_t *child;
usrtc_node_t *delparent = node->parent; usrtc_node_t *delparent=node->parent;
usrtc_node_t *next = node; usrtc_node_t *next=node;
usrtc_node_t *nextparent; usrtc_node_t *nextparent;
if(node->left != nil && node->right != nil) { if(node->left!=nil && node->right!=nil) {
next = usrtc_tree_next(us, node); next=usrtc_tree_next(us,node);
nextparent = next->parent; nextparent=next->parent;
/*if(next!=nil && next->parent!=nil && next->parent==nil) /*if(next!=nil && next->parent!=nil && next->parent==nil)
return;*/ return;*/
child = next->right; child=next->right;
child->parent = nextparent; child->parent=nextparent;
if(nextparent->left == next) if(nextparent->left==next)
nextparent->left = child; nextparent->left=child;
else { else {
//if(nextparent->right!=next) //if(nextparent->right!=next)
//return; //return;
nextparent->right = child; nextparent->right=child;
} }
next->parent = delparent; next->parent=delparent;
next->left = node->left; next->left=node->left;
next->right = node->right; next->right=node->right;
next->left->parent = next; next->left->parent=next;
next->right->parent = next; next->right->parent=next;
if(delparent->left == node) { if(delparent->left==node) {
delparent->left = next; delparent->left=next;
} else { } else {
//if(delparent->right!=node) //if(delparent->right!=node)
// return; // return;
@ -137,57 +134,55 @@ void usrtc_tree_delete(usrtc_t *us, usrtc_node_t *node, usrtc_node_t **pswap,
} else { } else {
/*if(node==nil) /*if(node==nil)
return; return;
if(node->left!=nil && node->right!=nil) if(node->left!=nil && node->right!=nil)
return;*/ return;*/
child = (node->left != nil) ? node->left : node->right; child=(node->left!=nil) ? node->left : node->right;
child->parent = delparent = node->parent; child->parent=delparent=node->parent;
if(node == delparent->left) { if(node==delparent->left) {
delparent->left = child; delparent->left=child;
} else { } else {
/*if(node!=delparent->right) /*if(node!=delparent->right)
return;*/ return;*/
delparent->right = child; delparent->right=child;
} }
} }
node->parent = NULL; node->parent=0;
node->right = NULL; node->right=0;
node->left = NULL; node->left=0;
us->nodecount--; us->nodecount--;
*pswap = next; *pswap = next;
*pchild = child; *pchild = child;
return;
} }
usrtc_node_t *usrtc_tree_lookup(usrtc_t *us, const void *key) usrtc_node_t *usrtc_tree_lookup(usrtc_t *us,const void *key)
{ {
usrtc_node_t *root = tree_root_priv(us); usrtc_node_t *root=tree_root_priv(us);
usrtc_node_t *nil = tree_null_priv(us); usrtc_node_t *nil=tree_null_priv(us);
usrtc_node_t *saved; usrtc_node_t *saved;
long res; long res;
while (root != nil) { while (root!=nil) {
res = us->compare(key, root->key); res=us->compare(key,root->key);
if(res < 0) if(res<0)
root = root->left; root=root->left;
else if(res > 0) else if(res>0)
root = root->right; root=root->right;
else { else {
if(!us->dupes_allowed) if(!us->dupes_allowed)
return root; /*no duplicates*/ return root; /*no duplicates*/
else { /*duplicate, then find left occurence*/ else { /*duplicate, then find left occurence*/
do { do {
saved = root; saved=root;
root = root->left; root=root->left;
while(root!=nil && us->compare(key, root->key)) while(root!=nil && us->compare(key,root->key))
root = root->right; root=root->right;
} while(root != nil); } while(root!=nil);
return saved; return saved;
} }
} }
@ -196,27 +191,27 @@ usrtc_node_t *usrtc_tree_lookup(usrtc_t *us, const void *key)
return NULL; return NULL;
} }
usrtc_node_t *usrtc_tree_lower_bound(usrtc_t *us, const void *key) usrtc_node_t *usrtc_tree_lower_bound(usrtc_t *us,const void *key)
{ {
usrtc_node_t *root = tree_root_priv(us); usrtc_node_t *root=tree_root_priv(us);
usrtc_node_t *nil = tree_null_priv(us); usrtc_node_t *nil=tree_null_priv(us);
usrtc_node_t *tentative = NULL; usrtc_node_t *tentative=NULL;
long res; long res;
while(root != nil) { while(root!=nil) {
res = us->compare(key, root->key); res=us->compare(key,root->key);
if(res > 0) { if(res>0) {
root = root->right; root=root->right;
} else if(res < 0) { } else if(res<0) {
tentative = root; tentative=root;
root = root->left; root=root->left;
} else { } else {
if (!us->dupes_allowed) if (!us->dupes_allowed)
return root; return root;
else { else {
tentative = root; tentative=root;
root = root->left; root=root->left;
} }
} }
} }
@ -224,27 +219,27 @@ usrtc_node_t *usrtc_tree_lower_bound(usrtc_t *us, const void *key)
return tentative; return tentative;
} }
usrtc_node_t *usrtc_tree_upper_bound(usrtc_t *us, const void *key) usrtc_node_t *usrtc_tree_upper_bound(usrtc_t *us,const void *key)
{ {
usrtc_node_t *root = tree_root_priv(us); usrtc_node_t *root=tree_root_priv(us);
usrtc_node_t *nil = tree_null_priv(us); usrtc_node_t *nil=tree_null_priv(us);
usrtc_node_t *tentative = NULL; usrtc_node_t *tentative=NULL;
long res; long res;
while(root != nil) { while(root!=nil) {
res = us->compare(key, root->key); res=us->compare(key,root->key);
if(res > 0) { if(res>0) {
root = root->left; root=root->left;
} else if(res < 0) { } else if(res<0) {
tentative = root; tentative=root;
root = root->right; root=root->right;
} else { } else {
if (!us->dupes_allowed) if (!us->dupes_allowed)
return root; return root;
else { else {
tentative = root; tentative=root;
root = root->right; root=root->right;
} }
} }
} }
@ -267,61 +262,61 @@ usrtc_node_t *usrtc_tree_first(usrtc_t *us)
usrtc_node_t *usrtc_tree_last(usrtc_t *us) usrtc_node_t *usrtc_tree_last(usrtc_t *us)
{ {
usrtc_node_t *nil = tree_null_priv(us); usrtc_node_t *nil=tree_null_priv(us);
usrtc_node_t *root = tree_root_priv(us); usrtc_node_t *root=tree_root_priv(us);
usrtc_node_t *right; usrtc_node_t *right;
if(root != nil) if(root!=nil)
while((right = root->right) != nil) while((right=root->right)!=nil)
root = right; root=right;
return (root == nil) ? NULL : root; return (root==nil) ? NULL : root;
} }
usrtc_node_t *usrtc_tree_next(usrtc_t *us, usrtc_node_t *curr) usrtc_node_t *usrtc_tree_next(usrtc_t *us, usrtc_node_t *curr)
{ {
usrtc_node_t *nil = tree_null_priv(us); usrtc_node_t *nil=tree_null_priv(us);
usrtc_node_t *parent; usrtc_node_t *parent;
usrtc_node_t *left; usrtc_node_t *left;
if(curr->right != nil) { if(curr->right!=nil) {
curr = curr->right; curr=curr->right;
while((left = curr->left) != nil) while((left=curr->left)!=nil)
curr = left; curr=left;
return curr; return curr;
} }
parent = curr->parent; parent=curr->parent;
while((parent != nil) && (curr == parent->right)) { while(parent!=nil && curr==parent->right) {
curr = parent; curr=parent;
parent = curr->parent; parent=curr->parent;
} }
return (parent == nil) ? NULL : parent; return (parent==nil) ? NULL : parent;
} }
usrtc_node_t *usrtc_tree_prev(usrtc_t *us, usrtc_node_t *curr) usrtc_node_t *usrtc_tree_prev(usrtc_t *us, usrtc_node_t *curr)
{ {
usrtc_node_t *nil = tree_null_priv(us); usrtc_node_t *nil=tree_null_priv(us);
usrtc_node_t *parent; usrtc_node_t *parent;
usrtc_node_t *right; usrtc_node_t *right;
if(curr->left != nil) { if(curr->left!=nil) {
curr = curr->left; curr=curr->left;
while((right = curr->right) != nil) while((right=curr->right)!=nil)
curr = right; curr=right;
return curr; return curr;
} }
parent = curr->parent; parent=curr->parent;
while((parent != nil) && (curr == parent->left)) { while(parent!=nil && curr==parent->left) {
curr = parent; curr=parent;
parent = curr->parent; parent=curr->parent;
} }
return (parent == nil) ? NULL : parent; return (parent==nil) ? NULL : parent;
} }
/*uff, convertation between trees and lists*/ /*uff, convertation between trees and lists*/
@ -329,167 +324,161 @@ void usrtc_tree_convert_to_list(usrtc_t *us)
{ {
usrtc_node_t *node; usrtc_node_t *node;
usrtc_node_t tempsentinel; usrtc_node_t tempsentinel;
usrtc_node_t *nil = &tempsentinel; usrtc_node_t *nil=&tempsentinel;
usrtc_node_t *tail, *next; usrtc_node_t *tail,*next;
usrtc_node_t *treenil = tree_null_priv(us); usrtc_node_t *treenil=tree_null_priv(us);
if(us->nodecount == 0) /* no nodes */ if(us->nodecount==0) /* no nodes */
return; return;
tempsentinel.next = nil; tempsentinel.next=nil;
tempsentinel.prev = nil; tempsentinel.prev=nil;
/* two passes */ /* two passes */
for(tail = nil, node = usrtc_tree_first(us); node != 0; tail = node, for(tail=nil,node=usrtc_tree_first(us);node!=0;tail=node,node=next) {
node = next) { next=usrtc_tree_next(us,node);
next = usrtc_tree_next(us, node); node->prev=tail;
node->prev = tail;
} }
nil->prev = tail; nil->prev=tail;
for(tail = nil, node = nil->prev; node != nil; tail = node, for(tail=nil,node=nil->prev;node!=nil;tail=node,node=node->prev)
node = node->prev) node->next=tail;
node->next = tail;
nil->next = tail; nil->next=tail;
us->sentinel.next = tempsentinel.next; us->sentinel.next=tempsentinel.next;
us->sentinel.prev = tempsentinel.prev; us->sentinel.prev=tempsentinel.prev;
us->sentinel.next->prev = treenil; us->sentinel.next->prev=treenil;
us->sentinel.prev->next = treenil; us->sentinel.prev->next=treenil;
return;
} }
void usrtc_tree_convert_from_list(usrtc_t *us) void usrtc_tree_convert_from_list(usrtc_t *us)
{ {
usrtc_node_t *tree[TREE_DEPTH_MAX] = { 0 }; usrtc_node_t *tree[TREE_DEPTH_MAX]={ 0 };
usrtc_node_t *curr; usrtc_node_t *curr;
usrtc_node_t *nil = tree_null_priv(us); usrtc_node_t *nil=tree_null_priv(us);
usrtc_node_t *next; usrtc_node_t *next;
usrtc_node_t *complete = NULL; usrtc_node_t *complete=NULL;
usrtc_count_t fullcount = (usrtc_count_t)USRTC_COUNT_T_MAX; usrtc_count_t fullcount=(usrtc_count_t)USRTC_COUNT_T_MAX;
usrtc_count_t nodecount = us->nodecount; usrtc_count_t nodecount=us->nodecount;
usrtc_count_t botrowcount; usrtc_count_t botrowcount;
int baselevel = 0; int baselevel=0;
int level = 0; int level=0;
int i = 0; int i=0;
while ((fullcount >= nodecount) && fullcount) /* calc */ while (fullcount>=nodecount && fullcount) /* calc */
fullcount >>= 1; fullcount>>=1;
botrowcount = nodecount - fullcount; botrowcount=nodecount-fullcount;
for(curr = nil->next; curr != nil; curr = next) { for(curr=nil->next;curr!=nil;curr=next) {
next = curr->next; next=curr->next;
if((complete == NULL) && (botrowcount-- == 0)) { if(complete==NULL && botrowcount-- ==0) {
baselevel = level = 1; baselevel=level=1;
complete = tree[0]; complete=tree[0];
if(complete != NULL) { if(complete!=NULL) {
tree[0] = 0; tree[0]=0;
complete->right = nil; complete->right=nil;
while(tree[level] != NULL) { while(tree[level]!=NULL) {
tree[level]->right = complete; tree[level]->right=complete;
complete->parent = tree[level]; complete->parent=tree[level];
complete = tree[level]; complete=tree[level];
tree[level++] = 0; tree[level++]=0;
} }
} }
} }
if(complete == NULL) { if(complete==NULL) {
curr->left = nil; curr->left=nil;
curr->right = nil; curr->right=nil;
complete = curr; complete=curr;
if(level != baselevel) if(level!=baselevel)
return; return;
while(tree[level] != NULL) { while(tree[level]!=NULL) {
tree[level]->right = complete; tree[level]->right=complete;
complete->parent = tree[level]; complete->parent=tree[level];
complete = tree[level]; complete=tree[level];
tree[level++] = 0; tree[level++]=0;
} }
} else { } else {
curr->left = complete; curr->left=complete;
complete->parent = curr; complete->parent=curr;
tree[level] = curr; tree[level]=curr;
complete = NULL; complete=NULL;
level = baselevel; level=baselevel;
} }
} }
if(complete == NULL) if(complete==NULL)
complete = nil; complete=nil;
for(i = 0; i < TREE_DEPTH_MAX; i++) { for(i=0;i<TREE_DEPTH_MAX;i++) {
if(tree[i] != NULL) { if(tree[i]!=NULL) {
tree[i]->right = complete; tree[i]->right=complete;
complete->parent = tree[i]; complete->parent=tree[i];
complete = tree[i]; complete=tree[i];
} }
} }
nil->right = nil; nil->right=nil;
nil->left = complete; nil->left=complete;
complete->parent = nil; complete->parent=nil;
return;
} }
void usrtc_tree_rotate_left(usrtc_node_t *child, usrtc_node_t *parent) void usrtc_tree_rotate_left(usrtc_node_t *child,usrtc_node_t *parent)
{ {
usrtc_node_t *leftgrandchild; usrtc_node_t *leftgrandchild;
usrtc_node_t *grandpa; usrtc_node_t *grandpa;
if(parent->right != child) if(parent->right!=child)
return; return;
child = parent->right; child=parent->right;
parent->right = leftgrandchild = child->left; parent->right=leftgrandchild=child->left;
leftgrandchild->parent = parent; leftgrandchild->parent=parent;
child->parent = grandpa = parent->parent; child->parent=grandpa=parent->parent;
if(parent == grandpa->left) { if(parent==grandpa->left) {
grandpa->left=child; grandpa->left=child;
} else { } else {
if(parent != grandpa->right) if(parent!=grandpa->right)
return; return;
grandpa->right = child; grandpa->right=child;
} }
child->left = parent; child->left=parent;
parent->parent = child; parent->parent=child;
return;
} }
void usrtc_tree_rotate_right(usrtc_node_t *child, usrtc_node_t *parent) void usrtc_tree_rotate_right(usrtc_node_t *child,usrtc_node_t *parent)
{ {
usrtc_node_t *rightgrandchild; usrtc_node_t *rightgrandchild;
usrtc_node_t *grandpa; usrtc_node_t *grandpa;
if(parent->left != child) if(parent->left!=child)
return; return;
parent->left = rightgrandchild = child->right; parent->left=rightgrandchild=child->right;
rightgrandchild->parent = parent; rightgrandchild->parent=parent;
child->parent = grandpa = parent->parent; child->parent=grandpa=parent->parent;
if(parent == grandpa->right) { if(parent==grandpa->right) {
grandpa->right = child; grandpa->right=child;
} else { } else {
if(parent != grandpa->left) if(parent!=grandpa->left)
return; return;
grandpa->left = child; grandpa->left=child;
} }
child->right = parent; child->right=parent;
parent->parent = child; parent->parent=child;
return;
} }
/* local functions */ /* local functions */

142
lib/usrtc.c

@ -46,40 +46,36 @@ static usrtc_node_t *default_node_alloc(void *context)
return malloc(sizeof *default_node_alloc(context)); return malloc(sizeof *default_node_alloc(context));
} }
static void default_node_free(void *context, usrtc_node_t *node) static void default_node_free(void *context,usrtc_node_t *node)
{ {
free(node); free(node);
return;
} }
void usrtc_init(usrtc_t *us, int impl, usrtc_count_t maxcount, void usrtc_init(usrtc_t *us,int impl,usrtc_count_t maxcount,usrtc_compare_t compare)
usrtc_compare_t compare)
{ {
if(!us) if(!us)
return; return;
if(impl>MAX_IMPL) if(impl>MAX_IMPL)
return; return;
us->nodecount = 0; us->nodecount=0;
us->maxcount = maxcount; us->maxcount=maxcount;
us->dupes_allowed = 0; us->dupes_allowed=0;
us->compare = compare; us->compare=compare;
us->node_alloc = default_node_alloc; us->node_alloc=default_node_alloc;
us->node_free = default_node_free; us->node_free=default_node_free;
us->context = 0; us->context=0;
us->futable = impl_table[impl]; us->futable=impl_table[impl];
us->futable->usrtc_init(us); us->futable->usrtc_init(us);
return;
} }
usrtc_t *usrtc_create(int impl, usrtc_count_t maxcount, usrtc_t *usrtc_create(int impl,usrtc_count_t maxcount,usrtc_compare_t compare)
usrtc_compare_t compare)
{ {
usrtc_t *newrtc = (usrtc_t *) malloc(sizeof *newrtc); usrtc_t *newrtc=(usrtc_t*)malloc(sizeof *newrtc);
if(newrtc) if(newrtc)
usrtc_init(newrtc, impl, maxcount, compare); usrtc_init(newrtc,impl,maxcount,compare);
return newrtc; return newrtc;
} }
@ -90,28 +86,25 @@ void usrtc_destroy(usrtc_t *us)
return; return;
free(us); free(us);
return;
} }
void usrtc_convert_to(usrtc_t *us,int impl) void usrtc_convert_to(usrtc_t *us,int impl)
{ {
if(impl_table[impl] == us->futable) if(impl_table[impl]==us->futable)
return; return;
if((us->futable->usrtc_type == usrtc_bst) && if(us->futable->usrtc_type==usrtc_bst && (impl==USRTC_BST || impl==USRTC_SPLAY)) {
(impl == USRTC_BST || impl == USRTC_SPLAY)) { us->futable=impl_table[impl];
us->futable = impl_table[impl];
return; return;
} }
us->futable->usrtc_convert_to_list(us); us->futable->usrtc_convert_to_list(us);
us->futable = impl_table[impl]; us->futable=impl_table[impl];
if(impl_table[impl]->usrtc_type == usrtc_lst) if(impl_table[impl]->usrtc_type==usrtc_lst)
return; return;
us->futable->usrtc_convert_from_list(us); us->futable->usrtc_convert_from_list(us);
return;
} }
usrtc_count_t usrtc_count(usrtc_t *us) usrtc_count_t usrtc_count(usrtc_t *us)
@ -129,32 +122,29 @@ int usrtc_isfull(usrtc_t *us)
return us->nodecount == us->maxcount; return us->nodecount == us->maxcount;
} }
int usrtc_alloc_insert(usrtc_t *us, const void *key, void *data) int usrtc_alloc_insert(usrtc_t *us,const void *key,void *data)
{ {
usrtc_node_t *newnode = us->node_alloc(us->context); usrtc_node_t *newnode=us->node_alloc(us->context);
if(newnode != NULL) { if(newnode!=NULL) {
newnode->data = data; newnode->data=data;
us->futable->usrtc_insert(us, newnode, key); us->futable->usrtc_insert(us,newnode,key);
} }
return newnode != NULL; return newnode!=NULL;
} }
void usrtc_delete_free(usrtc_t *us, usrtc_node_t *node) void usrtc_delete_free(usrtc_t *us,usrtc_node_t *node)
{ {
us->futable->usrtc_delete(us, node); us->futable->usrtc_delete(us,node);
us->node_free(us->context, node); us->node_free(us->context,node);
return;
} }
void usrtc_set_allocator(usrtc_t *us, usrtc_node_alloc_t alloc, void usrtc_set_allocator(usrtc_t *us,usrtc_node_alloc_t alloc,usrtc_node_free_t n_free,void *context)
usrtc_node_free_t n_free, void *context)
{ {
us->node_alloc = alloc; us->node_alloc=alloc;
us->node_free = n_free; us->node_free=n_free;
us->context = context; us->context=context;
return;
} }
void usrtc_allow_dupes(usrtc_t *us) void usrtc_allow_dupes(usrtc_t *us)
@ -163,33 +153,31 @@ void usrtc_allow_dupes(usrtc_t *us)
if(!us->nodecount) if(!us->nodecount)
return; return;
us->dupes_allowed = 1; us->dupes_allowed=1;
return;
} }
void usrtc_node_init(usrtc_node_t *node, void *data) void usrtc_node_init(usrtc_node_t *node,void *data)
{ {
node->data = data; node->data=data;
node->impl_specific.usrtc_dummy = 0; node->impl_specific.usrtc_dummy=0;
node->left = NULL; node->left=NULL;
node->right = NULL; node->right=NULL;
node->parent = NULL; node->parent=NULL;
} }
usrtc_node_t *usrtc_node_create(void *data) usrtc_node_t *usrtc_node_create(void *data)
{ {
usrtc_node_t *newnode = (usrtc_node_t *) malloc(sizeof *newnode); usrtc_node_t *newnode=(usrtc_node_t*)malloc(sizeof *newnode);
if(newnode != NULL) if(newnode!=NULL)
newnode->data = data; newnode->data=data;
return newnode; return newnode;
} }
void usrtc_node_destroy(usrtc_node_t *node) void usrtc_node_destroy(usrtc_node_t *node)
{ {
free(node); free(node);
return;
} }
void *usrtc_node_getdata(usrtc_node_t *node) void *usrtc_node_getdata(usrtc_node_t *node)
@ -197,10 +185,9 @@ void *usrtc_node_getdata(usrtc_node_t *node)
return node->data; return node->data;
} }
void usrtc_node_setdata(usrtc_node_t *node, void *data) void usrtc_node_setdata(usrtc_node_t *node,void *data)
{ {
node->data = data; node->data=data;
return;
} }
const void *usrtc_node_getkey(usrtc_node_t *node) const void *usrtc_node_getkey(usrtc_node_t *node)
@ -208,31 +195,29 @@ const void *usrtc_node_getkey(usrtc_node_t *node)
return node->key; return node->key;
} }
void usrtc_insert(usrtc_t *us, usrtc_node_t *node, const void *key) void usrtc_insert(usrtc_t *us,usrtc_node_t *node,const void *key)
{ {
us->futable->usrtc_insert(us, node, key); us->futable->usrtc_insert(us,node,key);
return;
} }
void usrtc_delete(usrtc_t *us, usrtc_node_t *node) void usrtc_delete(usrtc_t *us,usrtc_node_t *node)
{ {
us->futable->usrtc_delete(us, node); us->futable->usrtc_delete(us,node);
return;
} }
usrtc_node_t *usrtc_lookup(usrtc_t *us, const void *key) usrtc_node_t *usrtc_lookup(usrtc_t *us,const void *key)
{ {
return us->futable->usrtc_lookup(us, key); return us->futable->usrtc_lookup(us,key);
} }
usrtc_node_t *usrtc_lower_bound(usrtc_t *us, const void *key) usrtc_node_t *usrtc_lower_bound(usrtc_t *us,const void *key)
{ {
return us->futable->usrtc_lower_bound(us, key); return us->futable->usrtc_lower_bound(us,key);
} }
usrtc_node_t *usrtc_upper_bound(usrtc_t *us, const void *key) usrtc_node_t *usrtc_upper_bound(usrtc_t *us,const void *key)
{ {
return us->futable->usrtc_upper_bound(us, key); return us->futable->usrtc_upper_bound(us,key);
} }
usrtc_node_t *usrtc_first(usrtc_t *us) usrtc_node_t *usrtc_first(usrtc_t *us)
@ -245,13 +230,14 @@ usrtc_node_t *usrtc_last(usrtc_t *us)
return us->futable->usrtc_last(us); return us->futable->usrtc_last(us);
} }
usrtc_node_t *usrtc_next(usrtc_t *us, usrtc_node_t *node) usrtc_node_t *usrtc_next(usrtc_t *us,usrtc_node_t *node)
{ {
return us->futable->usrtc_next(us, node); return us->futable->usrtc_next(us,node);
} }
usrtc_node_t *usrtc_prev(usrtc_t *us, usrtc_node_t *node) usrtc_node_t *usrtc_prev(usrtc_t *us,usrtc_node_t *node)
{ {
return us->futable->usrtc_prev(us, node); return us->futable->usrtc_prev(us,node);
} }

2
man/Makefile.am

@ -1,2 +0,0 @@
man_MANS = usrtc_init.3 usrtc_create.3 usrtc_destroy.3

24
man/reference-template.3

@ -1,24 +0,0 @@
.TH @F_BLOCK@ 3 "@DoM@ @MONTH@ @YEAR@" "LIBTDATA" "Portable data structures C library manual"
.SH NAME
.br
.SH SYNOPSYS
.br
.SH DESCRIPTION
.br
.SH RETURN VALUE
.br
.SH BUGS
.br
.SH EXAMPLE
.br
.SH RATIONALE
.br
.SH SEE ALSO
.br
.SH COPYRIGHT
This software licensed under GNU LGPL v2.1 or later. See COPYING for further details.
.br
(c) Authors of libtdata. See AUTHORS for further details.
.SH AUTHOR
@GIT_NAME@ (@GIT_EMAIL@)
.br

1
man/usrtc_create.3

@ -1 +0,0 @@
usrtc_init.3

1
man/usrtc_destroy.3

@ -1 +0,0 @@
usrtc_init.3

87
man/usrtc_init.3

@ -1,87 +0,0 @@
.TH USRTC_INIT 3 "21 May 2019" "LIBTDATA" "Portable data structures C library manual"
.SH NAME
usrtc_init \- Initialize usrtc core structure
.br
usrtc_create \- Allocate and initialize usrtc core structure
.br
usrtc_destroy \- Destroy (free) usrtc core structure
.br
.SH SYNOPSYS
.B #include <tdata/usrtc.h>
.sp
void usrtc_init(usrtc_t *us, int impl, usrtc_count_t maxcount, usrtc_compare_t compare);
usrtc_t *usrtc_create(int impl, usrtc_count_t maxcount, usrtc_compare_t compare);
void usrtc_destroy(usrtc_t *us);
typedef long (*usrtc_compare_t)(const void*, const void*);
.br
.sp
.SH DESCRIPTION
.B usrtc_init
and
.B usrtc_create
are used to initialize a new usrtc core structure. The difference is
.B usrtc_create
will allocate
.B usrtc_t
structure via
.B malloc()
function, but
.B usrtc_init
expect already allocated structure. Argument
.B impl
is used to point the type of search data structure used for this particular usrtc core structure. Possible values are:
.br
.B * USRTC_LIST:
Linked list
.br
.B * USRTC_BST:
Binary search tree
.br
.B * USRTC_REDBLACK:
Redblack tree
.br
.B * USRTC_SPLAY:
Splay tree
.br
.B * USRTC_AVL:
AVL tree
.br
.B maxcount
argument is pointing to a max amount of the nodes within a search data structure.
.B compare
is a pointer to a compare function.
.br
.B usrtc_destroy
is used to destroy (free) usrtc core structure. This function must be used only for structures allocated via
.B usrtc_create
function.
.br
.SH RETURN VALUE
Valid pointer to a newly allocated and initialized core structure, otherwise
.B NULL.
.br
.SH BUGS
Not known yet.
.br
.SH EXAMPLE
.br
.SH RATIONALE
Using functions
.B usrtc_create
and
.B usrtc_destroy
is deprecating.
.br
.SH SEE ALSO
.br
.SH COPYRIGHT
This software licensed under GNU LGPL v2.1 or later. See COPYING for further details.
.br
(c) Authors of libtdata. See AUTHORS for further details.
.SH AUTHOR
Alexander Vdolainen (alex@vapaa.xyz)
.br