Flush the journal after every write.
[pspp] / src / libpspp / hash.h
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2009 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #if !hash_h
18 #define hash_h 1
19
20 #include <stddef.h>
21 #include <stdbool.h>
22 #include <libpspp/hash-functions.h>
23
24 typedef int hsh_compare_func (const void *, const void *, const void *aux);
25 typedef unsigned hsh_hash_func (const void *, const void *aux);
26 typedef void hsh_free_func (void *, const void *aux);
27
28 /* Hash table iterator (opaque). */
29 struct hsh_iterator
30   {
31     size_t next;                /* Index of next entry. */
32   };
33
34 /* Hash tables. */
35 struct hsh_table *hsh_create (int m, hsh_compare_func *,
36                               hsh_hash_func *, hsh_free_func *,
37                               const void *aux);
38
39 struct pool;
40 struct hsh_table *hsh_create_pool (struct pool *pool, int m,
41                                    hsh_compare_func *,
42                                    hsh_hash_func *, hsh_free_func *,
43                                    const void *aux);
44
45 void hsh_clear (struct hsh_table *);
46 void hsh_destroy (struct hsh_table *);
47 void *const *hsh_sort (struct hsh_table *);
48 void *const *hsh_data (struct hsh_table *);
49 void **hsh_sort_copy (struct hsh_table *);
50 void **hsh_data_copy (struct hsh_table *);
51
52 /* Search and insertion. */
53 void **hsh_probe (struct hsh_table *, const void *);
54 void *hsh_insert (struct hsh_table *, void *);
55 void *hsh_replace (struct hsh_table *, void *);
56 void *hsh_find (struct hsh_table *, const void *);
57 bool hsh_delete (struct hsh_table *, const void *);
58
59 /* Iteration. */
60 void *hsh_first (struct hsh_table *, struct hsh_iterator *);
61 void *hsh_next (struct hsh_table *, struct hsh_iterator *);
62
63 /* Search and insertion with assertion. */
64 #if DEBUGGING
65 void hsh_force_insert (struct hsh_table *, void *);
66 void *hsh_force_find (struct hsh_table *, const void *);
67 void hsh_force_delete (struct hsh_table *, const void *);
68 #else
69 #define hsh_force_insert(A, B)  ((void) (*hsh_probe (A, B) = B))
70 #define hsh_force_find(A, B)    (hsh_find (A, B))
71 #define hsh_force_delete(A, B)  ((void) hsh_delete (A, B))
72 #endif
73
74 /* Number of entries in hash table H. */
75 size_t hsh_count (struct hsh_table *);
76
77 /* Debugging. */
78 #if DEBUGGING
79 void hsh_dump (struct hsh_table *);
80 #endif
81
82
83 /* Const Wrappers for the above */
84
85 static inline struct const_hsh_table *
86 const_hsh_create (int m,
87                   hsh_compare_func *hcf,
88                   hsh_hash_func *hhf, hsh_free_func *hff,
89                   const void *aux)
90 {
91   return (struct const_hsh_table *) hsh_create (m, hcf, hhf, hff, aux);
92 }
93
94
95
96 static inline struct const_hsh_table *
97 const_hsh_create_pool (struct pool *pool, int m,
98                        hsh_compare_func *cf,
99                        hsh_hash_func *hf, hsh_free_func *ff,
100                        const void *aux)
101 {
102   return (struct const_hsh_table *) hsh_create_pool (pool, m, cf, hf, ff, aux);
103 }
104
105
106 static inline void
107 const_hsh_clear (struct const_hsh_table *h)
108 {
109   hsh_clear ( (struct hsh_table *) h);
110 }
111
112 static inline void
113 const_hsh_destroy (struct const_hsh_table *h)
114 {
115   hsh_destroy ( (struct hsh_table *) h);
116 }
117
118 static inline void *const *
119 const_hsh_sort (struct const_hsh_table *h)
120 {
121   return hsh_sort ( (struct hsh_table *) h);
122 }
123
124 static inline void *const *
125 const_hsh_data (struct const_hsh_table *h)
126 {
127   return hsh_data ( (struct hsh_table *) h);
128 }
129
130 static inline void **
131 const_hsh_sort_copy (struct const_hsh_table *h)
132 {
133   return hsh_sort_copy ( (struct hsh_table *) h);
134 }
135
136 static inline void **
137 const_hsh_data_copy (struct const_hsh_table *h)
138 {
139   return hsh_data_copy ( (struct hsh_table *) h);
140 }
141
142
143 static inline size_t
144 const_hsh_count (struct const_hsh_table *h)
145 {
146   return hsh_count ( (struct hsh_table *) h);
147 }
148
149 static inline void *
150 const_hsh_insert (struct const_hsh_table *h, const void *item)
151 {
152   return hsh_insert ( (struct hsh_table *) h, (void *) item);
153 }
154
155 static inline void *
156 const_hsh_replace (struct const_hsh_table *h, const void *item)
157 {
158   return hsh_replace ( (struct hsh_table *) h, (void *) item);
159 }
160
161 static inline void *
162 const_hsh_find (struct const_hsh_table *h, const void *item)
163 {
164   return hsh_find ( (struct hsh_table *) h, (void *) item);
165 }
166
167 static inline bool
168 const_hsh_delete (struct const_hsh_table *h, const void *item)
169 {
170   return hsh_delete ( (struct hsh_table *)h, (void *) item);
171 }
172
173
174 static inline void *
175 const_hsh_first (struct const_hsh_table *h, struct hsh_iterator *i)
176 {
177   return hsh_first ( (struct hsh_table *) h, i);
178 }
179
180 static inline void *
181 const_hsh_next (struct const_hsh_table *h, struct hsh_iterator *i)
182 {
183   return hsh_next ( (struct hsh_table *) h, i);
184 }
185
186
187 #endif /* hash_h */