1 /* oblist.h:
2  *
3  ****************************************************************
4  * Copyright (C) 2004 Tom Lord
5  *
6  * See the file "COPYING" for further information about
7  * the copyright and warranty status of this work.
8  */
9 
10 #ifndef INCLUDE__LIBAWIKI__OBLIST_H
11 #define INCLUDE__LIBAWIKI__OBLIST_H
12 
13 
14 #include "hackerlab/obqueues/obqueue.h"
15 
16 
17 typedef struct oblist t_oblist;
18 typedef struct oblist_type t_oblist_type;
19 
20 
21 typedef int (*t_oblist_cmp_fn) (void * a, void * b, void * closure);
22 typedef int (*t_oblist_init_fn) (t_oblist * ot,
23                                  alloc_limits limits,
24                                  ssize_t elt_size,
25                                  t_oblist_type * type,
26                                  void * closure,
27                                  void * mem,
28                                  ssize_t n_elts);
29 typedef void (*t_oblist_uninit_fn) (t_oblist * ot,
30                                     alloc_limits limits,
31                                     ssize_t elt_size,
32                                     t_oblist_type * type,
33                                     void * closure,
34                                     void * mem,
35                                     ssize_t n_elts);
36 
37 
38 
39 struct oblist_type
40 {
41   t_oblist_init_fn init;
42   t_oblist_uninit_fn uninit;
43 };
44 
45 
46 struct oblist
47 {
48   struct obqueue _left;
49   struct obqueue _right;
50 };
51 
52 
53 
54 /* automatically generated __STDC__ prototypes */
55 extern int init_oblist (t_oblist * ol,
56                         alloc_limits limits,
57                         ssize_t elt_size,
58                         t_oblist_type * type,
59                         void * closure);
60 extern void uninit_oblist (t_oblist * ol,
61                            alloc_limits limits,
62                            ssize_t elt_size,
63                            t_oblist_type * type,
64                            void * closure);
65 extern int oblist_is_empty (t_oblist * ol,
66                             alloc_limits limits,
67                             ssize_t elt_size,
68                             t_oblist_type * type,
69                             void * closure);
70 extern ssize_t oblist_size (t_oblist * ol,
71                             alloc_limits limits,
72                             ssize_t elt_size,
73                             t_oblist_type * type,
74                             void * closure);
75 extern ssize_t oblist_room (t_oblist * ol,
76                             alloc_limits limits,
77                             ssize_t elt_size,
78                             t_oblist_type * type,
79                             void * closure);
80 extern void * oblist_burst (ssize_t * len_returned,
81                             t_oblist * ol,
82                             alloc_limits limits,
83                             ssize_t elt_size,
84                             t_oblist_type * type,
85                             void * closure,
86                             ssize_t n,
87                             ssize_t len);
88 extern void * oblist_range (t_oblist * ol,
89                             alloc_limits limits,
90                             ssize_t elt_size,
91                             t_oblist_type * type,
92                             void * closure,
93                             ssize_t n,
94                             ssize_t len);
95 extern int oblist_insert_n (t_oblist * ol,
96                             alloc_limits limits,
97                             ssize_t elt_size,
98                             t_oblist_type * type,
99                             void * closure,
100                             ssize_t before_pos,
101                             ssize_t n,
102                             void * mem);
103 extern int oblist_delete_n (t_oblist * ol,
104                             alloc_limits limits,
105                             ssize_t elt_size,
106                             t_oblist_type * type,
107                             void * closure,
108                             ssize_t pos,
109                             ssize_t n);
110 extern int oblist_sort (t_oblist * ol,
111                         alloc_limits limits,
112                         ssize_t elt_size,
113                         t_oblist_type * type,
114                         void * lclosure,
115                         t_oblist_cmp_fn cmp,
116                         void * closure);
117 extern ssize_t oblist_find (ssize_t * would_be_before,
118                             t_oblist * ol,
119                             alloc_limits limits,
120                             ssize_t elt_size,
121                             t_oblist_type * type,
122                             void * lclosure,
123                             void * key,
124                             t_oblist_cmp_fn cmp,
125                             void * closure);
126 extern ssize_t oblist_sorted_insert (t_oblist * ol,
127                                      alloc_limits limits,
128                                      ssize_t elt_size,
129                                      t_oblist_type * type,
130                                      void * lclosure,
131                                      void * key,
132                                      t_oblist_cmp_fn cmp,
133                                      void * closure,
134                                      int copy_from_key,
135                                      int not_if_present);
136 #endif  /* INCLUDE__LIBAWIKI__OBLIST_H */
137 
138 
139 /* tag: Tom Lord Sun Oct 24 08:12:41 2004 (oblist.h)
140  */
141