Cleanup: remove redundant doxygen \file argument
[blender.git] / source / blender / blenlib / intern / smallhash.c
index 0b976e9612e51b91ab6c1bcb4b5f565e9207676e..9c4f60322e68b779041934514a24e41bf4ac5fa4 100644 (file)
@@ -1,6 +1,4 @@
 /*
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  *
  * The Original Code is Copyright (C) 2008 Blender Foundation.
  * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): Joseph Eagar.
- *
- * ***** END GPL LICENSE BLOCK *****
  */
 
-/** \file blender/blenlib/intern/smallhash.c
- *  \ingroup bli
+/** \file \ingroup bli
  *
  * A light stack-friendly hash library, it uses stack space for relatively small, fixed size hash tables
  * but falls back to heap memory once the stack limits reached (#SMSTACKSIZE).
@@ -34,7 +25,7 @@
  * based on a doubling hashing approach (non-chaining) which uses more buckets then entries
  * stepping over buckets when two keys share the same hash so any key can find a free bucket.
  *
- * See: http://en.wikipedia.org/wiki/Double_hashing
+ * See: https://en.wikipedia.org/wiki/Double_hashing
  *
  * \warning This should _only_ be used for small hashes where allocating a hash every time is unacceptable.
  * Otherwise #GHash should be used instead.
@@ -69,8 +60,8 @@
 
 /* typically this re-assigns 'h' */
 #define SMHASH_NEXT(h, hoff)  ( \
-       CHECK_TYPE_INLINE(&(h),    unsigned int *), \
-       CHECK_TYPE_INLINE(&(hoff), unsigned int *), \
+       CHECK_TYPE_INLINE(&(h),    uint *), \
+       CHECK_TYPE_INLINE(&(hoff), uint *), \
        ((h) + (((hoff) = ((hoff) * 2) + 1), (hoff))) \
        )
 
@@ -87,17 +78,17 @@ BLI_INLINE bool smallhash_val_is_used(const void *val)
 #endif
 }
 
-extern const unsigned int hashsizes[];
+extern const uint hashsizes[];
 
-BLI_INLINE unsigned int smallhash_key(const uintptr_t key)
+BLI_INLINE uint smallhash_key(const uintptr_t key)
 {
-       return (unsigned int)key;
+       return (uint)key;
 }
 
 /**
  * Check if the number of items in the smallhash is large enough to require more buckets.
  */
-BLI_INLINE bool smallhash_test_expand_buckets(const unsigned int nentries, const unsigned int nbuckets)
+BLI_INLINE bool smallhash_test_expand_buckets(const uint nentries, const uint nbuckets)
 {
        /* (approx * 1.5) */
        return (nentries + (nentries >> 1)) > nbuckets;
@@ -105,7 +96,7 @@ BLI_INLINE bool smallhash_test_expand_buckets(const unsigned int nentries, const
 
 BLI_INLINE void smallhash_init_empty(SmallHash *sh)
 {
-       unsigned int i;
+       uint i;
 
        for (i = 0; i < sh->nbuckets; i++) {
                sh->buckets[i].key = SMHASH_KEY_UNUSED;
@@ -116,7 +107,7 @@ BLI_INLINE void smallhash_init_empty(SmallHash *sh)
 /**
  * Increase initial bucket size to match a reserved amount.
  */
-BLI_INLINE void smallhash_buckets_reserve(SmallHash *sh, const unsigned int nentries_reserve)
+BLI_INLINE void smallhash_buckets_reserve(SmallHash *sh, const uint nentries_reserve)
 {
        while (smallhash_test_expand_buckets(nentries_reserve, sh->nbuckets)) {
                sh->nbuckets = hashsizes[++sh->cursize];
@@ -126,8 +117,8 @@ BLI_INLINE void smallhash_buckets_reserve(SmallHash *sh, const unsigned int nent
 BLI_INLINE SmallHashEntry *smallhash_lookup(const SmallHash *sh, const uintptr_t key)
 {
        SmallHashEntry *e;
-       unsigned int h = smallhash_key(key);
-       unsigned int hoff = 1;
+       uint h = smallhash_key(key);
+       uint hoff = 1;
 
        BLI_assert(key != SMHASH_KEY_UNUSED);
 
@@ -150,8 +141,8 @@ BLI_INLINE SmallHashEntry *smallhash_lookup(const SmallHash *sh, const uintptr_t
 BLI_INLINE SmallHashEntry *smallhash_lookup_first_free(SmallHash *sh, const uintptr_t key)
 {
        SmallHashEntry *e;
-       unsigned int h = smallhash_key(key);
-       unsigned int hoff = 1;
+       uint h = smallhash_key(key);
+       uint hoff = 1;
 
        for (e = &sh->buckets[h % sh->nbuckets];
             smallhash_val_is_used(e->val);
@@ -163,12 +154,12 @@ BLI_INLINE SmallHashEntry *smallhash_lookup_first_free(SmallHash *sh, const uint
        return e;
 }
 
-BLI_INLINE void smallhash_resize_buckets(SmallHash *sh, const unsigned int nbuckets)
+BLI_INLINE void smallhash_resize_buckets(SmallHash *sh, const uint nbuckets)
 {
        SmallHashEntry *buckets_old = sh->buckets;
-       const unsigned int nbuckets_old = sh->nbuckets;
+       const uint nbuckets_old = sh->nbuckets;
        const bool was_alloc = (buckets_old != sh->buckets_stack);
-       unsigned int i = 0;
+       uint i = 0;
 
        BLI_assert(sh->nbuckets != nbuckets);
        if (nbuckets <= SMSTACKSIZE) {
@@ -200,7 +191,7 @@ BLI_INLINE void smallhash_resize_buckets(SmallHash *sh, const unsigned int nbuck
 }
 
 void BLI_smallhash_init_ex(SmallHash *sh,
-                           const unsigned int nentries_reserve)
+                           const uint nentries_reserve)
 {
        /* assume 'sh' is uninitialized */
 
@@ -310,7 +301,7 @@ bool BLI_smallhash_haskey(const SmallHash *sh, uintptr_t key)
        return (e != NULL);
 }
 
-int BLI_smallhash_count(const SmallHash *sh)
+int BLI_smallhash_len(const SmallHash *sh)
 {
        return (int)sh->nentries;
 }
@@ -371,7 +362,7 @@ void **BLI_smallhash_iternew_p(const SmallHash *sh, SmallHashIter *iter, uintptr
 #if 0
 void BLI_smallhash_print(SmallHash *sh)
 {
-       unsigned int i, linecol = 79, c = 0;
+       uint i, linecol = 79, c = 0;
 
        printf("{");
        for (i = 0; i < sh->nbuckets; i++) {
@@ -382,7 +373,7 @@ void BLI_smallhash_print(SmallHash *sh)
                        printf("--f-");
                }
                else {
-                       printf("%2x", (unsigned int)sh->buckets[i].key);
+                       printf("%2x", (uint)sh->buckets[i].key);
                }
 
                if (i != sh->nbuckets - 1)
@@ -410,7 +401,7 @@ void BLI_smallhash_print(SmallHash *sh)
 double BLI_smallhash_calc_quality(SmallHash *sh)
 {
        uint64_t sum = 0;
-       unsigned int i;
+       uint i;
 
        if (sh->nentries == 0)
                return -1.0;
@@ -419,8 +410,8 @@ double BLI_smallhash_calc_quality(SmallHash *sh)
                if (sh->buckets[i].key != SMHASH_KEY_UNUSED) {
                        uint64_t count = 0;
                        SmallHashEntry *e, *e_final = &sh->buckets[i];
-                       unsigned int h = smallhash_key(e_final->key);
-                       unsigned int hoff = 1;
+                       uint h = smallhash_key(e_final->key);
+                       uint hoff = 1;
 
                        for (e = &sh->buckets[h % sh->nbuckets];
                             e != e_final;