svn merge ^/trunk/blender -r42778:42839
[blender.git] / source / blender / blenlib / BLI_ghash.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (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, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27  
28 #ifndef BLI_GHASH_H
29 #define BLI_GHASH_H
30
31 /** \file BLI_ghash.h
32  *  \ingroup bli
33  *  \brief A general (pointer -> pointer) hash table ADT
34  */
35
36 #ifdef __cplusplus
37 extern "C" {
38 #endif
39
40 typedef unsigned int    (*GHashHashFP)          (const void *key);
41 typedef int                             (*GHashCmpFP)           (const void *a, const void *b);
42 typedef void                    (*GHashKeyFreeFP)       (void *key);
43 typedef void                    (*GHashValFreeFP)       (void *val);
44
45 typedef struct Entry {
46         struct Entry *next;
47
48         void *key, *val;
49 } Entry;
50
51 typedef struct GHash {
52         GHashHashFP     hashfp;
53         GHashCmpFP      cmpfp;
54
55         Entry **buckets;
56         struct BLI_mempool *entrypool;
57         int nbuckets, nentries, cursize;
58 } GHash;
59
60 typedef struct GHashIterator {
61         GHash *gh;
62         int curBucket;
63         struct Entry *curEntry;
64 } GHashIterator;
65
66 /* *** */
67
68 GHash* BLI_ghash_new   (GHashHashFP hashfp, GHashCmpFP cmpfp, const char *info);
69 void   BLI_ghash_free  (GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp);
70 void   BLI_ghash_insert(GHash *gh, void *key, void *val);
71 void * BLI_ghash_lookup(GHash *gh, const void *key);
72 int    BLI_ghash_remove(GHash *gh, void *key, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp);
73 int    BLI_ghash_haskey(GHash *gh, void *key);
74 int        BLI_ghash_size  (GHash *gh);
75
76 /* *** */
77
78         /**
79          * Create a new GHashIterator. The hash table must not be mutated
80          * while the iterator is in use, and the iterator will step exactly
81          * BLI_ghash_size(gh) times before becoming done.
82          * 
83          * @param gh The GHash to iterate over.
84          * @return Pointer to a new DynStr.
85          */
86 GHashIterator*  BLI_ghashIterator_new           (GHash *gh);
87         /**
88          * Init an already allocated GHashIterator. The hash table must not
89          * be mutated while the iterator is in use, and the iterator will
90          * step exactly BLI_ghash_size(gh) times before becoming done.
91          * 
92          * @param ghi The GHashIterator to initialize.
93          * @param gh The GHash to iterate over.
94          */
95 void BLI_ghashIterator_init(GHashIterator *ghi, GHash *gh);
96         /**
97          * Free a GHashIterator.
98          *
99          * @param ghi The iterator to free.
100          */
101 void                    BLI_ghashIterator_free          (GHashIterator *ghi);
102
103         /**
104          * Retrieve the key from an iterator.
105          *
106          * @param ghi The iterator.
107          * @return The key at the current index, or NULL if the 
108          * iterator is done.
109          */
110 void*                   BLI_ghashIterator_getKey        (GHashIterator *ghi);
111         /**
112          * Retrieve the value from an iterator.
113          *
114          * @param ghi The iterator.
115          * @return The value at the current index, or NULL if the 
116          * iterator is done.
117          */
118 void*                   BLI_ghashIterator_getValue      (GHashIterator *ghi);
119         /**
120          * Steps the iterator to the next index.
121          *
122          * @param ghi The iterator.
123          */
124 void                    BLI_ghashIterator_step          (GHashIterator *ghi);
125         /**
126          * Determine if an iterator is done (has reached the end of
127          * the hash table).
128          *
129          * @param ghi The iterator.
130          * @return True if done, False otherwise.
131          */
132 int                             BLI_ghashIterator_isDone        (GHashIterator *ghi);
133
134 /* *** */
135
136 unsigned int    BLI_ghashutil_ptrhash   (const void *key);
137 int                             BLI_ghashutil_ptrcmp    (const void *a, const void *b);
138
139 unsigned int    BLI_ghashutil_strhash   (const void *key);
140 int                             BLI_ghashutil_strcmp    (const void *a, const void *b);
141
142 unsigned int    BLI_ghashutil_inthash   (const void *ptr);
143 int                             BLI_ghashutil_intcmp    (const void *a, const void *b);
144
145 typedef struct GHashPair {
146         const void *first;
147         int second;
148 } GHashPair;
149
150 GHashPair*              BLI_ghashutil_pairalloc (const void *first, int second);
151 unsigned int    BLI_ghashutil_pairhash  (const void *ptr);
152 int                             BLI_ghashutil_paircmp   (const void *a, const void *b);
153 void                    BLI_ghashutil_pairfree  (void *ptr);
154
155 #ifdef __cplusplus
156 }
157 #endif
158
159 #endif /* BLI_GHASH_H */