Merge branch 'master' into blender2.8

source/blender/blenlib/BLI_ghash.h

@@ -257,6 +257,10 @@ void   BLI_gset_clear_ex(GSet *gs, GSetKeyFreeFP keyfreefp,
                          const unsigned int nentries_reserve);
 void   BLI_gset_clear(GSet *gs, GSetKeyFreeFP keyfreefp);
 
+/* When set's are used for key & value. */
+void  *BLI_gset_lookup(GSet *gh, const void *key) ATTR_WARN_UNUSED_RESULT;
+void  *BLI_gset_pop_key(GSet *gs, const void *key) ATTR_WARN_UNUSED_RESULT;
+
 GSet *BLI_gset_ptr_new_ex(const char *info, const unsigned int nentries_reserve) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT;
 GSet *BLI_gset_ptr_new(const char *info);
 GSet *BLI_gset_str_new_ex(const char *info, const unsigned int nentries_reserve) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT;

source/blender/blenlib/intern/BLI_ghash.c

@@ -53,7 +53,7 @@
 #define GHASH_USE_MODULO_BUCKETS
 
 /* Also used by smallhash! */
-const unsigned int hashsizes[] = {
+const uint hashsizes[] = {
 	5, 11, 17, 37, 67, 131, 257, 521, 1031, 2053, 4099, 8209, 
 	16411, 32771, 65537, 131101, 262147, 524309, 1048583, 2097169, 
 	4194319, 8388617, 16777259, 33554467, 67108879, 134217757, 
@@ -103,16 +103,16 @@ struct GHash {
 
 	Entry **buckets;
 	struct BLI_mempool *entrypool;
-	unsigned int nbuckets;
+	uint nbuckets;
-	unsigned int limit_grow, limit_shrink;
+	uint limit_grow, limit_shrink;
 #ifdef GHASH_USE_MODULO_BUCKETS
-	unsigned int cursize, size_min;
+	uint cursize, size_min;
 #else
-	unsigned int bucket_mask, bucket_bit, bucket_bit_min;
+	uint bucket_mask, bucket_bit, bucket_bit_min;
 #endif
 
-	unsigned int nentries;
+	uint nentries;
-	unsigned int flag;
+	uint flag;
 };
 
 
@@ -141,7 +141,7 @@ BLI_INLINE void ghash_entry_copy(
 /**
  * Get the full hash for a key.
  */
-BLI_INLINE unsigned int ghash_keyhash(GHash *gh, const void *key)
+BLI_INLINE uint ghash_keyhash(GHash *gh, const void *key)
 {
 	return gh->hashfp(key);
 }
@@ -149,7 +149,7 @@ BLI_INLINE unsigned int ghash_keyhash(GHash *gh, const void *key)
 /**
  * Get the full hash for an entry.
  */
-BLI_INLINE unsigned int ghash_entryhash(GHash *gh, const Entry *e)
+BLI_INLINE uint ghash_entryhash(GHash *gh, const Entry *e)
 {
 	return gh->hashfp(e->key);
 }
@@ -157,7 +157,7 @@ BLI_INLINE unsigned int ghash_entryhash(GHash *gh, const Entry *e)
 /**
  * Get the bucket-index for an already-computed full hash.
  */
-BLI_INLINE unsigned int ghash_bucket_index(GHash *gh, const unsigned int hash)
+BLI_INLINE uint ghash_bucket_index(GHash *gh, const uint hash)
 {
 #ifdef GHASH_USE_MODULO_BUCKETS
 	return hash % gh->nbuckets;
@@ -169,7 +169,7 @@ BLI_INLINE unsigned int ghash_bucket_index(GHash *gh, const unsigned int hash)
 /**
  * Find the index of next used bucket, starting from \a curr_bucket (\a gh is assumed non-empty).
  */
-BLI_INLINE unsigned int ghash_find_next_bucket_index(GHash *gh, unsigned int curr_bucket)
+BLI_INLINE uint ghash_find_next_bucket_index(GHash *gh, uint curr_bucket)
 {
 	if (curr_bucket >= gh->nbuckets) {
 		curr_bucket = 0;
@@ -194,12 +194,12 @@ BLI_INLINE unsigned int ghash_find_next_bucket_index(GHash *gh, unsigned int cur
 /**
  * Expand buckets to the next size up or down.
  */
-static void ghash_buckets_resize(GHash *gh, const unsigned int nbuckets)
+static void ghash_buckets_resize(GHash *gh, const uint nbuckets)
 {
 	Entry **buckets_old = gh->buckets;
 	Entry **buckets_new;
-	const unsigned int nbuckets_old = gh->nbuckets;
+	const uint nbuckets_old = gh->nbuckets;
-	unsigned int i;
+	uint i;
 
 	BLI_assert((gh->nbuckets != nbuckets) || !gh->buckets);
 //	printf("%s: %d -> %d\n", __func__, nbuckets_old, nbuckets);
@@ -261,9 +261,9 @@ static void ghash_buckets_resize(GHash *gh, const unsigned int nbuckets)
  * or small enough to require less buckets, and resize \a gh accordingly.
  */
 static void ghash_buckets_expand(
-        GHash *gh, const unsigned int nentries, const bool user_defined)
+        GHash *gh, const uint nentries, const bool user_defined)
 {
-	unsigned int new_nbuckets;
+	uint new_nbuckets;
 
 	if (LIKELY(gh->buckets && (nentries < gh->limit_grow))) {
 		return;
@@ -305,9 +305,9 @@ static void ghash_buckets_expand(
 }
 
 static void ghash_buckets_contract(
-        GHash *gh, const unsigned int nentries, const bool user_defined, const bool force_shrink)
+        GHash *gh, const uint nentries, const bool user_defined, const bool force_shrink)
 {
-	unsigned int new_nbuckets;
+	uint new_nbuckets;
 
 	if (!(force_shrink || (gh->flag & GHASH_FLAG_ALLOW_SHRINK))) {
 		return;
@@ -355,7 +355,7 @@ static void ghash_buckets_contract(
 /**
  * Clear and reset \a gh buckets, reserve again buckets for given number of entries.
  */
-BLI_INLINE void ghash_buckets_reset(GHash *gh, const unsigned int nentries)
+BLI_INLINE void ghash_buckets_reset(GHash *gh, const uint nentries)
 {
 	MEM_SAFE_FREE(gh->buckets);
 
@@ -383,7 +383,7 @@ BLI_INLINE void ghash_buckets_reset(GHash *gh, const unsigned int nentries)
  * Takes hash and bucket_index arguments to avoid calling #ghash_keyhash and #ghash_bucket_index multiple times.
  */
 BLI_INLINE Entry *ghash_lookup_entry_ex(
-        GHash *gh, const void *key, const unsigned int bucket_index)
+        GHash *gh, const void *key, const uint bucket_index)
 {
 	Entry *e;
 	/* If we do not store GHash, not worth computing it for each entry here!
@@ -404,7 +404,7 @@ BLI_INLINE Entry *ghash_lookup_entry_ex(
  */
 BLI_INLINE Entry *ghash_lookup_entry_prev_ex(
         GHash *gh, const void *key,
-        Entry **r_e_prev, const unsigned int bucket_index)
+        Entry **r_e_prev, const uint bucket_index)
 {
 	/* If we do not store GHash, not worth computing it for each entry here!
 	 * Typically, comparison function will be quicker, and since it's needed in the end anyway... */
@@ -424,13 +424,13 @@ BLI_INLINE Entry *ghash_lookup_entry_prev_ex(
  */
 BLI_INLINE Entry *ghash_lookup_entry(GHash *gh, const void *key)
 {
-	const unsigned int hash = ghash_keyhash(gh, key);
+	const uint hash = ghash_keyhash(gh, key);
-	const unsigned int bucket_index = ghash_bucket_index(gh, hash);
+	const uint bucket_index = ghash_bucket_index(gh, hash);
 	return ghash_lookup_entry_ex(gh, key, bucket_index);
 }
 
 static GHash *ghash_new(GHashHashFP hashfp, GHashCmpFP cmpfp, const char *info,
-                        const unsigned int nentries_reserve, const unsigned int flag)
+                        const uint nentries_reserve, const uint flag)
 {
 	GHash *gh = MEM_mallocN(sizeof(*gh), info);
 
@@ -451,7 +451,7 @@ static GHash *ghash_new(GHashHashFP hashfp, GHashCmpFP cmpfp, const char *info,
  * Takes hash and bucket_index arguments to avoid calling #ghash_keyhash and #ghash_bucket_index multiple times.
  */
 BLI_INLINE void ghash_insert_ex(
-        GHash *gh, void *key, void *val, const unsigned int bucket_index)
+        GHash *gh, void *key, void *val, const uint bucket_index)
 {
 	GHashEntry *e = BLI_mempool_alloc(gh->entrypool);
 
@@ -470,7 +470,7 @@ BLI_INLINE void ghash_insert_ex(
  * Insert function that takes a pre-allocated entry.
  */
 BLI_INLINE void ghash_insert_ex_keyonly_entry(
-        GHash *gh, void *key, const unsigned int bucket_index,
+        GHash *gh, void *key, const uint bucket_index,
         Entry *e)
 {
 	BLI_assert((gh->flag & GHASH_FLAG_ALLOW_DUPES) || (BLI_ghash_haskey(gh, key) == 0));
@@ -486,7 +486,7 @@ BLI_INLINE void ghash_insert_ex_keyonly_entry(
  * Insert function that doesn't set the value (use for GSet)
  */
 BLI_INLINE void ghash_insert_ex_keyonly(
-        GHash *gh, void *key, const unsigned int bucket_index)
+        GHash *gh, void *key, const uint bucket_index)
 {
 	Entry *e = BLI_mempool_alloc(gh->entrypool);
 
@@ -502,8 +502,8 @@ BLI_INLINE void ghash_insert_ex_keyonly(
 
 BLI_INLINE void ghash_insert(GHash *gh, void *key, void *val)
 {
-	const unsigned int hash = ghash_keyhash(gh, key);
+	const uint hash = ghash_keyhash(gh, key);
-	const unsigned int bucket_index = ghash_bucket_index(gh, hash);
+	const uint bucket_index = ghash_bucket_index(gh, hash);
 
 	ghash_insert_ex(gh, key, val, bucket_index);
 }
@@ -512,8 +512,8 @@ BLI_INLINE bool ghash_insert_safe(
         GHash *gh, void *key, void *val, const bool override,
         GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
 {
-	const unsigned int hash = ghash_keyhash(gh, key);
+	const uint hash = ghash_keyhash(gh, key);
-	const unsigned int bucket_index = ghash_bucket_index(gh, hash);
+	const uint bucket_index = ghash_bucket_index(gh, hash);
 	GHashEntry *e = (GHashEntry *)ghash_lookup_entry_ex(gh, key, bucket_index);
 
 	BLI_assert(!(gh->flag & GHASH_FLAG_IS_GSET));
@@ -541,8 +541,8 @@ BLI_INLINE bool ghash_insert_safe_keyonly(
         GHash *gh, void *key, const bool override,
         GHashKeyFreeFP keyfreefp)
 {
-	const unsigned int hash = ghash_keyhash(gh, key);
+	const uint hash = ghash_keyhash(gh, key);
-	const unsigned int bucket_index = ghash_bucket_index(gh, hash);
+	const uint bucket_index = ghash_bucket_index(gh, hash);
 	Entry *e = ghash_lookup_entry_ex(gh, key, bucket_index);
 
 	BLI_assert((gh->flag & GHASH_FLAG_IS_GSET) != 0);
@@ -568,7 +568,7 @@ BLI_INLINE bool ghash_insert_safe_keyonly(
 static Entry *ghash_remove_ex(
         GHash *gh, const void *key,
         GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp,
-        const unsigned int bucket_index)
+        const uint bucket_index)
 {
 	Entry *e_prev;
 	Entry *e = ghash_lookup_entry_prev_ex(gh, key, &e_prev, bucket_index);
@@ -601,7 +601,7 @@ static Entry *ghash_remove_ex(
  */
 static Entry *ghash_pop(GHash *gh, GHashIterState *state)
 {
-	unsigned int curr_bucket = state->curr_bucket;
+	uint curr_bucket = state->curr_bucket;
 	if (gh->nentries == 0) {
 		return NULL;
 	}
@@ -626,7 +626,7 @@ static void ghash_free_cb(
         GHash *gh,
         GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
 {
-	unsigned int i;
+	uint i;
 
 	BLI_assert(keyfreefp  || valfreefp);
 	BLI_assert(!valfreefp || !(gh->flag & GHASH_FLAG_IS_GSET));
@@ -651,9 +651,9 @@ static void ghash_free_cb(
 static GHash *ghash_copy(GHash *gh, GHashKeyCopyFP keycopyfp, GHashValCopyFP valcopyfp)
 {
 	GHash *gh_new;
-	unsigned int i;
+	uint i;
 	/* This allows us to be sure to get the same number of buckets in gh_new as in ghash. */
-	const unsigned int reserve_nentries_new = MAX2(GHASH_LIMIT_GROW(gh->nbuckets) - 1, gh->nentries);
+	const uint reserve_nentries_new = MAX2(GHASH_LIMIT_GROW(gh->nbuckets) - 1, gh->nentries);
 
 	BLI_assert(!valcopyfp || !(gh->flag & GHASH_FLAG_IS_GSET));
 
@@ -700,7 +700,7 @@ static GHash *ghash_copy(GHash *gh, GHashKeyCopyFP keycopyfp, GHashValCopyFP val
  * \return  An empty GHash.
  */
 GHash *BLI_ghash_new_ex(GHashHashFP hashfp, GHashCmpFP cmpfp, const char *info,
-                        const unsigned int nentries_reserve)
+                        const uint nentries_reserve)
 {
 	return ghash_new(hashfp, cmpfp, info, nentries_reserve, 0);
 }
@@ -724,7 +724,7 @@ GHash *BLI_ghash_copy(GHash *gh, GHashKeyCopyFP keycopyfp, GHashValCopyFP valcop
 /**
  * Reserve given amount of entries (resize \a gh accordingly if needed).
  */
-void BLI_ghash_reserve(GHash *gh, const unsigned int nentries_reserve)
+void BLI_ghash_reserve(GHash *gh, const uint nentries_reserve)
 {
 	ghash_buckets_expand(gh, nentries_reserve, true);
 	ghash_buckets_contract(gh, nentries_reserve, true, false);
@@ -733,7 +733,7 @@ void BLI_ghash_reserve(GHash *gh, const unsigned int nentries_reserve)
 /**
  * \return size of the GHash.
  */
-unsigned int BLI_ghash_size(GHash *gh)
+uint BLI_ghash_size(GHash *gh)
 {
 	return gh->nentries;
 }
@@ -771,8 +771,8 @@ bool BLI_ghash_reinsert(GHash *gh, void *key, void *val, GHashKeyFreeFP keyfreef
  */
 void *BLI_ghash_replace_key(GHash *gh, void *key)
 {
-	const unsigned int hash = ghash_keyhash(gh, key);
+	const uint hash = ghash_keyhash(gh, key);
-	const unsigned int bucket_index = ghash_bucket_index(gh, hash);
+	const uint bucket_index = ghash_bucket_index(gh, hash);
 	GHashEntry *e = (GHashEntry *)ghash_lookup_entry_ex(gh, key, bucket_index);
 	if (e != NULL) {
 		void *key_prev = e->e.key;
@@ -843,8 +843,8 @@ void **BLI_ghash_lookup_p(GHash *gh, const void *key)
  */
 bool BLI_ghash_ensure_p(GHash *gh, void *key, void ***r_val)
 {
-	const unsigned int hash = ghash_keyhash(gh, key);
+	const uint hash = ghash_keyhash(gh, key);
-	const unsigned int bucket_index = ghash_bucket_index(gh, hash);
+	const uint bucket_index = ghash_bucket_index(gh, hash);
 	GHashEntry *e = (GHashEntry *)ghash_lookup_entry_ex(gh, key, bucket_index);
 	const bool haskey = (e != NULL);
 
@@ -866,8 +866,8 @@ bool BLI_ghash_ensure_p(GHash *gh, void *key, void ***r_val)
 bool BLI_ghash_ensure_p_ex(
         GHash *gh, const void *key, void ***r_key, void ***r_val)
 {
-	const unsigned int hash = ghash_keyhash(gh, key);
+	const uint hash = ghash_keyhash(gh, key);
-	const unsigned int bucket_index = ghash_bucket_index(gh, hash);
+	const uint bucket_index = ghash_bucket_index(gh, hash);
 	GHashEntry *e = (GHashEntry *)ghash_lookup_entry_ex(gh, key, bucket_index);
 	const bool haskey = (e != NULL);
 
@@ -893,8 +893,8 @@ bool BLI_ghash_ensure_p_ex(
  */
 bool BLI_ghash_remove(GHash *gh, const void *key, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
 {
-	const unsigned int hash = ghash_keyhash(gh, key);
+	const uint hash = ghash_keyhash(gh, key);
-	const unsigned int bucket_index = ghash_bucket_index(gh, hash);
+	const uint bucket_index = ghash_bucket_index(gh, hash);
 	Entry *e = ghash_remove_ex(gh, key, keyfreefp, valfreefp, bucket_index);
 	if (e) {
 		BLI_mempool_free(gh->entrypool, e);
@@ -916,8 +916,8 @@ bool BLI_ghash_remove(GHash *gh, const void *key, GHashKeyFreeFP keyfreefp, GHas
  */
 void *BLI_ghash_popkey(GHash *gh, const void *key, GHashKeyFreeFP keyfreefp)
 {
-	const unsigned int hash = ghash_keyhash(gh, key);
+	const uint hash = ghash_keyhash(gh, key);
-	const unsigned int bucket_index = ghash_bucket_index(gh, hash);
+	const uint bucket_index = ghash_bucket_index(gh, hash);
 	GHashEntry *e = (GHashEntry *)ghash_remove_ex(gh, key, keyfreefp, NULL, bucket_index);
 	BLI_assert(!(gh->flag & GHASH_FLAG_IS_GSET));
 	if (e) {
@@ -975,7 +975,7 @@ bool BLI_ghash_pop(
  * \param nentries_reserve  Optionally reserve the number of members that the hash will hold.
  */
 void BLI_ghash_clear_ex(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp,
-                        const unsigned int nentries_reserve)
+                        const uint nentries_reserve)
 {
 	if (keyfreefp || valfreefp)
 		ghash_free_cb(gh, keyfreefp, valfreefp);
@@ -1013,7 +1013,7 @@ void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreef
 /**
  * Sets a GHash flag.
  */
-void BLI_ghash_flag_set(GHash *gh, unsigned int flag)
+void BLI_ghash_flag_set(GHash *gh, uint flag)
 {
 	gh->flag |= flag;
 }
@@ -1021,7 +1021,7 @@ void BLI_ghash_flag_set(GHash *gh, unsigned int flag)
 /**
  * Clear a GHash flag.
  */
-void BLI_ghash_flag_clear(GHash *gh, unsigned int flag)
+void BLI_ghash_flag_clear(GHash *gh, uint flag)
 {
 	gh->flag &= ~flag;
 }
@@ -1162,19 +1162,19 @@ bool BLI_ghashIterator_done(GHashIterator *ghi)
 
 #if 0
 /* works but slower */
-unsigned int BLI_ghashutil_ptrhash(const void *key)
+uint BLI_ghashutil_ptrhash(const void *key)
 {
-	return (unsigned int)(intptr_t)key;
+	return (uint)(intptr_t)key;
 }
 #else
 /* based python3.3's pointer hashing function */
-unsigned int BLI_ghashutil_ptrhash(const void *key)
+uint BLI_ghashutil_ptrhash(const void *key)
 {
 	size_t y = (size_t)key;
 	/* bottom 3 or 4 bits are likely to be 0; rotate y by 4 to avoid
 	 * excessive hash collisions for dicts and sets */
 	y = (y >> 4) | (y << (8 * sizeof(void *) - 4));
-	return (unsigned int)y;
+	return (uint)y;
 }
 #endif
 bool BLI_ghashutil_ptrcmp(const void *a, const void *b)
@@ -1182,9 +1182,9 @@ bool BLI_ghashutil_ptrcmp(const void *a, const void *b)
 	return (a != b);
 }
 
-unsigned int BLI_ghashutil_uinthash_v4(const unsigned int key[4])
+uint BLI_ghashutil_uinthash_v4(const uint key[4])
 {
-	unsigned int hash;
+	uint hash;
 	hash  = key[0];
 	hash *= 37;
 	hash += key[1];
@@ -1194,17 +1194,17 @@ unsigned int BLI_ghashutil_uinthash_v4(const unsigned int key[4])
 	hash += key[3];
 	return hash;
 }
-unsigned int BLI_ghashutil_uinthash_v4_murmur(const unsigned int key[4])
+uint BLI_ghashutil_uinthash_v4_murmur(const uint key[4])
 {
 	return BLI_hash_mm2((const unsigned char *)key, sizeof(int) * 4  /* sizeof(key) */, 0);
 }
 
 bool BLI_ghashutil_uinthash_v4_cmp(const void *a, const void *b)
 {
-	return (memcmp(a, b, sizeof(unsigned int[4])) != 0);
+	return (memcmp(a, b, sizeof(uint[4])) != 0);
 }
 
-unsigned int BLI_ghashutil_uinthash(unsigned int key)
+uint BLI_ghashutil_uinthash(uint key)
 {
 	key += ~(key << 16);
 	key ^=  (key >>  5);
@@ -1216,7 +1216,7 @@ unsigned int BLI_ghashutil_uinthash(unsigned int key)
 	return key;
 }
 
-unsigned int BLI_ghashutil_inthash_p(const void *ptr)
+uint BLI_ghashutil_inthash_p(const void *ptr)
 {
 	uintptr_t key = (uintptr_t)ptr;
 
@@ -1227,17 +1227,17 @@ unsigned int BLI_ghashutil_inthash_p(const void *ptr)
 	key += ~(key <<  9);
 	key ^=  (key >> 17);
 
-	return (unsigned int)(key & 0xffffffff);
+	return (uint)(key & 0xffffffff);
 }
 
-unsigned int BLI_ghashutil_inthash_p_murmur(const void *ptr)
+uint BLI_ghashutil_inthash_p_murmur(const void *ptr)
 {
 	uintptr_t key = (uintptr_t)ptr;
 
 	return BLI_hash_mm2((const unsigned char *)&key, sizeof(key), 0);
 }
 
-unsigned int BLI_ghashutil_inthash_p_simple(const void *ptr)
+uint BLI_ghashutil_inthash_p_simple(const void *ptr)
 {
 	return GET_UINT_FROM_POINTER(ptr);
 }
@@ -1261,29 +1261,29 @@ size_t BLI_ghashutil_combine_hash(size_t hash_a, size_t hash_b)
  *
  * note: this is the same hash method that glib 2.34.0 uses.
  */
-unsigned int BLI_ghashutil_strhash_n(const char *key, size_t n)
+uint BLI_ghashutil_strhash_n(const char *key, size_t n)
 {
 	const signed char *p;
-	unsigned int h = 5381;
+	uint h = 5381;
 
 	for (p = (const signed char *)key; n-- && *p != '\0'; p++) {
-		h = (h << 5) + h + (unsigned int)*p;
+		h = (uint)((h << 5) + h) + (uint)*p;
 	}
 
 	return h;
 }
-unsigned int BLI_ghashutil_strhash_p(const void *ptr)
+uint BLI_ghashutil_strhash_p(const void *ptr)
 {
 	const signed char *p;
-	unsigned int h = 5381;
+	uint h = 5381;
 
 	for (p = ptr; *p != '\0'; p++) {
-		h = (h << 5) + h + (unsigned int)*p;
+		h = (uint)((h << 5) + h) + (uint)*p;
 	}
 
 	return h;
 }
-unsigned int BLI_ghashutil_strhash_p_murmur(const void *ptr)
+uint BLI_ghashutil_strhash_p_murmur(const void *ptr)
 {
 	const unsigned char *key = ptr;
 
@@ -1302,10 +1302,10 @@ GHashPair *BLI_ghashutil_pairalloc(const void *first, const void *second)
 	return pair;
 }
 
-unsigned int BLI_ghashutil_pairhash(const void *ptr)
+uint BLI_ghashutil_pairhash(const void *ptr)
 {
 	const GHashPair *pair = ptr;
-	unsigned int hash = BLI_ghashutil_ptrhash(pair->first);
+	uint hash = BLI_ghashutil_ptrhash(pair->first);
 	return hash ^ BLI_ghashutil_ptrhash(pair->second);
 }
 
@@ -1329,7 +1329,7 @@ void BLI_ghashutil_pairfree(void *ptr)
 /** \name Convenience GHash Creation Functions
  * \{ */
 
-GHash *BLI_ghash_ptr_new_ex(const char *info, const unsigned int nentries_reserve)
+GHash *BLI_ghash_ptr_new_ex(const char *info, const uint nentries_reserve)
 {
 	return BLI_ghash_new_ex(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, info, nentries_reserve);
 }
@@ -1338,7 +1338,7 @@ GHash *BLI_ghash_ptr_new(const char *info)
 	return BLI_ghash_ptr_new_ex(info, 0);
 }
 
-GHash *BLI_ghash_str_new_ex(const char *info, const unsigned int nentries_reserve)
+GHash *BLI_ghash_str_new_ex(const char *info, const uint nentries_reserve)
 {
 	return BLI_ghash_new_ex(BLI_ghashutil_strhash_p, BLI_ghashutil_strcmp, info, nentries_reserve);
 }
@@ -1347,7 +1347,7 @@ GHash *BLI_ghash_str_new(const char *info)
 	return BLI_ghash_str_new_ex(info, 0);
 }
 
-GHash *BLI_ghash_int_new_ex(const char *info, const unsigned int nentries_reserve)
+GHash *BLI_ghash_int_new_ex(const char *info, const uint nentries_reserve)
 {
 	return BLI_ghash_new_ex(BLI_ghashutil_inthash_p, BLI_ghashutil_intcmp, info, nentries_reserve);
 }
@@ -1356,7 +1356,7 @@ GHash *BLI_ghash_int_new(const char *info)
 	return BLI_ghash_int_new_ex(info, 0);
 }
 
-GHash *BLI_ghash_pair_new_ex(const char *info, const unsigned int nentries_reserve)
+GHash *BLI_ghash_pair_new_ex(const char *info, const uint nentries_reserve)
 {
 	return BLI_ghash_new_ex(BLI_ghashutil_pairhash, BLI_ghashutil_paircmp, info, nentries_reserve);
 }
@@ -1376,7 +1376,7 @@ GHash *BLI_ghash_pair_new(const char *info)
 /** \name GSet Functions
  * \{ */
 GSet *BLI_gset_new_ex(GSetHashFP hashfp, GSetCmpFP cmpfp, const char *info,
-                      const unsigned int nentries_reserve)
+                      const uint nentries_reserve)
 {
 	return (GSet *)ghash_new(hashfp, cmpfp, info, nentries_reserve, GHASH_FLAG_IS_GSET);
 }
@@ -1394,7 +1394,7 @@ GSet *BLI_gset_copy(GSet *gs, GHashKeyCopyFP keycopyfp)
 	return (GSet *)ghash_copy((GHash *)gs, keycopyfp, NULL);
 }
 
-unsigned int BLI_gset_size(GSet *gs)
+uint BLI_gset_size(GSet *gs)
 {
 	return ((GHash *)gs)->nentries;
 }
@@ -1405,8 +1405,8 @@ unsigned int BLI_gset_size(GSet *gs)
  */
 void BLI_gset_insert(GSet *gs, void *key)
 {
-	const unsigned int hash = ghash_keyhash((GHash *)gs, key);
+	const uint hash = ghash_keyhash((GHash *)gs, key);
-	const unsigned int bucket_index = ghash_bucket_index((GHash *)gs, hash);
+	const uint bucket_index = ghash_bucket_index((GHash *)gs, hash);
 	ghash_insert_ex_keyonly((GHash *)gs, key, bucket_index);
 }
 
@@ -1429,8 +1429,8 @@ bool BLI_gset_add(GSet *gs, void *key)
  */
 bool BLI_gset_ensure_p_ex(GSet *gs, const void *key, void ***r_key)
 {
-	const unsigned int hash = ghash_keyhash((GHash *)gs, key);
+	const uint hash = ghash_keyhash((GHash *)gs, key);
-	const unsigned int bucket_index = ghash_bucket_index((GHash *)gs, hash);
+	const uint bucket_index = ghash_bucket_index((GHash *)gs, hash);
 	GSetEntry *e = (GSetEntry *)ghash_lookup_entry_ex((GHash *)gs, key, bucket_index);
 	const bool haskey = (e != NULL);
 
@@ -1505,7 +1505,7 @@ bool BLI_gset_pop(
 }
 
 void BLI_gset_clear_ex(GSet *gs, GSetKeyFreeFP keyfreefp,
-                       const unsigned int nentries_reserve)
+                       const uint nentries_reserve)
 {
 	BLI_ghash_clear_ex((GHash *)gs, keyfreefp, NULL,
 	                   nentries_reserve);
@@ -1521,23 +1521,58 @@ void BLI_gset_free(GSet *gs, GSetKeyFreeFP keyfreefp)
 	BLI_ghash_free((GHash *)gs, keyfreefp, NULL);
 }
 
-void BLI_gset_flag_set(GSet *gs, unsigned int flag)
+void BLI_gset_flag_set(GSet *gs, uint flag)
 {
 	((GHash *)gs)->flag |= flag;
 }
 
-void BLI_gset_flag_clear(GSet *gs, unsigned int flag)
+void BLI_gset_flag_clear(GSet *gs, uint flag)
 {
 	((GHash *)gs)->flag &= ~flag;
 }
 
 /** \} */
 
+/** \name GSet Combined Key/Value Usage
+ *
+ * \note Not typical ``set`` use, only use when the pointer identity matters.
+ * This can be useful when the key references data stored outside the GSet.
+ * \{ */
+
+/**
+ * Returns the pointer to the key if it's found.
+ */
+void *BLI_gset_lookup(GSet *gs, const void *key)
+{
+	Entry *e = ghash_lookup_entry((GHash *)gs, key);
+	return e ? e->key : NULL;
+}
+
+/**
+ * Returns the pointer to the key if it's found, removing it from the GSet.
+ * \node Caller must handle freeing.
+ */
+void *BLI_gset_pop_key(GSet *gs, const void *key)
+{
+	const uint hash = ghash_keyhash((GHash *)gs, key);
+	const uint bucket_index = ghash_bucket_index((GHash *)gs, hash);
+	Entry *e = ghash_remove_ex((GHash *)gs, key, NULL, NULL, bucket_index);
+	if (e) {
+		void *key_ret = e->key;
+		BLI_mempool_free(((GHash *)gs)->entrypool, e);
+		return key_ret;
+	}
+	else {
+		return NULL;
+	}
+}
+
+/** \} */
 
 /** \name Convenience GSet Creation Functions
  * \{ */
 
-GSet *BLI_gset_ptr_new_ex(const char *info, const unsigned int nentries_reserve)
+GSet *BLI_gset_ptr_new_ex(const char *info, const uint nentries_reserve)
 {
 	return BLI_gset_new_ex(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, info, nentries_reserve);
 }
@@ -1546,7 +1581,7 @@ GSet *BLI_gset_ptr_new(const char *info)
 	return BLI_gset_ptr_new_ex(info, 0);
 }
 
-GSet *BLI_gset_str_new_ex(const char *info, const unsigned int nentries_reserve)
+GSet *BLI_gset_str_new_ex(const char *info, const uint nentries_reserve)
 {
 	return BLI_gset_new_ex(BLI_ghashutil_strhash_p, BLI_ghashutil_strcmp, info, nentries_reserve);
 }
@@ -1555,7 +1590,7 @@ GSet *BLI_gset_str_new(const char *info)
 	return BLI_gset_str_new_ex(info, 0);
 }
 
-GSet *BLI_gset_pair_new_ex(const char *info, const unsigned int nentries_reserve)
+GSet *BLI_gset_pair_new_ex(const char *info, const uint nentries_reserve)
 {
 	return BLI_gset_new_ex(BLI_ghashutil_pairhash, BLI_ghashutil_paircmp, info, nentries_reserve);
 }
@@ -1595,7 +1630,7 @@ double BLI_ghash_calc_quality_ex(
         double *r_prop_empty_buckets, double *r_prop_overloaded_buckets, int *r_biggest_bucket)
 {
 	double mean;
-	unsigned int i;
+	uint i;
 
 	if (gh->nentries == 0) {
 		if (r_load) {