Fix state losses for recursive outliner trees (e.g. datablocks editor)
[blender-staging.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 #include "BLI_sys_types.h" /* for bool */
37
38 #ifdef __cplusplus
39 extern "C" {
40 #endif
41
42 typedef unsigned int  (*GHashHashFP)     (const void *key);
43 typedef int           (*GHashCmpFP)      (const void *a, const void *b);
44 typedef void          (*GHashKeyFreeFP)  (void *key);
45 typedef void          (*GHashValFreeFP)  (void *val);
46
47 typedef struct GHash GHash;
48
49 typedef struct GHashIterator {
50         GHash *gh;
51         struct Entry *curEntry;
52         unsigned int curBucket;
53 } GHashIterator;
54
55 enum {
56         GHASH_FLAG_ALLOW_DUPES = (1 << 0),  /* only checked for in debug mode */
57 };
58
59 /* *** */
60
61 GHash *BLI_ghash_new(GHashHashFP hashfp, GHashCmpFP cmpfp, const char *info);
62 void   BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp);
63 void   BLI_ghash_insert(GHash *gh, void *key, void *val);
64 void   BLI_ghash_reinsert(GHash *gh, void *key, void *val, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp);
65 void  *BLI_ghash_lookup(GHash *gh, const void *key);
66 void **BLI_ghash_lookup_p(GHash *gh, const void *key);
67 bool   BLI_ghash_remove(GHash *gh, void *key, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp);
68 void   BLI_ghash_clear(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp);
69 void  *BLI_ghash_pop(GHash *gh, void *key, GHashKeyFreeFP keyfreefp);
70 bool   BLI_ghash_haskey(GHash *gh, const void *key);
71 int    BLI_ghash_size(GHash *gh);
72 void   BLI_ghash_flag_set(GHash *gh, unsigned short flag);
73 void   BLI_ghash_flag_clear(GHash *gh, unsigned short flag);
74
75 /* *** */
76
77 /**
78  * Create a new GHashIterator. The hash table must not be mutated
79  * while the iterator is in use, and the iterator will step exactly
80  * BLI_ghash_size(gh) times before becoming done.
81  *
82  * \param gh The GHash to iterate over.
83  * \return Pointer to a new DynStr.
84  */
85 GHashIterator *BLI_ghashIterator_new(GHash *gh);
86 /**
87  * Init an already allocated GHashIterator. The hash table must not
88  * be mutated while the iterator is in use, and the iterator will
89  * step exactly BLI_ghash_size(gh) times before becoming done.
90  *
91  * \param ghi The GHashIterator to initialize.
92  * \param gh The GHash to iterate over.
93  */
94 void BLI_ghashIterator_init(GHashIterator *ghi, GHash *gh);
95 /**
96  * Free a GHashIterator.
97  *
98  * \param ghi The iterator to free.
99  */
100 void            BLI_ghashIterator_free(GHashIterator *ghi);
101
102 /**
103  * Retrieve the key from an iterator.
104  *
105  * \param ghi The iterator.
106  * \return The key at the current index, or NULL if the
107  * iterator is done.
108  */
109 void           *BLI_ghashIterator_getKey(GHashIterator *ghi);
110 /**
111  * Retrieve the value from an iterator.
112  *
113  * \param ghi The iterator.
114  * \return The value at the current index, or NULL if the
115  * iterator is done.
116  */
117 void           *BLI_ghashIterator_getValue(GHashIterator *ghi);
118 /**
119  * Steps the iterator to the next index.
120  *
121  * \param ghi The iterator.
122  */
123 void            BLI_ghashIterator_step(GHashIterator *ghi);
124 /**
125  * Determine if an iterator is done (has reached the end of
126  * the hash table).
127  *
128  * \param ghi The iterator.
129  * \return True if done, False otherwise.
130  */
131 bool            BLI_ghashIterator_done(GHashIterator *ghi);
132
133 #define GHASH_ITER(gh_iter_, ghash_)                                          \
134         for (BLI_ghashIterator_init(&gh_iter_, ghash_);                           \
135              BLI_ghashIterator_done(&gh_iter_) == false;                          \
136              BLI_ghashIterator_step(&gh_iter_))
137
138 #define GHASH_ITER_INDEX(gh_iter_, ghash_, i_)                                \
139         for (BLI_ghashIterator_init(&gh_iter_, ghash_), i_ = 0;                   \
140              BLI_ghashIterator_done(&gh_iter_) == false;                          \
141              BLI_ghashIterator_step(&gh_iter_), i_++)
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 GHash          *BLI_ghash_ptr_new(const char *info);
155 GHash          *BLI_ghash_str_new(const char *info);
156 GHash          *BLI_ghash_int_new(const char *info);
157 GHash          *BLI_ghash_pair_new(const char *info);
158
159 typedef struct GHashPair {
160         const void *first;
161         const void *second;
162 } GHashPair;
163
164 GHashPair      *BLI_ghashutil_pairalloc(const void *first, const void *second);
165 unsigned int    BLI_ghashutil_pairhash(const void *ptr);
166 int             BLI_ghashutil_paircmp(const void *a, const void *b);
167 void            BLI_ghashutil_pairfree(void *ptr);
168
169 #ifdef __cplusplus
170 }
171 #endif
172
173 #endif /* __BLI_GHASH_H__ */