replace hashes with sets where possible.

6 files changed, 107 insertions, 107 deletions

diff --git a/source/blender/bmesh/intern/bmesh_walkers.c b/source/blender/bmesh/intern/bmesh_walkers.c
index c9e36541db7..af901b3359c 100644
--- a/source/blender/bmesh/intern/bmesh_walkers.c
+++ b/source/blender/bmesh/intern/bmesh_walkers.c
@@ -87,8 +87,8 @@ void BMW_init(BMWalker *walker, BMesh *bm, int type,
 	walker->mask_edge = mask_edge;
 	walker->mask_face = mask_face;
 
-	walker->visithash = BLI_ghash_ptr_new("bmesh walkers");
-	walker->secvisithash = BLI_ghash_ptr_new("bmesh walkers sec");
+	walker->visit_set = BLI_gset_ptr_new("bmesh walkers");
+	walker->visit_set_alt = BLI_gset_ptr_new("bmesh walkers sec");
 
 	if (UNLIKELY(type >= BMW_MAXWALKERS || type < 0)) {
 		fprintf(stderr,
@@ -127,8 +127,8 @@ void BMW_init(BMWalker *walker, BMesh *bm, int type,
 void BMW_end(BMWalker *walker)
 {
 	BLI_mempool_destroy(walker->worklist);
-	BLI_ghash_free(walker->visithash, NULL, NULL);
-	BLI_ghash_free(walker->secvisithash, NULL, NULL);
+	BLI_gset_free(walker->visit_set, NULL);
+	BLI_gset_free(walker->visit_set_alt, NULL);
 }
 
 
@@ -253,6 +253,6 @@ void BMW_reset(BMWalker *walker)
 		BMW_state_remove(walker);
 	}
 	walker->depth = 0;
-	BLI_ghash_clear(walker->visithash, NULL, NULL);
-	BLI_ghash_clear(walker->secvisithash, NULL, NULL);
+	BLI_gset_clear(walker->visit_set, NULL);
+	BLI_gset_clear(walker->visit_set_alt, NULL);
 }
diff --git a/source/blender/bmesh/intern/bmesh_walkers.h b/source/blender/bmesh/intern/bmesh_walkers.h
index 8be362b5afa..ea1dbc61cc6 100644
--- a/source/blender/bmesh/intern/bmesh_walkers.h
+++ b/source/blender/bmesh/intern/bmesh_walkers.h
@@ -67,8 +67,8 @@ typedef struct BMWalker {
 
 	BMWFlag flag;
 
-	GHash *visithash;
-	GHash *secvisithash;
+	GSet *visit_set;
+	GSet *visit_set_alt;
 	int depth;
 } BMWalker;
 
diff --git a/source/blender/bmesh/intern/bmesh_walkers_impl.c b/source/blender/bmesh/intern/bmesh_walkers_impl.c
index 2fbda777dcc..a68d9ccd2bc 100644
--- a/source/blender/bmesh/intern/bmesh_walkers_impl.c
+++ b/source/blender/bmesh/intern/bmesh_walkers_impl.c
@@ -85,7 +85,7 @@ static void bmw_ShellWalker_visitEdge(BMWalker *walker, BMEdge *e)
 {
 	BMwShellWalker *shellWalk = NULL;
 
-	if (BLI_ghash_haskey(walker->visithash, e)) {
+	if (BLI_gset_haskey(walker->visit_set, e)) {
 		return;
 	}
 
@@ -95,7 +95,7 @@ static void bmw_ShellWalker_visitEdge(BMWalker *walker, BMEdge *e)
 
 	shellWalk = BMW_state_add(walker);
 	shellWalk->curedge = e;
-	BLI_ghash_insert(walker->visithash, e, NULL);
+	BLI_gset_insert(walker->visit_set, e);
 }
 
 static void bmw_ShellWalker_begin(BMWalker *walker, void *data)
@@ -167,8 +167,8 @@ static void *bmw_ShellWalker_step(BMWalker *walker)
 	bool restrictpass = true;
 	BMwShellWalker shellWalk = *((BMwShellWalker *)BMW_current_state(walker));
 	
-	if (!BLI_ghash_haskey(walker->visithash, shellWalk.base)) {
-		BLI_ghash_insert(walker->visithash, shellWalk.base, NULL);
+	if (!BLI_gset_haskey(walker->visit_set, shellWalk.base)) {
+		BLI_gset_insert(walker->visit_set, shellWalk.base);
 	}
 
 	BMW_state_remove(walker);
@@ -177,7 +177,7 @@ static void *bmw_ShellWalker_step(BMWalker *walker)
 	/* find the next edge whose other vertex has not been visite */
 	curedge = shellWalk.curedge;
 	do {
-		if (!BLI_ghash_haskey(walker->visithash, curedge)) {
+		if (!BLI_gset_haskey(walker->visit_set, curedge)) {
 			if (!walker->restrictflag ||
 			    (walker->restrictflag && BMO_elem_flag_test(walker->bm, curedge, walker->restrictflag)))
 			{
@@ -187,7 +187,7 @@ static void *bmw_ShellWalker_step(BMWalker *walker)
 				
 				/* push a new state onto the stac */
 				newState = BMW_state_add(walker);
-				BLI_ghash_insert(walker->visithash, curedge, NULL);
+				BLI_gset_insert(walker->visit_set, curedge);
 				
 				/* populate the new stat */
 
@@ -211,7 +211,7 @@ static void bmw_ConnectedVertexWalker_visitVertex(BMWalker *walker, BMVert *v)
 {
 	BMwConnectedVertexWalker *vwalk;
 
-	if (BLI_ghash_haskey(walker->visithash, v)) {
+	if (BLI_gset_haskey(walker->visit_set, v)) {
 		/* already visited */
 		return;
 	}
@@ -223,7 +223,7 @@ static void bmw_ConnectedVertexWalker_visitVertex(BMWalker *walker, BMVert *v)
 
 	vwalk = BMW_state_add(walker);
 	vwalk->curvert = v;
-	BLI_ghash_insert(walker->visithash, v, NULL);
+	BLI_gset_insert(walker->visit_set, v);
 }
 
 static void bmw_ConnectedVertexWalker_begin(BMWalker *walker, void *data)
@@ -251,7 +251,7 @@ static void *bmw_ConnectedVertexWalker_step(BMWalker *walker)
 
 	BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) {
 		v2 = BM_edge_other_vert(e, v);
-		if (!BLI_ghash_haskey(walker->visithash, v2)) {
+		if (!BLI_gset_haskey(walker->visit_set, v2)) {
 			bmw_ConnectedVertexWalker_visitVertex(walker, v2);
 		}
 	}
@@ -276,7 +276,7 @@ static void bmw_IslandboundWalker_begin(BMWalker *walker, void *data)
 	iwalk->base = iwalk->curloop = l;
 	iwalk->lastv = l->v;
 
-	BLI_ghash_insert(walker->visithash, data, NULL);
+	BLI_gset_insert(walker->visit_set, data);
 
 }
 
@@ -334,11 +334,11 @@ static void *bmw_IslandboundWalker_step(BMWalker *walker)
 	if (l == owalk.curloop) {
 		return NULL;
 	}
-	else if (BLI_ghash_haskey(walker->visithash, l)) {
+	else if (BLI_gset_haskey(walker->visit_set, l)) {
 		return owalk.curloop;
 	}
 
-	BLI_ghash_insert(walker->visithash, l, NULL);
+	BLI_gset_insert(walker->visit_set, l);
 	iwalk = BMW_state_add(walker);
 	iwalk->base = owalk.base;
 
@@ -367,7 +367,7 @@ static void bmw_IslandWalker_begin(BMWalker *walker, void *data)
 	}
 
 	iwalk = BMW_state_add(walker);
-	BLI_ghash_insert(walker->visithash, data, NULL);
+	BLI_gset_insert(walker->visit_set, data);
 
 	iwalk->cur = data;
 }
@@ -403,18 +403,18 @@ static void *bmw_IslandWalker_step(BMWalker *walker)
 				continue;
 			}
 
-			/* saves checking BLI_ghash_haskey below (manifold edges theres a 50% chance) */
+			/* saves checking BLI_gset_haskey below (manifold edges theres a 50% chance) */
 			if (f == iwalk->cur) {
 				continue;
 			}
 
-			if (BLI_ghash_haskey(walker->visithash, f)) {
+			if (BLI_gset_haskey(walker->visit_set, f)) {
 				continue;
 			}
 			
 			iwalk = BMW_state_add(walker);
 			iwalk->cur = f;
-			BLI_ghash_insert(walker->visithash, f, NULL);
+			BLI_gset_insert(walker->visit_set, f);
 			break;
 		}
 	}
@@ -448,7 +448,7 @@ static void bmw_LoopWalker_begin(BMWalker *walker, void *data)
 	v = e->v1;
 
 	lwalk = BMW_state_add(walker);
-	BLI_ghash_insert(walker->visithash, e, NULL);
+	BLI_gset_insert(walker->visit_set, e);
 
 	lwalk->cur = lwalk->start = e;
 	lwalk->lastv = lwalk->startv = v;
@@ -494,8 +494,8 @@ static void bmw_LoopWalker_begin(BMWalker *walker, void *data)
 
 	lwalk->lastv = lwalk->startv = BM_edge_other_vert(owalk.cur, lwalk->lastv);
 
-	BLI_ghash_clear(walker->visithash, NULL, NULL);
-	BLI_ghash_insert(walker->visithash, owalk.cur, NULL);
+	BLI_gset_clear(walker->visit_set, NULL);
+	BLI_gset_insert(walker->visit_set, owalk.cur);
 }
 
 static void *bmw_LoopWalker_yield(BMWalker *walker)
@@ -530,7 +530,7 @@ static void *bmw_LoopWalker_step(BMWalker *walker)
 			nexte = BM_edge_exists(v, l->v);
 
 			if (bmw_mask_check_edge(walker, nexte) &&
-			    !BLI_ghash_haskey(walker->visithash, nexte) &&
+			    !BLI_gset_haskey(walker->visit_set, nexte) &&
 			    /* never step onto a boundary edge, this gives odd-results */
 			    (BM_edge_is_boundary(nexte) == false))
 			{
@@ -542,7 +542,7 @@ static void *bmw_LoopWalker_step(BMWalker *walker)
 				lwalk->is_single = owalk.is_single;
 				lwalk->f_hub = owalk.f_hub;
 
-				BLI_ghash_insert(walker->visithash, nexte, NULL);
+				BLI_gset_insert(walker->visit_set, nexte);
 			}
 		}
 	}
@@ -556,7 +556,7 @@ static void *bmw_LoopWalker_step(BMWalker *walker)
 			BM_ITER_ELEM (nexte, &eiter, v, BM_EDGES_OF_VERT) {
 				if ((nexte->l == NULL) &&
 				    bmw_mask_check_edge(walker, nexte) &&
-				    !BLI_ghash_haskey(walker->visithash, nexte))
+				    !BLI_gset_haskey(walker->visit_set, nexte))
 				{
 					lwalk = BMW_state_add(walker);
 					lwalk->cur = nexte;
@@ -566,7 +566,7 @@ static void *bmw_LoopWalker_step(BMWalker *walker)
 					lwalk->is_single = owalk.is_single;
 					lwalk->f_hub = owalk.f_hub;
 
-					BLI_ghash_insert(walker->visithash, nexte, NULL);
+					BLI_gset_insert(walker->visit_set, nexte);
 				}
 			}
 		}
@@ -601,7 +601,7 @@ static void *bmw_LoopWalker_step(BMWalker *walker)
 		if (l != NULL) {
 			if (l != e->l &&
 			    bmw_mask_check_edge(walker, l->e) &&
-			    !BLI_ghash_haskey(walker->visithash, l->e))
+			    !BLI_gset_haskey(walker->visit_set, l->e))
 			{
 				lwalk = BMW_state_add(walker);
 				lwalk->cur = l->e;
@@ -611,7 +611,7 @@ static void *bmw_LoopWalker_step(BMWalker *walker)
 				lwalk->is_single = owalk.is_single;
 				lwalk->f_hub = owalk.f_hub;
 
-				BLI_ghash_insert(walker->visithash, l->e, NULL);
+				BLI_gset_insert(walker->visit_set, l->e);
 			}
 		}
 	}
@@ -654,7 +654,7 @@ static void *bmw_LoopWalker_step(BMWalker *walker)
 		if (l != NULL) {
 			if (l != e->l &&
 			    bmw_mask_check_edge(walker, l->e) &&
-			    !BLI_ghash_haskey(walker->visithash, l->e))
+			    !BLI_gset_haskey(walker->visit_set, l->e))
 			{
 				lwalk = BMW_state_add(walker);
 				lwalk->cur = l->e;
@@ -664,7 +664,7 @@ static void *bmw_LoopWalker_step(BMWalker *walker)
 				lwalk->is_single = owalk.is_single;
 				lwalk->f_hub = owalk.f_hub;
 
-				BLI_ghash_insert(walker->visithash, l->e, NULL);
+				BLI_gset_insert(walker->visit_set, l->e);
 			}
 		}
 	}
@@ -694,7 +694,7 @@ static bool bmw_FaceLoopWalker_include_face(BMWalker *walker, BMLoop *l)
 	}
 
 	/* the face must not have been already visited */
-	if (BLI_ghash_haskey(walker->visithash, l->f) && BLI_ghash_haskey(walker->secvisithash, l->e)) {
+	if (BLI_gset_haskey(walker->visit_set, l->f) && BLI_gset_haskey(walker->visit_set_alt, l->e)) {
 		return false;
 	}
 
@@ -738,7 +738,7 @@ static void bmw_FaceLoopWalker_begin(BMWalker *walker, void *data)
 	lwalk = BMW_state_add(walker);
 	lwalk->l = e->l;
 	lwalk->no_calc = false;
-	BLI_ghash_insert(walker->visithash, lwalk->l->f, NULL);
+	BLI_gset_insert(walker->visit_set, lwalk->l->f);
 
 	/* rewind */
 	while ((owalk_pt = BMW_current_state(walker))) {
@@ -750,11 +750,11 @@ static void bmw_FaceLoopWalker_begin(BMWalker *walker, void *data)
 	*lwalk = owalk;
 	lwalk->no_calc = false;
 
-	BLI_ghash_clear(walker->secvisithash, NULL, NULL);
-	BLI_ghash_insert(walker->secvisithash, lwalk->l->e, NULL);
+	BLI_gset_clear(walker->visit_set_alt, NULL);
+	BLI_gset_insert(walker->visit_set_alt, lwalk->l->e);
 
-	BLI_ghash_clear(walker->visithash, NULL, NULL);
-	BLI_ghash_insert(walker->visithash, lwalk->l->f, NULL);
+	BLI_gset_clear(walker->visit_set, NULL);
+	BLI_gset_insert(walker->visit_set, lwalk->l->f);
 }
 
 static void *bmw_FaceLoopWalker_yield(BMWalker *walker)
@@ -804,8 +804,8 @@ static void *bmw_FaceLoopWalker_step(BMWalker *walker)
 		}
 
 		/* both may already exist */
-		BLI_ghash_reinsert(walker->secvisithash, l->e, NULL, NULL, NULL);
-		BLI_ghash_reinsert(walker->visithash, l->f, NULL, NULL, NULL);
+		BLI_gset_reinsert(walker->visit_set_alt, l->e, NULL);
+		BLI_gset_reinsert(walker->visit_set, l->f, NULL);
 	}
 
 	return f;
@@ -836,7 +836,7 @@ static void bmw_EdgeringWalker_begin(BMWalker *walker, void *data)
 		lwalk->wireedge = NULL;
 	}
 
-	BLI_ghash_insert(walker->visithash, lwalk->l->e, NULL);
+	BLI_gset_insert(walker->visit_set, lwalk->l->e);
 
 	/* rewind */
 	while ((owalk_pt = BMW_current_state(walker))) {
@@ -856,8 +856,8 @@ static void bmw_EdgeringWalker_begin(BMWalker *walker, void *data)
 		lwalk->l = lwalk->l->radial_next;
 	}
 
-	BLI_ghash_clear(walker->visithash, NULL, NULL);
-	BLI_ghash_insert(walker->visithash, lwalk->l->e, NULL);
+	BLI_gset_clear(walker->visit_set, NULL);
+	BLI_gset_insert(walker->visit_set, lwalk->l->e);
 }
 
 static void *bmw_EdgeringWalker_yield(BMWalker *walker)
@@ -922,7 +922,7 @@ static void *bmw_EdgeringWalker_step(BMWalker *walker)
 	}
 	/* only walk to manifold edge */
 	if ((l->f->len % 2 == 0) && EDGE_CHECK(l->e) &&
-	    !BLI_ghash_haskey(walker->visithash, l->e))
+	    !BLI_gset_haskey(walker->visit_set, l->e))
 
 #else
 
@@ -934,14 +934,14 @@ static void *bmw_EdgeringWalker_step(BMWalker *walker)
 	}
 	/* only walk to manifold edge */
 	if ((l->f->len == 4) && EDGE_CHECK(l->e) &&
-	    !BLI_ghash_haskey(walker->visithash, l->e))
+	    !BLI_gset_haskey(walker->visit_set, l->e))
 #endif
 	{
 		lwalk = BMW_state_add(walker);
 		lwalk->l = l;
 		lwalk->wireedge = NULL;
 
-		BLI_ghash_insert(walker->visithash, l->e, NULL);
+		BLI_gset_insert(walker->visit_set, l->e);
 	}
 
 	return e;
@@ -954,12 +954,12 @@ static void bmw_UVEdgeWalker_begin(BMWalker *walker, void *data)
 	BMwUVEdgeWalker *lwalk;
 	BMLoop *l = data;
 
-	if (BLI_ghash_haskey(walker->visithash, l))
+	if (BLI_gset_haskey(walker->visit_set, l))
 		return;
 
 	lwalk = BMW_state_add(walker);
 	lwalk->l = l;
-	BLI_ghash_insert(walker->visithash, l, NULL);
+	BLI_gset_insert(walker->visit_set, l);
 }
 
 static void *bmw_UVEdgeWalker_yield(BMWalker *walker)
@@ -1001,7 +1001,7 @@ static void *bmw_UVEdgeWalker_step(BMWalker *walker)
 			
 			rlen = BM_edge_face_count(l2->e);
 			for (j = 0; j < rlen; j++) {
-				if (BLI_ghash_haskey(walker->visithash, l2)) {
+				if (BLI_gset_haskey(walker->visit_set, l2)) {
 					continue;
 				}
 
@@ -1019,7 +1019,7 @@ static void *bmw_UVEdgeWalker_step(BMWalker *walker)
 					continue;
 				
 				lwalk = BMW_state_add(walker);
-				BLI_ghash_insert(walker->visithash, l2, NULL);
+				BLI_gset_insert(walker->visit_set, l2);
 
 				lwalk->l = l2;
 
diff --git a/source/blender/bmesh/operators/bmo_beautify.c b/source/blender/bmesh/operators/bmo_beautify.c
index 22b686db64e..3dbdb3ddc52 100644
--- a/source/blender/bmesh/operators/bmo_beautify.c
+++ b/source/blender/bmesh/operators/bmo_beautify.c
@@ -28,7 +28,7 @@
  *
  * In principle this is very simple however there is the possibility of
  * going into an eternal loop where edges keep rotating.
- * To avoid this - each edge stores a hash of it previous
+ * To avoid this - each edge stores a set of it previous
  * states so as not to rotate back.
  *
  * TODO
@@ -54,14 +54,14 @@ enum {
 };
 
 /* -------------------------------------------------------------------- */
-/* GHash for edge rotation */
+/* GSet for edge rotation */
 
 typedef struct EdRotState {
 	int v1, v2; /*	edge vert, small -> large */
 	int f1, f2; /*	face vert, small -> large */
 } EdRotState;
 
-static unsigned int erot_ghashutil_hash(const void *ptr)
+static unsigned int erot_gsetutil_hash(const void *ptr)
 {
 	const EdRotState *e_state = (const EdRotState *)ptr;
 	unsigned int
@@ -71,7 +71,7 @@ static unsigned int erot_ghashutil_hash(const void *ptr)
 	hash ^= BLI_ghashutil_inthash(SET_INT_IN_POINTER(e_state->f2));
 	return hash;
 }
-static int erot_ghashutil_cmp(const void *a, const void *b)
+static int erot_gsetutil_cmp(const void *a, const void *b)
 {
 	const EdRotState *e_state_a = (const EdRotState *)a;
 	const EdRotState *e_state_b = (const EdRotState *)b;
@@ -86,9 +86,9 @@ static int erot_ghashutil_cmp(const void *a, const void *b)
 	else                                    return  0;
 }
 
-static GHash *erot_ghash_new(void)
+static GSet *erot_gset_new(void)
 {
-	return BLI_ghash_new(erot_ghashutil_hash, erot_ghashutil_cmp, __func__);
+	return BLI_gset_new(erot_gsetutil_hash, erot_gsetutil_cmp, __func__);
 }
 
 /* ensure v0 is smaller */
@@ -236,12 +236,12 @@ static float bm_edge_calc_rotate_beauty(const BMEdge *e, const int flag)
 /* Update the edge cost of rotation in the heap */
 
 /* recalc an edge in the heap (surrounding geometry has changed) */
-static void bm_edge_update_beauty_cost_single(BMEdge *e, Heap *eheap, HeapNode **eheap_table, GHash **edge_state_arr,
+static void bm_edge_update_beauty_cost_single(BMEdge *e, Heap *eheap, HeapNode **eheap_table, GSet **edge_state_arr,
                                               const int flag)
 {
 	if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
 		const int i = BM_elem_index_get(e);
-		GHash *e_state_hash = edge_state_arr[i];
+		GSet *e_state_set = edge_state_arr[i];
 
 		if (eheap_table[i]) {
 			BLI_heap_remove(eheap, eheap_table[i]);
@@ -254,10 +254,10 @@ static void bm_edge_update_beauty_cost_single(BMEdge *e, Heap *eheap, HeapNode *
 		//           BMO_elem_flag_test(bm, e->l->radial_next->f, FACE_MARK));
 
 		/* check we're not moving back into a state we have been in before */
-		if (e_state_hash != NULL) {
+		if (e_state_set != NULL) {
 			EdRotState e_state_alt;
 			erot_state_alternate(e, &e_state_alt);
-			if (BLI_ghash_haskey(e_state_hash, (void *)&e_state_alt)) {
+			if (BLI_gset_haskey(e_state_set, (void *)&e_state_alt)) {
 				// printf("  skipping, we already have this state\n");
 				return;
 			}
@@ -277,7 +277,7 @@ static void bm_edge_update_beauty_cost_single(BMEdge *e, Heap *eheap, HeapNode *
 }
 
 /* we have rotated an edge, tag other edges and clear this one */
-static void bm_edge_update_beauty_cost(BMEdge *e, Heap *eheap, HeapNode **eheap_table, GHash **edge_state_arr,
+static void bm_edge_update_beauty_cost(BMEdge *e, Heap *eheap, HeapNode **eheap_table, GSet **edge_state_arr,
                                        const int flag)
 {
 	BMLoop *l;
@@ -308,7 +308,7 @@ static void bm_mesh_beautify_fill(BMesh *bm, BMEdge **edge_array, const int edge
 	Heap *eheap;             /* edge heap */
 	HeapNode **eheap_table;  /* edge index aligned table pointing to the eheap */
 
-	GHash      **edge_state_arr  = MEM_callocN(edge_array_len * sizeof(GHash *), __func__);
+	GSet       **edge_state_arr  = MEM_callocN(edge_array_len * sizeof(GSet *), __func__);
 	BLI_mempool *edge_state_pool = BLI_mempool_create(sizeof(EdRotState), 512, 512, BLI_MEMPOOL_SYSMALLOC);
 	int i;
 
@@ -338,18 +338,18 @@ static void bm_mesh_beautify_fill(BMesh *bm, BMEdge **edge_array, const int edge
 
 		e = BM_edge_rotate(bm, e, false, BM_EDGEROT_CHECK_EXISTS);
 		if (LIKELY(e)) {
-			GHash *e_state_hash = edge_state_arr[i];
+			GSet *e_state_set = edge_state_arr[i];
 
-			/* add the new state into the hash so we don't move into this state again
+			/* add the new state into the set so we don't move into this state again
 			 * note: we could add the previous state too but this isn't essential)
 			 *       for avoiding eternal loops */
 			EdRotState *e_state = BLI_mempool_alloc(edge_state_pool);
 			erot_state_current(e, e_state);
-			if (UNLIKELY(e_state_hash == NULL)) {
-				edge_state_arr[i] = e_state_hash = erot_ghash_new();  /* store previous state */
+			if (UNLIKELY(e_state_set == NULL)) {
+				edge_state_arr[i] = e_state_set = erot_gset_new();  /* store previous state */
 			}
-			BLI_assert(BLI_ghash_haskey(e_state_hash, (void *)e_state) == false);
-			BLI_ghash_insert(e_state_hash, e_state, NULL);
+			BLI_assert(BLI_gset_haskey(e_state_set, (void *)e_state) == false);
+			BLI_gset_insert(e_state_set, e_state);
 
 
 			// printf("  %d -> %d, %d\n", i, BM_elem_index_get(e->v1), BM_elem_index_get(e->v2));
@@ -373,7 +373,7 @@ static void bm_mesh_beautify_fill(BMesh *bm, BMEdge **edge_array, const int edge
 
 	for (i = 0; i < edge_array_len; i++) {
 		if (edge_state_arr[i]) {
-			BLI_ghash_free(edge_state_arr[i], NULL, NULL);
+			BLI_gset_free(edge_state_arr[i], NULL);
 		}
 	}
 
diff --git a/source/blender/bmesh/operators/bmo_hull.c b/source/blender/bmesh/operators/bmo_hull.c
index 9ba08f0a470..f0ec45b624f 100644
--- a/source/blender/bmesh/operators/bmo_hull.c
+++ b/source/blender/bmesh/operators/bmo_hull.c
@@ -67,7 +67,7 @@ typedef struct HullTriangle {
 
 /*************************** Hull Triangles ***************************/
 
-static void hull_add_triangle(BMesh *bm, GHash *hull_triangles, BLI_mempool *pool,
+static void hull_add_triangle(BMesh *bm, GSet *hull_triangles, BLI_mempool *pool,
                               BMVert *v1, BMVert *v2, BMVert *v3)
 {
 	HullTriangle *t;
@@ -82,7 +82,7 @@ static void hull_add_triangle(BMesh *bm, GHash *hull_triangles, BLI_mempool *poo
 	for (i = 0; i < 3; i++)
 		BMO_elem_flag_disable(bm, t->v[i], HULL_FLAG_INTERIOR_ELE);
 
-	BLI_ghash_insert(hull_triangles, t, NULL);
+	BLI_gset_insert(hull_triangles, t);
 	normal_tri_v3(t->no, v1->co, v2->co, v3->co);
 }
 
@@ -102,12 +102,12 @@ static BMFace *hull_find_example_face(BMesh *bm, BMEdge *e)
 	return NULL;
 }
 
-static void hull_output_triangles(BMesh *bm, GHash *hull_triangles)
+static void hull_output_triangles(BMesh *bm, GSet *hull_triangles)
 {
-	GHashIterator iter;
+	GSetIterator iter;
 	
-	GHASH_ITER (iter, hull_triangles) {
-		HullTriangle *t = BLI_ghashIterator_getKey(&iter);
+	GSET_ITER (iter, hull_triangles) {
+		HullTriangle *t = BLI_gsetIterator_getKey(&iter);
 		int i;
 
 		if (!t->skip) {
@@ -206,22 +206,22 @@ static int hull_final_edges_lookup(HullFinalEdges *final_edges,
 }
 
 /* Used for checking whether a pre-existing edge lies on the hull */
-static HullFinalEdges *hull_final_edges(GHash *hull_triangles)
+static HullFinalEdges *hull_final_edges(GSet *hull_triangles)
 {
 	HullFinalEdges *final_edges;
-	GHashIterator iter;
+	GSetIterator iter;
 	
 	final_edges = MEM_callocN(sizeof(HullFinalEdges), "HullFinalEdges");
 	final_edges->edges = BLI_ghash_ptr_new("final edges ghash");
 	final_edges->base_pool = BLI_mempool_create(sizeof(ListBase), 128, 128, 0);
 	final_edges->link_pool = BLI_mempool_create(sizeof(LinkData), 128, 128, 0);
 
-	GHASH_ITER (iter, hull_triangles) {
+	GSET_ITER (iter, hull_triangles) {
 		LinkData *link;
 		int i;
 		
 		for (i = 0; i < 3; i++) {
-			HullTriangle *t = BLI_ghashIterator_getKey(&iter);
+			HullTriangle *t = BLI_gsetIterator_getKey(&iter);
 			BMVert *v1 = t->v[i];
 			BMVert *v2 = t->v[(i + 1) % 3];
 			ListBase *adj;
@@ -259,13 +259,13 @@ static void hull_final_edges_free(HullFinalEdges *final_edges)
 
 /**************************** Final Output ****************************/
 
-static void hull_remove_overlapping(BMesh *bm, GHash *hull_triangles,
+static void hull_remove_overlapping(BMesh *bm, GSet *hull_triangles,
                                     HullFinalEdges *final_edges)
 {
-	GHashIterator hull_iter;
+	GSetIterator hull_iter;
 
-	GHASH_ITER (hull_iter, hull_triangles) {
-		HullTriangle *t = BLI_ghashIterator_getKey(&hull_iter);
+	GSET_ITER (hull_iter, hull_triangles) {
+		HullTriangle *t = BLI_gsetIterator_getKey(&hull_iter);
 		BMIter bm_iter1, bm_iter2;
 		BMFace *f;
 		bool f_on_hull;
@@ -479,7 +479,7 @@ static BMVert **hull_verts_from_bullet(plConvexHull hull,
 }
 
 static void hull_from_bullet(BMesh *bm, BMOperator *op,
-                             GHash *hull_triangles,
+                             GSet *hull_triangles,
                              BLI_mempool *pool)
 {
 	int *fvi = NULL;
@@ -556,7 +556,7 @@ void bmo_convex_hull_exec(BMesh *bm, BMOperator *op)
 	BLI_mempool *hull_pool;
 	BMElemF *ele;
 	BMOIter oiter;
-	GHash *hull_triangles;
+	GSet *hull_triangles;
 
 	/* Verify that at least three verts in the input */
 	if (!hull_num_input_verts_is_ok(op)) {
@@ -575,7 +575,7 @@ void bmo_convex_hull_exec(BMesh *bm, BMOperator *op)
 	}
 
 	hull_pool = BLI_mempool_create(sizeof(HullTriangle), 128, 128, 0);
-	hull_triangles = BLI_ghash_ptr_new("hull_triangles");
+	hull_triangles = BLI_gset_ptr_new("hull_triangles");
 
 	hull_from_bullet(bm, op, hull_triangles, hull_pool);
 
@@ -597,7 +597,7 @@ void bmo_convex_hull_exec(BMesh *bm, BMOperator *op)
 	hull_output_triangles(bm, hull_triangles);
 	BLI_mempool_destroy(hull_pool);
 
-	BLI_ghash_free(hull_triangles, NULL, NULL);
+	BLI_gset_free(hull_triangles, NULL);
 
 	hull_tag_unused(bm, op);
 
diff --git a/source/blender/bmesh/operators/bmo_subdivide_edgering.c b/source/blender/bmesh/operators/bmo_subdivide_edgering.c
index fa39ae68cdf..d9d87d0db78 100644
--- a/source/blender/bmesh/operators/bmo_subdivide_edgering.c
+++ b/source/blender/bmesh/operators/bmo_subdivide_edgering.c
@@ -203,7 +203,7 @@ finally:
 /* -------------------------------------------------------------------- */
 /* Edge Loop Pairs */
 /* key (ordered loop pointers) */
-static GHash *bm_edgering_pair_calc(BMesh *bm, ListBase *eloops_rim)
+static GSet *bm_edgering_pair_calc(BMesh *bm, ListBase *eloops_rim)
 {
 	/**
 	 * Method for for finding pairs:
@@ -219,7 +219,7 @@ static GHash *bm_edgering_pair_calc(BMesh *bm, ListBase *eloops_rim)
 	 * could sort and optimize this but not really so important.
 	 */
 
-	GHash *eloop_pair_gh = BLI_ghash_pair_new(__func__);
+	GSet *eloop_pair_gs = BLI_gset_pair_new(__func__);
 	GHash *vert_eloop_gh = BLI_ghash_ptr_new(__func__);
 
 	struct BMEdgeLoopStore *el_store;
@@ -256,9 +256,9 @@ static GHash *bm_edgering_pair_calc(BMesh *bm, ListBase *eloops_rim)
 					if (pair_test.first > pair_test.second)
 						SWAP(const void *, pair_test.first, pair_test.second);
 
-					if (!BLI_ghash_haskey(eloop_pair_gh, &pair_test)) {
+					if (!BLI_gset_haskey(eloop_pair_gs, &pair_test)) {
 						GHashPair *pair = BLI_ghashutil_pairalloc(pair_test.first, pair_test.second);
-						BLI_ghash_insert(eloop_pair_gh, pair, NULL);
+						BLI_gset_insert(eloop_pair_gs, pair);
 					}
 
 				}
@@ -268,12 +268,12 @@ static GHash *bm_edgering_pair_calc(BMesh *bm, ListBase *eloops_rim)
 
 	BLI_ghash_free(vert_eloop_gh, NULL, NULL);
 
-	if (BLI_ghash_size(eloop_pair_gh) == 0) {
-		BLI_ghash_free(eloop_pair_gh, NULL, NULL);
-		eloop_pair_gh = NULL;
+	if (BLI_gset_size(eloop_pair_gs) == 0) {
+		BLI_gset_free(eloop_pair_gs, NULL);
+		eloop_pair_gs = NULL;
 	}
 
-	return eloop_pair_gh;
+	return eloop_pair_gs;
 }
 
 
@@ -1175,23 +1175,23 @@ void bmo_subdivide_edgering_exec(BMesh *bm, BMOperator *op)
 		}
 	}
 	else {
-		GHashIterator gh_iter;
+		GSetIterator gs_iter;
 		int i;
 
-		GHash *eloop_pairs_gh = bm_edgering_pair_calc(bm, &eloops_rim);
+		GSet *eloop_pairs_gs = bm_edgering_pair_calc(bm, &eloops_rim);
 		LoopPairStore **lpair_arr;
 
-		if (eloop_pairs_gh == NULL) {
+		if (eloop_pairs_gs == NULL) {
 			BMO_error_raise(bm, op, BMERR_INVALID_SELECTION,
 			                "Edge-rings are not connected");
 			goto cleanup;
 		}
 
-		lpair_arr = BLI_array_alloca(lpair_arr, BLI_ghash_size(eloop_pairs_gh));
+		lpair_arr = BLI_array_alloca(lpair_arr, BLI_gset_size(eloop_pairs_gs));
 
 		/* first cache pairs */
-		GHASH_ITER_INDEX (gh_iter, eloop_pairs_gh, i) {
-			GHashPair *eloop_pair = BLI_ghashIterator_getKey(&gh_iter);
+		GSET_ITER_INDEX (gs_iter, eloop_pairs_gs, i) {
+			GHashPair *eloop_pair = BLI_gsetIterator_getKey(&gs_iter);
 			struct BMEdgeLoopStore *el_store_a = (void *)eloop_pair->first;
 			struct BMEdgeLoopStore *el_store_b = (void *)eloop_pair->second;
 			LoopPairStore *lpair;
@@ -1207,8 +1207,8 @@ void bmo_subdivide_edgering_exec(BMesh *bm, BMOperator *op)
 			BLI_assert(bm_verts_tag_count(bm) == 0);
 		}
 
-		GHASH_ITER_INDEX (gh_iter, eloop_pairs_gh, i) {
-			GHashPair *eloop_pair = BLI_ghashIterator_getKey(&gh_iter);
+		GSET_ITER_INDEX (gs_iter, eloop_pairs_gs, i) {
+			GHashPair *eloop_pair = BLI_gsetIterator_getKey(&gs_iter);
 			struct BMEdgeLoopStore *el_store_a = (void *)eloop_pair->first;
 			struct BMEdgeLoopStore *el_store_b = (void *)eloop_pair->second;
 			LoopPairStore *lpair = lpair_arr[i];
@@ -1222,7 +1222,7 @@ void bmo_subdivide_edgering_exec(BMesh *bm, BMOperator *op)
 
 			BLI_assert(bm_verts_tag_count(bm) == 0);
 		}
-		BLI_ghash_free(eloop_pairs_gh, MEM_freeN, NULL);
+		BLI_gset_free(eloop_pairs_gs, MEM_freeN);
 	}
 
 cleanup: