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