summaryrefslogtreecommitdiff
path: root/vcs-svn/trp.txt
blob: 5ca6b42edb289c5f5714ae2f0a09710d40dd14f3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
Motivation
==========
 
Treaps provide a memory-efficient binary search tree structure.
Insertion/deletion/search are about as about as fast in the average
case as red-black trees and the chances of worst-case behavior are
vanishingly small, thanks to (pseudo-)randomness.  The bad worst-case
behavior is a small price to pay, given that treaps are much simpler
to implement.
 
API
===
 
The trp API generates a data structure and functions to handle a
large growing set of objects stored in a pool.
 
The caller:
 
. Specifies parameters for the generated functions with the
  trp_gen(static, foo_, ...) macro.
 
. Allocates a `struct trp_root` variable and sets it to {~0}.
 
. Adds new nodes to the set using `foo_insert`.  Any pointers
  to existing nodes cannot be relied upon any more, so the caller
  might retrieve them anew with `foo_pointer`.
 
. Can find a specific item in the set using `foo_search`.
 
. Can iterate over items in the set using `foo_first` and `foo_next`.
 
. Can remove an item from the set using `foo_remove`.
 
Example:
 
----
struct ex_node {
	const char *s;
	struct trp_node ex_link;
};
static struct trp_root ex_base = {~0};
obj_pool_gen(ex, struct ex_node, 4096);
trp_gen(static, ex_, struct ex_node, ex_link, ex, strcmp)
struct ex_node *item;
 
item = ex_pointer(ex_alloc(1));
item->s = "hello";
ex_insert(&ex_base, item);
item = ex_pointer(ex_alloc(1));
item->s = "goodbye";
ex_insert(&ex_base, item);
for (item = ex_first(&ex_base); item; item = ex_next(&ex_base, item))
	printf("%s\n", item->s);
----
 
Functions
---------
 
trp_gen(attr, foo_, node_type, link_field, pool, cmp)::
 
	Generate a type-specific treap implementation.
+
. The storage class for generated functions will be 'attr' (e.g., `static`).
. Generated function names are prefixed with 'foo_' (e.g., `treap_`).
. Treap nodes will be of type 'node_type' (e.g., `struct treap_node`).
  This type must be a struct with at least one `struct trp_node` field
  to point to its children.
. The field used to access child nodes will be 'link_field'.
. All treap nodes must lie in the 'pool' object pool.
. Treap nodes must be totally ordered by the 'cmp' relation, with the
  following prototype:
+
int (*cmp)(node_type \*a, node_type \*b)
+
and returning a value less than, equal to, or greater than zero
according to the result of comparison.
 
node_type {asterisk}foo_insert(struct trp_root *treap, node_type \*node)::
 
	Insert node into treap.  If inserted multiple times,
	a node will appear in the treap multiple times.
+
The return value is the address of the node within the treap,
which might differ from `node` if `pool_alloc` had to call
`realloc` to expand the pool.
 
void foo_remove(struct trp_root *treap, node_type \*node)::
 
	Remove node from treap.  Caller must ensure node is
	present in treap before using this function.
 
node_type *foo_search(struct trp_root \*treap, node_type \*key)::
 
	Search for a node that matches key.  If no match is found,
	result is NULL.
 
node_type *foo_nsearch(struct trp_root \*treap, node_type \*key)::
 
	Like `foo_search`, but if if the key is missing return what
	would be key's successor, were key in treap (NULL if no
	successor).
 
node_type *foo_first(struct trp_root \*treap)::
 
	Find the first item from the treap, in sorted order.
 
node_type *foo_next(struct trp_root \*treap, node_type \*node)::
 
	Find the next item.