66025c04332d058915f0f8eab8f4b6b86079c1c7
[blender-staging.git] / source / blender / blenkernel / intern / library_idmap.c
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  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 #include <string.h>
22 #include <stdlib.h>
23
24 #include "MEM_guardedalloc.h"
25
26 #include "BLI_utildefines.h"
27 #include "BLI_ghash.h"
28 #include "BLI_listbase.h"
29
30 #include "DNA_ID.h"
31
32 #include "BKE_idcode.h"
33 #include "BKE_library.h"
34 #include "BKE_library_idmap.h"  /* own include */
35
36 /** \file blender/blenkernel/intern/library_map.c
37  *  \ingroup bke
38  *
39  * Utility functions for faster ID lookups.
40  */
41
42 /** \name BKE_main_idmap API
43  *
44  * Cache ID (name, library lookups).
45  * This doesn't account for adding/removing data-blocks,
46  * and should only be used when performing many lookups.
47  *
48  * \note GHash's are initialized on demand,
49  * since its likely some types will never have lookups run on them,
50  * so its a waste to create and never use.
51  * \{ */
52
53 struct IDNameLib_Key {
54         /** ``ID.name + 2``: without the ID type prefix, since each id type gets it's own 'map' */
55         const char *name;
56         /** ``ID.lib``: */
57         const Library *lib;
58 };
59
60 struct IDNameLib_TypeMap {
61         GHash *map;
62         short id_type;
63         /* only for storage of keys in the ghash, avoid many single allocs */
64         struct IDNameLib_Key *keys;
65 };
66
67 /**
68  * Opaque structure, external API users only see this.
69  */
70 struct IDNameLib_Map {
71         struct IDNameLib_TypeMap type_maps[MAX_LIBARRAY];
72         struct Main *bmain;
73 };
74
75 static struct IDNameLib_TypeMap *main_idmap_from_idcode(struct IDNameLib_Map *id_map, short id_type)
76 {
77         for (int i = 0; i < MAX_LIBARRAY; i++) {
78                 if (id_map->type_maps[i].id_type == id_type) {
79                         return &id_map->type_maps[i];
80                 }
81         }
82         return NULL;
83 }
84
85 struct IDNameLib_Map *BKE_main_idmap_create(struct Main *bmain)
86 {
87         struct IDNameLib_Map *id_map = MEM_mallocN(sizeof(*id_map), __func__);
88
89         int index = 0;
90         while (index < MAX_LIBARRAY) {
91                 struct IDNameLib_TypeMap *type_map = &id_map->type_maps[index];
92                 type_map->map = NULL;
93                 type_map->id_type = BKE_idcode_iter_step(&index);
94                 BLI_assert(type_map->id_type != 0);
95         }
96         BLI_assert(index == MAX_LIBARRAY);
97
98         id_map->bmain = bmain;
99
100         return id_map;
101 }
102
103 struct Main *BKE_main_idmap_main_get(struct IDNameLib_Map *id_map)
104 {
105         return id_map->bmain;
106 }
107
108 static unsigned int idkey_hash(const void *ptr)
109 {
110         const struct IDNameLib_Key *idkey = ptr;
111         unsigned int key = BLI_ghashutil_strhash(idkey->name);
112         if (idkey->lib) {
113                 key ^= BLI_ghashutil_ptrhash(idkey->lib);
114         }
115         return key;
116 }
117
118 static bool idkey_cmp(const void *a, const void *b)
119 {
120         const struct IDNameLib_Key *idkey_a = a;
121         const struct IDNameLib_Key *idkey_b = b;
122         return strcmp(idkey_a->name, idkey_b->name) || (idkey_a->lib != idkey_b->lib);
123 }
124
125 ID *BKE_main_idmap_lookup(struct IDNameLib_Map *id_map, short id_type, const char *name, const Library *lib)
126 {
127         struct IDNameLib_TypeMap *type_map = main_idmap_from_idcode(id_map, id_type);
128
129         if (UNLIKELY(type_map == NULL)) {
130                 return NULL;
131         }
132
133         /* lazy init */
134         if (type_map->map == NULL) {
135                 ListBase *lb = which_libbase(id_map->bmain, id_type);
136                 const int lb_len = BLI_listbase_count(lb);
137                 if (lb_len == 0) {
138                         return NULL;
139                 }
140                 type_map->map = BLI_ghash_new_ex(idkey_hash, idkey_cmp, __func__, lb_len);
141                 type_map->keys = MEM_mallocN(sizeof(struct IDNameLib_Key) * lb_len, __func__);
142
143                 GHash *map = type_map->map;
144                 struct IDNameLib_Key *key = type_map->keys;
145
146                 for (ID *id = lb->first; id; id = id->next, key++) {
147                         key->name = id->name + 2;
148                         key->lib = id->lib;
149                         BLI_ghash_insert(map, key, id);
150                 }
151         }
152
153         const struct IDNameLib_Key key_lookup = {name, lib};
154         return BLI_ghash_lookup(type_map->map, &key_lookup);
155 }
156
157 ID *BKE_main_idmap_lookup_id(struct IDNameLib_Map *id_map, const ID *id)
158 {
159         return BKE_main_idmap_lookup(id_map, GS(id->name), id->name + 2, id->lib);
160 }
161
162 void BKE_main_idmap_destroy(struct IDNameLib_Map *id_map)
163 {
164         struct IDNameLib_TypeMap *type_map = id_map->type_maps;
165         for (int i = 0; i < MAX_LIBARRAY; i++, type_map++) {
166                 if (type_map->map) {
167                         BLI_ghash_free(type_map->map, NULL, NULL);
168                         type_map->map = NULL;
169                         MEM_freeN(type_map->keys);
170                 }
171         }
172
173         MEM_freeN(id_map);
174 }
175
176 /** \} */