Merge pull request #23 from OliverKillane/enh/add-hashset

OliverKillane · web-flow · commit c7a53d44ef7a · 2026-01-16T01:45:26.000+01:00
Added hashset based on swisstable
diff --git a/src/derive-c/alloc/test/template.h b/src/derive-c/alloc/test/template.h
@@ -33,7 +33,7 @@
     #define KEY_HASH(ptr) ((size_t)(*(ptr))) // [DERIVE-C] for template
     #define KEY_DEBUG dc_void_ptr_debug      // [DERIVE-C] for template
     #define VALUE size_t                     // [DERIVE-C] for template
-    #define DC_INTERNAL_NAME ALLOCATIONS_MAP // [DERIVE-C] for template
+    #define INTERNAL_NAME ALLOCATIONS_MAP    // [DERIVE-C] for template
     #include <derive-c/container/map/swiss/template.h>
 
     #pragma pop_macro("ALLOC")
diff --git a/src/derive-c/container/arena/chunked/template.h b/src/derive-c/container/arena/chunked/template.h
@@ -69,7 +69,7 @@ typedef ALLOC NS(SELF, alloc_t);
 #define SLOT_VALUE_CLONE VALUE_CLONE   // [DERIVE-C] for template
 #define SLOT_VALUE_CLONE VALUE_CLONE   // [DERIVE-C] for template
 #define SLOT_VALUE_DELETE VALUE_DELETE // [DERIVE-C] for template
-#define DC_INTERNAL_NAME SLOT          // [DERIVE-C] for template
+#define INTERNAL_NAME SLOT             // [DERIVE-C] for template
 #include <derive-c/utils/slot/template.h>
 
 typedef SLOT PRIV(NS(SELF, block))[DC_ARENA_CHUNKED_BLOCK_SIZE(BLOCK_INDEX_BITS)];
diff --git a/src/derive-c/container/arena/contiguous/template.h b/src/derive-c/container/arena/contiguous/template.h
@@ -64,7 +64,7 @@ typedef ALLOC NS(SELF, alloc_t);
 #define SLOT_VALUE_CLONE VALUE_CLONE   // [DERIVE-C] for template
 #define SLOT_VALUE_CLONE VALUE_CLONE   // [DERIVE-C] for template
 #define SLOT_VALUE_DELETE VALUE_DELETE // [DERIVE-C] for template
-#define DC_INTERNAL_NAME SLOT          // [DERIVE-C] for template
+#define INTERNAL_NAME SLOT             // [DERIVE-C] for template
 #include <derive-c/utils/slot/template.h>
 
 typedef struct {
diff --git a/src/derive-c/container/arena/geometric/template.h b/src/derive-c/container/arena/geometric/template.h
@@ -95,7 +95,7 @@ typedef ALLOC NS(SELF, alloc_t);
 #define SLOT_VALUE_CLONE VALUE_CLONE   // [DERIVE-C] for template
 #define SLOT_VALUE_CLONE VALUE_CLONE   // [DERIVE-C] for template
 #define SLOT_VALUE_DELETE VALUE_DELETE // [DERIVE-C] for template
-#define DC_INTERNAL_NAME SLOT          // [DERIVE-C] for template
+#define INTERNAL_NAME SLOT             // [DERIVE-C] for template
 #include <derive-c/utils/slot/template.h>
 
 typedef struct {
diff --git a/src/derive-c/container/arena/trait.h b/src/derive-c/container/arena/trait.h
@@ -13,6 +13,7 @@
     DC_REQUIRE_METHOD(bool, SELF, try_remove, (SELF*, NS(SELF, index_t), NS(SELF, value_t)*));     \
     DC_REQUIRE_METHOD(NS(SELF, value_t), SELF, remove, (SELF*, NS(SELF, index_t)));                \
     DC_TRAIT_ITERABLE(SELF);                                                                       \
+    DC_TRAIT_CONST_ITERABLE(SELF);                                                                 \
     DC_TRAIT_CLONEABLE(SELF);                                                                      \
     DC_TRAIT_DELETABLE(SELF);                                                                      \
     DC_TRAIT_DEBUGABLE(SELF)
diff --git a/src/derive-c/container/bitset/trait.h b/src/derive-c/container/bitset/trait.h
@@ -12,6 +12,7 @@
     DC_REQUIRE_METHOD(bool, SELF, get, (SELF const*, NS(SELF, index_t)));                          \
     DC_REQUIRE_METHOD(size_t, SELF, size, (SELF const*));                                          \
     DC_TRAIT_ITERABLE(SELF);                                                                       \
+    DC_TRAIT_CONST_ITERABLE(SELF);                                                                 \
     DC_TRAIT_CLONEABLE(SELF);                                                                      \
     DC_TRAIT_DELETABLE(SELF);                                                                      \
     DC_TRAIT_DEBUGABLE(SELF)
diff --git a/src/derive-c/container/map/ankerl/template.h b/src/derive-c/container/map/ankerl/template.h
@@ -114,7 +114,7 @@ DC_INTERNAL static void PRIV(NS(SLOT, delete))(SLOT* slot) {
 #define ITEM_CLONE PRIV(NS(SLOT, clone)) // [DERIVE-C] for template
 #define ITEM_DEBUG PRIV(NS(SLOT, debug)) // [DERIVE-C] for template
 #define ITEM_CLONE PRIV(NS(SLOT, clone)) // [DERIVE-C] for template
-#define DC_INTERNAL_NAME SLOT_VECTOR     // [DERIVE-C] for template
+#define INTERNAL_NAME SLOT_VECTOR        // [DERIVE-C] for template
 #include <derive-c/container/vector/dynamic/template.h>
 
 #pragma pop_macro("ALLOC")
diff --git a/src/derive-c/container/map/staticlinear/template.h b/src/derive-c/container/map/staticlinear/template.h
@@ -68,7 +68,7 @@ typedef VALUE NS(SELF, value_t);
 #define BITSET NS(NAME, bitset)
 
 #define EXCLUSIVE_END_INDEX CAPACITY // [DERIVE-C] for template
-#define DC_INTERNAL_NAME BITSET      // [DERIVE-C] for template
+#define INTERNAL_NAME BITSET         // [DERIVE-C] for template
 #include <derive-c/container/bitset/static/template.h>
 
 #define BITSET_INDEX_TYPE NS(BITSET, index_t)
diff --git a/src/derive-c/container/map/trait.h b/src/derive-c/container/map/trait.h
@@ -19,6 +19,7 @@
     DC_REQUIRE_METHOD(void, SELF, delete_entry, (SELF*, NS(SELF, key_t)));                         \
     DC_REQUIRE_METHOD(size_t, SELF, size, (SELF const*));                                          \
     DC_TRAIT_ITERABLE(SELF);                                                                       \
+    DC_TRAIT_CONST_ITERABLE(SELF);                                                                 \
     DC_TRAIT_CLONEABLE(SELF);                                                                      \
     DC_TRAIT_DELETABLE(SELF);                                                                      \
     DC_TRAIT_DEBUGABLE(SELF)
diff --git a/src/derive-c/container/queue/deque/template.h b/src/derive-c/container/queue/deque/template.h
@@ -49,7 +49,7 @@ typedef ALLOC NS(SELF, alloc_t);
 #pragma push_macro("ITEM_DELETE")
 
 // ITEM is already defined
-#define DC_INTERNAL_NAME ITEM_VECTORS // [DERIVE-C] for template
+#define INTERNAL_NAME ITEM_VECTORS // [DERIVE-C] for template
 #include <derive-c/container/vector/dynamic/template.h>
 
 #pragma pop_macro("ALLOC")
diff --git a/src/derive-c/container/queue/trait.h b/src/derive-c/container/queue/trait.h
@@ -16,6 +16,7 @@
     DC_REQUIRE_METHOD(NS(SELF, item_t), SELF, pop_front, (SELF*));                                 \
     DC_REQUIRE_METHOD(NS(SELF, item_t), SELF, pop_back, (SELF*));                                  \
     DC_TRAIT_ITERABLE(SELF);                                                                       \
+    DC_TRAIT_CONST_ITERABLE(SELF);                                                                 \
     DC_TRAIT_DELETABLE(SELF);                                                                      \
     DC_TRAIT_CLONEABLE(SELF);                                                                      \
     DC_TRAIT_DEBUGABLE(SELF)
diff --git a/src/derive-c/container/set/swiss/includes.h b/src/derive-c/container/set/swiss/includes.h
@@ -0,0 +1,18 @@
+#pragma once
+
+// [DERIVE-C] stdlib includes
+#include <stdbool.h> // IWYU pragma: export
+#include <stddef.h>  // IWYU pragma: export
+#include <stdint.h>  // IWYU pragma: export
+#include <stdio.h>   // IWYU pragma: export
+#include <stdlib.h>  // IWYU pragma: export
+#include <string.h>  // IWYU pragma: export
+
+// [DERIVE-C] lib includes
+#include <derive-c/container/set/trait.h>   // IWYU pragma: export
+#include <derive-c/core/debug/gdb_marker.h> // IWYU pragma: export
+#include <derive-c/core/prelude.h>          // IWYU pragma: export
+#include <derive-c/alloc/std.h>             // IWYU pragma: export
+
+// [DERIVE-C] used template includes
+#include <derive-c/container/map/swiss/includes.h> // IWYU pragma: export
diff --git a/src/derive-c/container/set/swiss/template.h b/src/derive-c/container/set/swiss/template.h
@@ -0,0 +1,167 @@
+/// @brief A swisstable based hashset
+
+#include <derive-c/core/includes/def.h>
+#if !defined(SKIP_INCLUDES)
+    #include "includes.h"
+#endif
+
+#include <derive-c/core/alloc/def.h>
+#include <derive-c/core/self/def.h>
+
+#if !defined ITEM
+    #if !defined DC_PLACEHOLDERS
+TEMPLATE_ERROR("No ITEM")
+    #endif
+    #define ITEM set_item_t
+typedef size_t ITEM;
+#endif
+
+#if !defined ITEM_HASH
+    #if !defined DC_PLACEHOLDERS
+TEMPLATE_ERROR("No ITEM_HASH")
+    #endif
+
+    #define ITEM_HASH item_hash
+static size_t ITEM_HASH(ITEM const* item) { return *item; }
+#endif
+
+#if !defined ITEM_EQ
+    #define ITEM_EQ DC_MEM_EQ
+#endif
+
+#if !defined ITEM_DELETE
+    #define ITEM_DELETE DC_NO_DELETE
+#endif
+
+#if !defined ITEM_CLONE
+    #define ITEM_CLONE DC_COPY_CLONE
+#endif
+
+#if !defined ITEM_DEBUG
+    #define ITEM_DEBUG DC_DEFAULT_DEBUG
+#endif
+
+typedef ITEM NS(SELF, item_t);
+
+#define MAP PRIV(NS(NAME, inner_map))
+
+#pragma push_macro("ALLOC")
+
+#define KEY ITEM                    // [DERIVE-C] for template
+#define KEY_HASH ITEM_HASH          // [DERIVE-C] for template
+#define KEY_EQ ITEM_EQ              // [DERIVE-C] for template
+#define KEY_DELETE ITEM_DELETE      // [DERIVE-C] for template
+#define KEY_CLONE ITEM_CLONE        // [DERIVE-C] for template
+#define KEY_DEBUG ITEM_DEBUG        // [DERIVE-C] for template
+#define VALUE dc_unit               // [DERIVE-C] for template
+#define VALUE_DELETE dc_unit_delete // [DERIVE-C] for template
+#define VALUE_CLONE dc_unit_clone   // [DERIVE-C] for template
+#define VALUE_DEBUG dc_unit_debug   // [DERIVE-C] for template
+#define INTERNAL_NAME MAP           // [DERIVE-C] for template
+#include <derive-c/container/map/swiss/template.h>
+
+#pragma pop_macro("ALLOC")
+
+DC_STATIC_CONSTANT size_t NS(SELF, max_capacity) = NS(MAP, max_capacity);
+
+typedef struct {
+    MAP map;
+} SELF;
+
+DC_PUBLIC static SELF NS(SELF, new_with_capacity_for)(size_t for_items, NS(ALLOC, ref) alloc_ref) {
+    return (SELF){
+        .map = NS(MAP, new_with_capacity_for)(for_items, alloc_ref),
+    };
+}
+
+DC_PUBLIC static SELF NS(SELF, new)(NS(ALLOC, ref) alloc_ref) {
+    return (SELF){
+        .map = NS(MAP, new)(alloc_ref),
+    };
+}
+
+DC_PUBLIC static SELF NS(SELF, clone)(SELF const* self) {
+    return (SELF){
+        .map = NS(MAP, clone)(&self->map),
+    };
+}
+
+DC_PUBLIC static void NS(SELF, extend_capacity_for)(SELF* self, size_t expected_items) {
+    NS(MAP, extend_capacity_for)(&self->map, expected_items);
+}
+
+DC_PUBLIC static bool NS(SELF, try_add)(SELF* self, ITEM item) {
+    return NS(MAP, try_insert(&self->map, item, dc_unit_new())) != NULL;
+}
+
+DC_PUBLIC static void NS(SELF, add)(SELF* self, ITEM item) {
+    bool const inserted = NS(SELF, try_add)(self, item);
+    DC_ASSERT(inserted, "Failed to insert item");
+}
+
+DC_PUBLIC static bool NS(SELF, contains)(SELF const* self, ITEM item) {
+    return NS(MAP, try_read)(&self->map, item) != NULL;
+}
+
+DC_PUBLIC static bool NS(SELF, try_remove)(SELF* self, ITEM item) {
+    dc_unit dest;
+    return NS(MAP, try_remove)(&self->map, item, &dest);
+}
+
+DC_PUBLIC static void NS(SELF, remove)(SELF* self, ITEM item) {
+    bool const removed = NS(SELF, try_remove)(self, item);
+    DC_ASSERT(removed, "Failed to remove");
+}
+
+DC_PUBLIC static size_t NS(SELF, size)(SELF const* self) { return NS(MAP, size)(&self->map); }
+
+#define ITER_CONST NS(SELF, iter_const)
+
+typedef struct {
+    NS(MAP, iter_const) map_iter;
+} ITER_CONST;
+
+typedef ITEM const* NS(ITER_CONST, item);
+
+DC_PUBLIC static bool NS(ITER_CONST, empty_item)(ITEM const* const* item) { return *item == NULL; }
+
+DC_PUBLIC static ITEM const* NS(ITER_CONST, next)(ITER_CONST* iter) {
+    return NS(MAP, NS(iter_const, next))(&iter->map_iter).key;
+}
+
+DC_PUBLIC static ITER_CONST NS(SELF, get_iter_const)(SELF const* self) {
+    return (ITER_CONST){
+        .map_iter = NS(MAP, get_iter_const)(&self->map),
+    };
+}
+
+DC_PUBLIC static void NS(SELF, debug)(SELF const* self, dc_debug_fmt fmt, FILE* stream) {
+    fprintf(stream, DC_EXPAND_STRING(SELF) "@%p {\n", (void*)self);
+    fmt = dc_debug_fmt_scope_begin(fmt);
+
+    dc_debug_fmt_print(fmt, stream, "map: ");
+    NS(MAP, debug)(&self->map, fmt, stream);
+    fprintf(stream, ",\n");
+
+    fmt = dc_debug_fmt_scope_end(fmt);
+    dc_debug_fmt_print(fmt, stream, "}");
+}
+
+#undef ITER_CONST
+
+DC_PUBLIC static void NS(SELF, delete)(SELF* self) { NS(MAP, delete)(&self->map); }
+
+#undef MAP
+
+#undef ITEM_DEBUG
+#undef ITEM_CLONE
+#undef ITEM_DELETE
+#undef ITEM_EQ
+#undef ITEM_HASH
+#undef ITEM
+
+DC_TRAIT_SET(SELF);
+
+#include <derive-c/core/self/undef.h>
+#include <derive-c/core/alloc/undef.h>
+#include <derive-c/core/includes/undef.h>
diff --git a/src/derive-c/container/set/trait.h b/src/derive-c/container/set/trait.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <derive-c/core/prelude.h>
+
+#define DC_TRAIT_SET(SELF)                                                                         \
+    DC_REQUIRE_TYPE(SELF, item_t);                                                                 \
+    DC_REQUIRE_CONSTANT(SELF, max_capacity, size_t);                                               \
+    DC_REQUIRE_METHOD(bool, SELF, try_add, (SELF*, NS(SELF, item_t)));                             \
+    DC_REQUIRE_METHOD(void, SELF, add, (SELF*, NS(SELF, item_t)));                                 \
+    DC_REQUIRE_METHOD(bool, SELF, contains, (SELF const*, NS(SELF, item_t)));                      \
+    DC_REQUIRE_METHOD(bool, SELF, try_remove, (SELF*, NS(SELF, item_t)));                          \
+    DC_REQUIRE_METHOD(void, SELF, remove, (SELF*, NS(SELF, item_t)));                              \
+    DC_REQUIRE_METHOD(size_t, SELF, size, (SELF const*));                                          \
+    DC_TRAIT_CONST_ITERABLE(SELF);                                                                 \
+    DC_TRAIT_CLONEABLE(SELF);                                                                      \
+    DC_TRAIT_DELETABLE(SELF);                                                                      \
+    DC_TRAIT_DEBUGABLE(SELF)
diff --git a/src/derive-c/container/vector/trait.h b/src/derive-c/container/vector/trait.h
@@ -19,6 +19,7 @@
     DC_REQUIRE_METHOD(NS(SELF, item_t)*, SELF, push, (SELF*, NS(SELF, item_t)));                   \
     DC_REQUIRE_METHOD(NS(SELF, index_t), SELF, size, (SELF const*));                               \
     DC_TRAIT_ITERABLE(SELF);                                                                       \
+    DC_TRAIT_CONST_ITERABLE(SELF);                                                                 \
     DC_TRAIT_DELETABLE(SELF);                                                                      \
     DC_TRAIT_CLONEABLE(SELF);                                                                      \
     DC_TRAIT_DEBUGABLE(SELF)
diff --git a/src/derive-c/core/prelude.h b/src/derive-c/core/prelude.h
@@ -11,6 +11,7 @@
 #include <derive-c/core/require.h>     // IWYU pragma: export
 #include <derive-c/core/scope.h>       // IWYU pragma: export
 #include <derive-c/core/zerosized.h>   // IWYU pragma: export
+#include <derive-c/core/unit.h>        // IWYU pragma: export
 
 // Traits
 #include <derive-c/core/traits/clone.h>  // IWYU pragma: export
diff --git a/src/derive-c/core/self/def.h b/src/derive-c/core/self/def.h
@@ -29,15 +29,15 @@
 /// 3. Namespace all macro paramaters (e.g. `VECTOR_SELF`, `HASHMAP_SELF` etc)
 ///
 /// To keep code simple, but allow definitions to uniformly use `SELF`:
-///  - We restrict to 1 layer deep - `NAME` (from user), and `DC_INTERNAL_NAME` (usage inside a
+///  - We restrict to 1 layer deep - `NAME` (from user), and `INTERNAL_NAME` (usage inside a
 ///  template file, one layer deep).
 
-#if defined DC_INTERNAL_NAME
+#if defined INTERNAL_NAME
     #if defined SELF
         #pragma push_macro("SELF")
         #define SELF_PUSHED
         #undef SELF
-        #define SELF DC_EXPAND(DC_INTERNAL_NAME)
+        #define SELF DC_EXPAND(INTERNAL_NAME)
     #endif
 #elif defined NAME
     #if defined SELF
@@ -46,8 +46,7 @@
     #define SELF DC_EXPAND(NAME)
 #else
     #if !defined DC_PLACEHOLDERS
-        #error                                                                                     \
-            "The `SELF` type for a data structure must be defined (by `NAME` or `DC_INTERNAL_NAME`)"
+        #error "The `SELF` type for a data structure must be defined (by `NAME` or `INTERNAL_NAME`)"
     #endif
     #define NAME self_t
     #define SELF NAME
diff --git a/src/derive-c/core/self/undef.h b/src/derive-c/core/self/undef.h
@@ -8,10 +8,10 @@
     #undef SELF_PUSHED
 #endif
 
-#if defined DC_INTERNAL_NAME
-    #undef DC_INTERNAL_NAME // [DERIVE-C] argument
+#if defined INTERNAL_NAME
+    #undef INTERNAL_NAME // [DERIVE-C] argument
 #elif defined NAME
     #undef NAME
 #elif !defined DC_PLACEHOLDERS
-    #error "If `DC_INTERNAL_NAME` is not defined, `NAME` must be defined"
+    #error "If `INTERNAL_NAME` is not defined, `NAME` must be defined"
 #endif
diff --git a/src/derive-c/core/traits/iter.h b/src/derive-c/core/traits/iter.h
@@ -8,10 +8,12 @@
     DC_REQUIRE_METHOD(NS(SELF, item), SELF, next, (SELF*));                                        \
     DC_REQUIRE_METHOD(bool, SELF, empty_item, (NS(SELF, item) const*))
 
-#define DC_TRAIT_ITERABLE(SELF)                                                                    \
-    DC_REQUIRE_TYPE(SELF, iter);                                                                   \
+#define DC_TRAIT_CONST_ITERABLE(SELF)                                                              \
     DC_REQUIRE_TYPE(SELF, iter_const);                                                             \
-    DC_REQUIRE_METHOD(NS(SELF, iter), SELF, get_iter, (SELF*));                                    \
     DC_REQUIRE_METHOD(NS(SELF, iter_const), SELF, get_iter_const, (SELF const*));                  \
-    DC_TRAIT_ITER(NS(SELF, iter));                                                                 \
     DC_TRAIT_ITER(NS(SELF, iter_const))
+
+#define DC_TRAIT_ITERABLE(SELF)                                                                    \
+    DC_REQUIRE_TYPE(SELF, iter);                                                                   \
+    DC_REQUIRE_METHOD(NS(SELF, iter), SELF, get_iter, (SELF*));                                    \
+    DC_TRAIT_ITER(NS(SELF, iter))
diff --git a/src/derive-c/core/unit.h b/src/derive-c/core/unit.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <derive-c/core/debug/fmt.h>
+#include <derive-c/core/zerosized.h>
+#include <derive-c/core/namespace.h>
+
+DC_ZERO_SIZED(dc_unit);
+
+DC_PUBLIC static dc_unit dc_unit_new() { return (dc_unit){}; }
+
+DC_PUBLIC static dc_unit dc_unit_clone(dc_unit const* self) { return *self; }
+
+DC_PUBLIC static void dc_unit_debug(dc_unit const* /* self */, dc_debug_fmt /* fmt */,
+                                    FILE* stream) {
+    fprintf(stream, "[UNIT]");
+}
+
+DC_PUBLIC static void dc_unit_delete(dc_unit* /* self */) {}
diff --git a/test/containers/set/commands.hpp b/test/containers/set/commands.hpp
diff --git a/test/containers/set/swiss/fuzz.cpp b/test/containers/set/swiss/fuzz.cpp
diff --git a/test/containers/set/swiss/test.cpp b/test/containers/set/swiss/test.cpp
diff --git a/test/containers/set/swiss/warn.c b/test/containers/set/swiss/warn.c
