change unordered_set API, no hash, equal fields

use static methods, prefixed by the type T.
This enables inlining the hot hashtable parts, and
disallows corrupting the table with changed hash or equal methods.
They really need to be declared and defined statically, just as with C++, where
we need to declare it for the template.

Fixes GH #21

Author: rurban

README.md

@@ -832,6 +832,8 @@ List of added, changed. removed features:
   * algorithm: Added shuffle, iter_swap, reverse, reverse_range,
     lexicographical_compare, is_sorted, is_sorted_until.
     Requires now INCLUDE_ALGORITHM
+  * unordered_set and children: removed hash and equal init args, and fields.
+    They must be now declared statically beforehand as `T_hash` and `T_equal`.
   * array: Added difference, intersection, symmetric_difference, assign_range.
   * set: Added includes, includes_range.
   * string: Added find_if, find_if_not, find_if_range, find_if_not_range, includes,

api.lst

@@ -343,7 +343,7 @@ ctl/unordered_set.h: max_bucket_count (A *self)
 ctl/unordered_set.h: load_factor (A *self)
 ctl/unordered_set.h: _reserve (A *self, const size_t new_size)
 ctl/unordered_set.h: reserve (A *self, size_t desired_count)
-ctl/unordered_set.h: init (size_t (*_hash)(T *), int (*_equal)(T *, T *))
+ctl/unordered_set.h: init (void)
 ctl/unordered_set.h: init_from (A *copy)
 ctl/unordered_set.h: rehash (A *self, size_t desired_count)
 ctl/unordered_set.h: _rehash (A *self, size_t count)

ctl/bits/integral.h

@@ -1,4 +1,5 @@
-/* Type utilities, to apply default equal, compare, hash methods for intergral types.
+/* Type utilities, to apply default equal, compare for integral types.
+   And hash methods.
    See MIT LICENSE.
  */
 
@@ -14,7 +15,47 @@ _define_integral_compare(long)
 #undef _define_integral_compare
 */
 
+#include <string.h>
+
+#ifndef CTL_HASH_DEFAULTS
+#define CTL_HASH_DEFAULTS
+static inline uint32_t ctl_int32_hash(uint32_t key)
+{
+    key = ((key >> 16) ^ key) * 0x45d9f3b;
+    key = ((key >> 16) ^ key) * 0x45d9f3b;
+    key = (key >> 16) ^ key;
+    return key;
+}
+/* FNV1a. Eventually wyhash or o1hash */
+static inline size_t ctl_string_hash(const char* key)
+{
+    size_t h;
+    h = 2166136261u;
+    for (unsigned i = 0; i < strlen((char *)key); i++)
+    {
+        h ^= (unsigned char)key[i];
+        h *= 16777619;
+    }
+    return h;
+}
+
 #if defined(POD) && !defined(NOT_INTEGRAL)
+static inline int JOIN(T, equal)(T *a, T *b)
+{
+    return *a == *b;
+}
+#endif
+
+#endif //CTL_HASH_DEFAULTS
+
+#if defined(POD) && !defined(NOT_INTEGRAL)
+
+#ifdef CTL_USET
+static inline size_t _JOIN(A, _default_integral_hash)(T *a)
+{
+    return ctl_int32_hash((uint32_t)*a);
+}
+#endif //USET
 
 static inline int _JOIN(A, _default_integral_compare3)(T *a, T *b)
 {
@@ -34,30 +75,6 @@ static inline int _JOIN(A, _default_integral_equal)(T *a, T *b)
     */
 }
 
-static inline size_t _JOIN(A, _default_integral_hash)(T *a)
-{
-    return (size_t)*a;
-}
-
-#include <string.h>
-
-#if defined str || defined u8string || defined charp || defined u8ident || defined ucharp
-
-static inline size_t _JOIN(A, _default_string_hash)(T *key)
-{
-    size_t h;
-    /* FNV1a, not wyhash */
-    h = 2166136261u;
-    for (unsigned i = 0; i < strlen((char *)key); i++)
-    {
-        h ^= (unsigned char)key[i];
-        h *= 16777619;
-    }
-    return h;
-}
-
-#endif
-
 #define CTL_STRINGIFY_HELPER(n) #n
 #define CTL_STRINGIFY(n) CTL_STRINGIFY_HELPER(n)
 #define _strEQcc(s1c, s2c) !strcmp(s1c "", s2c "")
@@ -83,47 +100,29 @@ static inline bool _JOIN(A, _type_is_integral)(void)
            _strEQcc(CTL_STRINGIFY(T), "llong");
 }
 
-// not C++
-#ifndef __cplusplus
-#define __set_str_hash(self, t)                                                                                        \
-    {                                                                                                                  \
-        typeof(t) tmp = (x);                                                                                           \
-        if (__builtin_types_compatible_p(typeof(t), char *))                                                           \
-            self->hash = _JOIN(A, _default_string_hash);                                                               \
-        else if (__builtin_types_compatible_p(typeof(t), unsigned char *))                                             \
-            self->hash = _JOIN(A, _default_string_hash);                                                               \
-    }
-#else
-#define __set_str_hash(self, t) self->hash = _JOIN(A, _default_string_hash)
-#endif
-
 static inline void _JOIN(A, _set_default_methods)(A *self)
 {
 #if !defined CTL_STR
 #if defined str || defined u8string || defined charp || defined u8ident || defined ucharp
     {
-#ifdef CTL_USET
-        if (!self->hash)
-            __set_str_hash(self, T);
-#else
+#ifndef CTL_USET
         if (!self->compare)
             self->compare = str_key_compare;
-#endif
         if (!self->equal)
             self->equal = str_equal;
+#endif
     }
     else
 #endif
 #endif
-#ifdef CTL_USET
-        if (!self->hash)
-            self->hash = _JOIN(A, _default_integral_hash);
-#else
+#ifndef CTL_USET
     if (!self->compare)
         self->compare = _JOIN(A, _default_integral_compare);
-#endif
     if (!self->equal)
         self->equal = _JOIN(A, _default_integral_equal);
+#else
+    (void)self;
+#endif
 }
 
 #else

ctl/unordered_set.h

@@ -118,8 +118,6 @@ typedef struct A
     float max_load_factor;
     void (*free)(T *);
     T (*copy)(T *);
-    size_t (*hash)(T *);
-    int (*equal)(T *, T *);
 #if CTL_USET_SECURITY_COLLCOUNTING == 4
     bool is_sorted_vector;
 #elif CTL_USET_SECURITY_COLLCOUNTING == 5
@@ -144,11 +142,11 @@ static inline size_t JOIN(A, bucket_count)(A *self)
 static inline size_t JOIN(I, index)(A *self, T value)
 {
 #ifdef CTL_USET_GROWTH_POWER2
-    return self->hash(&value) & self->bucket_max;
+    return JOIN(T, hash)(&value) & self->bucket_max;
 #elif __WORDSIZE == 127
-    return ((uint64_t) self->hash(&value) * ((uint64_t) self->bucket_max + 1)) >> 32;
+    return ((uint64_t) JOIN(T, hash)(&value) * ((uint64_t) self->bucket_max + 1)) >> 32;
 #else
-    return self->hash(&value) % (self->bucket_max + 1);
+    return JOIN(T, hash)(&value) % (self->bucket_max + 1);
 #endif
 }
 
@@ -322,10 +320,12 @@ JOIN(I, range)(A* container, I* begin, I* end)
 }
 */
 
+// needed for algorithm
 static inline int JOIN(A, _equal)(A *self, T *a, T *b)
 {
-    ASSERT(self->equal || !"equal undefined");
-    return self->equal(a, b);
+    //ASSERT(JOIN(T, equal) || !"equal undefined");
+    (void)self;
+    return JOIN(T, equal)(a, b);
 }
 
 static inline A JOIN(A, init_from)(A *copy);
@@ -518,15 +518,15 @@ static inline B **JOIN(A, _bucket_hash)(A *self, size_t hash)
 static inline B **JOIN(A, _bucket)(A *self, T value)
 {
     const size_t hash = JOIN(I, index)(self, value);
-    //LOG ("_bucket %lx %% %lu => %zu\n", self->hash(&value), self->bucket_max + 1, hash);
+    //LOG ("_bucket %lx %% %lu => %zu\n", JOIN(T, hash)(&value), self->bucket_max + 1, hash);
     return &self->buckets[hash];
 }
 #endif
 
 static inline size_t JOIN(A, bucket)(A *self, T value)
 {
     const size_t hash = JOIN(I, index)(self, value);
-    //LOG ("bucket %lx %% %lu => %zu\n", self->hash(&value), self->bucket_max + 1, hash);
+    //LOG ("bucket %lx %% %lu => %zu\n", JOIN(T, hash)(&value), self->bucket_max + 1, hash);
     return hash;
 }
 
@@ -613,12 +613,10 @@ static inline void JOIN(A, reserve)(A *self, size_t desired_count)
     JOIN(A, _rehash)(self, new_size);
 }
 
-static inline A JOIN(A, init)(size_t (*_hash)(T *), int (*_equal)(T *, T *))
+static inline A JOIN(A, init)(void)
 {
     static A zero;
     A self = zero;
-    self.hash = _hash;
-    self.equal = _equal;
 #ifdef POD
     self.copy = JOIN(A, implicit_copy);
     _JOIN(A, _set_default_methods)(&self);
@@ -633,24 +631,15 @@ static inline A JOIN(A, init)(size_t (*_hash)(T *), int (*_equal)(T *, T *))
 
 static inline A JOIN(A, init_from)(A *copy)
 {
-    static A zero;
-    A self = zero;
-#ifdef POD
-    self.copy = JOIN(A, implicit_copy);
-#else
-    self.free = JOIN(T, free);
-    self.copy = JOIN(T, copy);
-#endif
-    self.hash = copy->hash;
-    self.equal = copy->equal;
-    return self;
+    (void)copy;
+    return JOIN(A, init)();
 }
 
 static inline void JOIN(A, rehash)(A *self, size_t desired_count)
 {
     if (desired_count == (self->bucket_max + 1))
         return;
-    A rehashed = JOIN(A, init)(self->hash, self->equal);
+    A rehashed = JOIN(A, init)();
     JOIN(A, reserve)(&rehashed, desired_count);
     if (LIKELY(self->buckets && self->size)) // if desired_count 0
     {
@@ -681,7 +670,7 @@ static inline void JOIN(A, _rehash)(A *self, size_t count)
     // we do allow shrink here
     if (count == self->bucket_max + 1)
         return;
-    A rehashed = JOIN(A, init)(self->hash, self->equal);
+    A rehashed = JOIN(A, init)();
     //LOG("_rehash %zu => %zu\n", self->size, count);
     JOIN(A, _reserve)(&rehashed, count);
 
@@ -714,7 +703,7 @@ static inline B *JOIN(A, find_node)(A *self, T value)
     if (self->size)
     {
 #ifdef CTL_USET_CACHED_HASH
-        size_t hash = self->hash(&value);
+        size_t hash = JOIN(T, hash)(&value);
         B **buckets = JOIN(A, _bucket_hash)(self, hash);
 #else
         B **buckets = JOIN(A, _bucket)(self, value);
@@ -739,7 +728,7 @@ static inline B *JOIN(A, find_node)(A *self, T value)
             if (n->cached_hash != hash)
                 continue;
 #endif
-            if (self->equal(&value, &n->value))
+            if (JOIN(T, equal)(&value, &n->value))
             {
 #if 0 // not yet
                 // speedup subsequent read accesses?
@@ -802,7 +791,7 @@ static inline B **JOIN(A, push_cached)(A *self, T *value)
 #endif
 
 #ifdef CTL_USET_CACHED_HASH
-    size_t hash = self->hash(value);
+    size_t hash = JOIN(T, hash)(value);
     B **buckets = JOIN(A, _bucket_hash)(self, hash);
     JOIN(B, push)(buckets, JOIN(B, init_cached)(*value, hash));
 #else
@@ -899,7 +888,7 @@ static inline I JOIN(A, emplace_hint)(I *pos, T *value)
     if (!JOIN(I, done)(pos))
     {
 #ifdef CTL_USET_CACHED_HASH
-        size_t hash = self->hash(value);
+        size_t hash = JOIN(T, hash)(value);
         B **buckets = JOIN(A, _bucket_hash)(self, hash);
 #else
         B **buckets = JOIN(A, _bucket)(self, *value);
@@ -924,7 +913,7 @@ static inline I JOIN(A, emplace_hint)(I *pos, T *value)
             if (n->cached_hash != hash)
                 continue;
 #endif
-            if (self->equal(value, &n->value))
+            if (JOIN(T, equal)(value, &n->value))
             {
                 FREE_VALUE(self, *value);
                 return JOIN(I, iter)(self, n);
@@ -1060,7 +1049,7 @@ static inline void JOIN(A, _linked_erase)(A *self, B **bucket, B *n, B *prev, B
 static inline void JOIN(A, erase)(A *self, T value)
 {
 #ifdef CTL_USET_CACHED_HASH
-    size_t hash = self->hash(&value);
+    size_t hash = JOIN(T, hash)(&value);
     B **buckets = JOIN(A, _bucket_hash)(self, hash);
 #else
     B **buckets = JOIN(A, _bucket)(self, value);
@@ -1078,7 +1067,7 @@ static inline void JOIN(A, erase)(A *self, T value)
             continue;
         }
 #endif
-        if (self->equal(&value, &n->value))
+        if (JOIN(T, equal)(&value, &n->value))
         {
             JOIN(A, _linked_erase)(self, buckets, n, prev, next);
             break;
@@ -1115,7 +1104,7 @@ static inline size_t JOIN(A, erase_if)(A *self, int (*_match)(T *))
 static inline A JOIN(A, copy)(A *self)
 {
     // LOG ("copy\norig size: %lu\n", self->size);
-    A other = JOIN(A, init)(self->hash, self->equal);
+    A other = JOIN(A, init)();
     JOIN(A, _reserve)(&other, self->bucket_max + 1);
     foreach (A, self, it)
     {
@@ -1154,7 +1143,7 @@ static inline void JOIN(A, erase_generic)(A* self, GI *range)
 
 static inline A JOIN(A, union)(A *a, A *b)
 {
-    A self = JOIN(A, init)(a->hash, a->equal);
+    A self = JOIN(A, init)();
     JOIN(A, _reserve)(&self, 1 + MAX(a->bucket_max, b->bucket_max));
     foreach (A, a, it1)
         JOIN(A, insert)(&self, self.copy(it1.ref));
@@ -1182,7 +1171,7 @@ static inline A JOIN(A, union_range)(I *r1, GI *r2)
 
 static inline A JOIN(A, intersection)(A *a, A *b)
 {
-    A self = JOIN(A, init)(a->hash, a->equal);
+    A self = JOIN(A, init)();
     foreach (A, a, it)
         if (JOIN(A, find_node)(b, *it.ref))
             JOIN(A, insert)(&self, self.copy(it.ref));
@@ -1192,7 +1181,7 @@ static inline A JOIN(A, intersection)(A *a, A *b)
 static inline A JOIN(A, intersection_range)(I *r1, GI *r2)
 {
     A *a = r1->container;
-    A self = JOIN(A, init)(a->hash, a->equal);
+    A self = JOIN(A, init)();
     void (*next2)(struct I*) = r2->vtable.next;
     T* (*ref2)(struct I*) = r2->vtable.ref;
     int (*done2)(struct I*) = r2->vtable.done;
@@ -1214,7 +1203,7 @@ static inline A JOIN(A, intersection_range)(I *r1, GI *r2)
 
 static inline A JOIN(A, difference)(A *a, A *b)
 {
-    A self = JOIN(A, init)(a->hash, a->equal);
+    A self = JOIN(A, init)();
     foreach (A, a, it)
         if (!JOIN(A, find_node)(b, *it.ref))
             JOIN(A, insert)(&self, self.copy(it.ref));