From f513658788a084c13f17c25021dbdc7a8c958fb6 Mon Sep 17 00:00:00 2001
From: "Michael Gene Brockus (Dreamer)" <michaelbrockus@gmail.com>
Date: Thu, 10 Oct 2024 09:24:07 -0600
Subject: [PATCH 1/7] add classes

---
 code/logic/fossil/tofu/arrayof.h     | 40 +++++++++++++++++
 code/logic/fossil/tofu/doublylist.h  | 66 ++++++++++++++++++++++++++++
 code/logic/fossil/tofu/dqueue.h      | 58 ++++++++++++++++++++++++
 code/logic/fossil/tofu/forwardlist.h | 66 ++++++++++++++++++++++++++++
 code/logic/fossil/tofu/mapof.h       | 56 +++++++++++++++++++++--
 code/logic/fossil/tofu/pqueue.h      | 58 ++++++++++++++++++++++++
 code/logic/fossil/tofu/queue.h       | 58 ++++++++++++++++++++++++
 code/logic/fossil/tofu/setof.h       | 60 +++++++++++++++++++++++++
 code/logic/fossil/tofu/stack.h       | 62 ++++++++++++++++++++++++++
 code/logic/fossil/tofu/tofu.h        |  8 ++++
 code/logic/fossil/tofu/vector.h      | 60 +++++++++++++++++++++++++
 11 files changed, 588 insertions(+), 4 deletions(-)

diff --git a/code/logic/fossil/tofu/arrayof.h b/code/logic/fossil/tofu/arrayof.h
index be7345c..3fe1f40 100644
--- a/code/logic/fossil/tofu/arrayof.h
+++ b/code/logic/fossil/tofu/arrayof.h
@@ -96,4 +96,44 @@ void fossil_tofu_arrayof_print(const fossil_tofu_arrayof_t *arrayof);
 }
 #endif
 
+#ifdef __cplusplus
+namespace fossil {
+    class ArrayOf {
+    public:
+        ArrayOf(char* type, size_t size, ...) : arrayof_(fossil_tofu_arrayof_create(type, size)) {}
+
+        ~ArrayOf() {
+            fossil_tofu_arrayof_erase(arrayof_);
+        }
+
+        void add(fossil_tofu_t element) {
+            fossil_tofu_arrayof_add(arrayof_, element);
+        }
+
+        fossil_tofu_t get(size_t index) {
+            return fossil_tofu_arrayof_get(arrayof_, index);
+        }
+
+        size_t size() {
+            return fossil_tofu_arrayof_size(arrayof_);
+        }
+
+        bool is_empty() {
+            return fossil_tofu_arrayof_is_empty(arrayof_);
+        }
+
+        void clear() {
+            fossil_tofu_arrayof_clear(arrayof_);
+        }
+
+        void print() {
+            fossil_tofu_arrayof_print(arrayof_);
+        }
+
+    private:
+        fossil_tofu_arrayof_t* arrayof_;
+    };
+}
+#endif
+
 #endif /* FOSSIL_TOFU_FRAMEWORK_H */
diff --git a/code/logic/fossil/tofu/doublylist.h b/code/logic/fossil/tofu/doublylist.h
index dbb6898..1414aff 100644
--- a/code/logic/fossil/tofu/doublylist.h
+++ b/code/logic/fossil/tofu/doublylist.h
@@ -153,4 +153,70 @@ bool fossil_dlist_is_cnullptr(const fossil_dlist_t* dlist);
 }
 #endif
 
+#ifdef __cplusplus
+namespace fossil {
+    class DoublyList {
+    public:
+        DoublyList(char* type) : dlist_(fossil_dlist_create(type)) {}
+
+        ~DoublyList() {
+            fossil_dlist_erase(dlist_);
+        }
+
+        void insert(fossil_tofu_t data) {
+            fossil_dlist_insert(dlist_, data);
+        }
+
+        fossil_tofu_t remove() {
+            fossil_tofu_t data;
+            fossil_dlist_remove(dlist_, &data);
+            return data;
+        }
+
+        int search(fossil_tofu_t data) {
+            return fossil_dlist_search(dlist_, data);
+        }
+
+        size_t size() {
+            return fossil_dlist_size(dlist_);
+        }
+
+        fossil_tofu_t* getter(fossil_tofu_t data) {
+            return fossil_dlist_getter(dlist_, data);
+        }
+
+        void setter(fossil_tofu_t data) {
+            fossil_dlist_setter(dlist_, data);
+        }
+
+        void reverse_forward() {
+            fossil_dlist_reverse_forward(dlist_);
+        }
+
+        void reverse_backward() {
+            fossil_dlist_reverse_backward(dlist_);
+        }
+
+        bool not_empty() {
+            return fossil_dlist_not_empty(dlist_);
+        }
+
+        bool not_cnullptr() {
+            return fossil_dlist_not_cnullptr(dlist_);
+        }
+
+        bool is_empty() {
+            return fossil_dlist_is_empty(dlist_);
+        }
+
+        bool is_cnullptr() {
+            return fossil_dlist_is_cnullptr(dlist_);
+        }
+
+    private:
+        fossil_dlist_t* dlist_;
+    };
+}
+#endif
+
 #endif /* FOSSIL_TOFU_FRAMEWORK_H */
diff --git a/code/logic/fossil/tofu/dqueue.h b/code/logic/fossil/tofu/dqueue.h
index b6e3a84..238e347 100644
--- a/code/logic/fossil/tofu/dqueue.h
+++ b/code/logic/fossil/tofu/dqueue.h
@@ -139,4 +139,62 @@ bool fossil_dqueue_is_cnullptr(const fossil_dqueue_t* dqueue);
 }
 #endif
 
+#ifdef __cplusplus
+namespace fossil {
+    class DQueue {
+    public:
+        DQueue(char* type) : dqueue_(fossil_dqueue_create(type)) {}
+
+        ~DQueue() {
+            fossil_dqueue_erase(dqueue_);
+        }
+
+        void insert(fossil_tofu_t data) {
+            fossil_dqueue_insert(dqueue_, data);
+        }
+
+        fossil_tofu_t remove() {
+            fossil_tofu_t data;
+            fossil_dqueue_remove(dqueue_, &data);
+            return data;
+        }
+
+        int search(fossil_tofu_t data) {
+            return fossil_dqueue_search(dqueue_, data);
+        }
+
+        size_t size() {
+            return fossil_dqueue_size(dqueue_);
+        }
+
+        fossil_tofu_t* getter(fossil_tofu_t data) {
+            return fossil_dqueue_getter(dqueue_, data);
+        }
+
+        void setter(fossil_tofu_t data) {
+            fossil_dqueue_setter(dqueue_, data);
+        }
+
+        bool not_empty() {
+            return fossil_dqueue_not_empty(dqueue_);
+        }
+
+        bool not_cnullptr() {
+            return fossil_dqueue_not_cnullptr(dqueue_);
+        }
+
+        bool is_empty() {
+            return fossil_dqueue_is_empty(dqueue_);
+        }
+
+        bool is_cnullptr() {
+            return fossil_dqueue_is_cnullptr(dqueue_);
+        }
+
+    private:
+        fossil_dqueue_t* dqueue_;
+    };
+}
+#endif
+
 #endif /* FOSSIL_TOFU_FRAMEWORK_H */
diff --git a/code/logic/fossil/tofu/forwardlist.h b/code/logic/fossil/tofu/forwardlist.h
index e519419..846082f 100644
--- a/code/logic/fossil/tofu/forwardlist.h
+++ b/code/logic/fossil/tofu/forwardlist.h
@@ -151,4 +151,70 @@ bool fossil_flist_is_cnullptr(const fossil_flist_t* flist);
 }
 #endif
 
+#ifdef __cplusplus
+namespace fossil {
+    class ForwardList {
+    public:
+        ForwardList(char* type) : flist_(fossil_flist_create(type)) {}
+
+        ~ForwardList() {
+            fossil_flist_erase(flist_);
+        }
+
+        void insert(fossil_tofu_t data) {
+            fossil_flist_insert(flist_, data);
+        }
+
+        fossil_tofu_t remove() {
+            fossil_tofu_t data;
+            fossil_flist_remove(flist_, &data);
+            return data;
+        }
+
+        bool search(fossil_tofu_t data) {
+            return fossil_flist_search(flist_, data) == 0;
+        }
+
+        size_t size() {
+            return fossil_flist_size(flist_);
+        }
+
+        fossil_tofu_t* getter(fossil_tofu_t data) {
+            return fossil_flist_getter(flist_, data);
+        }
+
+        void setter(fossil_tofu_t data) {
+            fossil_flist_setter(flist_, data);
+        }
+
+        void reverse_forward() {
+            fossil_flist_reverse_forward(flist_);
+        }
+
+        void reverse_backward() {
+            fossil_flist_reverse_backward(flist_);
+        }
+
+        bool not_empty() {
+            return fossil_flist_not_empty(flist_);
+        }
+
+        bool not_cnullptr() {
+            return fossil_flist_not_cnullptr(flist_);
+        }
+
+        bool is_empty() {
+            return fossil_flist_is_empty(flist_);
+        }
+
+        bool is_cnullptr() {
+            return fossil_flist_is_cnullptr(flist_);
+        }
+
+    private:
+        fossil_flist_t* flist_;
+    };
+}
+#endif
+
 #endif /* FOSSIL_TOFU_FRAMEWORK_H */
diff --git a/code/logic/fossil/tofu/mapof.h b/code/logic/fossil/tofu/mapof.h
index 318071b..6055d6b 100644
--- a/code/logic/fossil/tofu/mapof.h
+++ b/code/logic/fossil/tofu/mapof.h
@@ -30,12 +30,12 @@ typedef struct {
 } fossil_tofu_mapof_t;
 
 /**
- * @brief Creates a new map with the specified capacity.
+ * @brief Creates a new map with a given type.
  *
- * @param capacity The initial capacity of the map.
- * @return The newly created map.
+ * @param type The type of the map.
+ * @return The created map.
  */
-fossil_tofu_mapof_t fossil_tofu_mapof_create(size_t capacity);
+fossil_tofu_mapof_t fossil_tofu_mapof_create(const char *type);
 
 /**
  * @brief Adds a key-value pair to the map.
@@ -113,4 +113,52 @@ void fossil_tofu_mapof_print(fossil_tofu_mapof_t *map);
 }
 #endif
 
+#ifdef __cplusplus
+namespace fossil {
+    class Map {
+    public:
+        Map(char *type) : map_(fossil_tofu_mapof_create(type)) {}
+
+        ~Map() {
+            fossil_tofu_mapof_erase(&map_);
+        }
+
+        void add(fossil_tofu_t key, fossil_tofu_t value) {
+            fossil_tofu_mapof_add(&map_, key, value);
+        }
+
+        fossil_tofu_t get(fossil_tofu_t key) {
+            return fossil_tofu_mapof_get(&map_, key);
+        }
+
+        bool contains(fossil_tofu_t key) {
+            return fossil_tofu_mapof_contains(&map_, key);
+        }
+
+        void remove(fossil_tofu_t key) {
+            fossil_tofu_mapof_remove(&map_, key);
+        }
+
+        size_t size() {
+            return fossil_tofu_mapof_size(&map_);
+        }
+
+        bool is_empty() {
+            return fossil_tofu_mapof_is_empty(&map_);
+        }
+
+        void clear() {
+            fossil_tofu_mapof_clear(&map_);
+        }
+
+        void print() {
+            fossil_tofu_mapof_print(&map_);
+        }
+
+    private:
+        fossil_tofu_mapof_t map_;
+    };
+}
+#endif
+
 #endif /* FOSSIL_TOFU_FRAMEWORK_H */
diff --git a/code/logic/fossil/tofu/pqueue.h b/code/logic/fossil/tofu/pqueue.h
index 196094e..aada890 100644
--- a/code/logic/fossil/tofu/pqueue.h
+++ b/code/logic/fossil/tofu/pqueue.h
@@ -141,4 +141,62 @@ bool fossil_pqueue_is_cnullptr(const fossil_pqueue_t* pqueue);
 }
 #endif
 
+#ifdef __cplusplus
+namespace fossil {
+    class PQueue {
+    public:
+        PQueue(char* type) : pqueue_(fossil_pqueue_create(type)) {}
+
+        ~PQueue() {
+            fossil_pqueue_erase(pqueue_);
+        }
+
+        void insert(fossil_tofu_t data, int32_t priority) {
+            fossil_pqueue_insert(pqueue_, data, priority);
+        }
+
+        fossil_tofu_t remove() {
+            fossil_tofu_t data;
+            fossil_pqueue_remove(pqueue_, &data, 0);
+            return data;
+        }
+
+        bool search(fossil_tofu_t data, int32_t priority) {
+            return fossil_pqueue_search(pqueue_, data, priority) == 0;
+        }
+
+        size_t size() {
+            return fossil_pqueue_size(pqueue_);
+        }
+
+        fossil_tofu_t* getter(fossil_tofu_t data, int32_t priority) {
+            return fossil_pqueue_getter(pqueue_, data, priority);
+        }
+
+        void setter(fossil_tofu_t data, int32_t priority) {
+            fossil_pqueue_setter(pqueue_, data, priority);
+        }
+
+        bool not_empty() {
+            return fossil_pqueue_not_empty(pqueue_);
+        }
+
+        bool not_cnullptr() {
+            return fossil_pqueue_not_cnullptr(pqueue_);
+        }
+
+        bool is_empty() {
+            return fossil_pqueue_is_empty(pqueue_);
+        }
+
+        bool is_cnullptr() {
+            return fossil_pqueue_is_cnullptr(pqueue_);
+        }
+
+    private:
+        fossil_pqueue_t* pqueue_;
+    };
+}
+#endif
+
 #endif /* FOSSIL_TOFU_FRAMEWORK_H */
diff --git a/code/logic/fossil/tofu/queue.h b/code/logic/fossil/tofu/queue.h
index 12c3f89..72d8b69 100644
--- a/code/logic/fossil/tofu/queue.h
+++ b/code/logic/fossil/tofu/queue.h
@@ -138,4 +138,62 @@ bool fossil_queue_is_cnullptr(const fossil_queue_t* queue);
 }
 #endif
 
+#ifdef __cplusplus
+namespace fossil {
+    class Queue {
+    public:
+        Queue(char* type) : queue_(fossil_queue_create(type)) {}
+
+        ~Queue() {
+            fossil_queue_erase(queue_);
+        }
+
+        void insert(fossil_tofu_t data) {
+            fossil_queue_insert(queue_, data);
+        }
+
+        fossil_tofu_t remove() {
+            fossil_tofu_t data;
+            fossil_queue_remove(queue_, &data);
+            return data;
+        }
+
+        bool search(fossil_tofu_t data) {
+            return fossil_queue_search(queue_, data) == 0;
+        }
+
+        size_t size() {
+            return fossil_queue_size(queue_);
+        }
+
+        fossil_tofu_t* getter(fossil_tofu_t data) {
+            return fossil_queue_getter(queue_, data);
+        }
+
+        void setter(fossil_tofu_t data) {
+            fossil_queue_setter(queue_, data);
+        }
+
+        bool not_empty() {
+            return fossil_queue_not_empty(queue_);
+        }
+
+        bool not_cnullptr() {
+            return fossil_queue_not_cnullptr(queue_);
+        }
+
+        bool is_empty() {
+            return fossil_queue_is_empty(queue_);
+        }
+
+        bool is_cnullptr() {
+            return fossil_queue_is_cnullptr(queue_);
+        }
+
+    private:
+        fossil_queue_t* queue_;
+    };
+}
+#endif
+
 #endif /* FOSSIL_TOFU_FRAMEWORK_H */
diff --git a/code/logic/fossil/tofu/setof.h b/code/logic/fossil/tofu/setof.h
index 6f56efc..ed02b1c 100644
--- a/code/logic/fossil/tofu/setof.h
+++ b/code/logic/fossil/tofu/setof.h
@@ -146,4 +146,64 @@ int32_t fossil_set_contains(const fossil_set_t* set, fossil_tofu_t data);
 }
 #endif
 
+#ifdef __cplusplus
+namespace fossil {
+    class Set {
+    public:
+        Set(char* type) : set_(fossil_set_create(type)) {}
+
+        ~Set() {
+            fossil_set_erase(set_);
+        }
+
+        void insert(fossil_tofu_t data) {
+            fossil_set_insert(set_, data);
+        }
+
+        void remove(fossil_tofu_t data) {
+            fossil_set_remove(set_, data);
+        }
+
+        int search(fossil_tofu_t data) {
+            return fossil_set_search(set_, data);
+        }
+
+        size_t size() {
+            return fossil_set_size(set_);
+        }
+
+        fossil_tofu_t* getter(fossil_tofu_t data) {
+            return fossil_set_getter(set_, data);
+        }
+
+        void setter(fossil_tofu_t data) {
+            fossil_set_setter(set_, data);
+        }
+
+        bool not_empty() {
+            return fossil_set_not_empty(set_);
+        }
+
+        bool not_cnullptr() {
+            return fossil_set_not_cnullptr(set_);
+        }
+
+        bool is_empty() {
+            return fossil_set_is_empty(set_);
+        }
+
+        bool is_cnullptr() {
+            return fossil_set_is_cnullptr(set_);
+        }
+
+        bool contains(fossil_tofu_t data) {
+            return fossil_set_contains(set_, data);
+        }
+
+    private:
+        fossil_set_t* set_;
+    };
+}
+#endif
+
 #endif /* FOSSIL_TOFU_FRAMEWORK_H */
diff --git a/code/logic/fossil/tofu/stack.h b/code/logic/fossil/tofu/stack.h
index 3beb4a2..107cb61 100644
--- a/code/logic/fossil/tofu/stack.h
+++ b/code/logic/fossil/tofu/stack.h
@@ -145,4 +145,66 @@ fossil_tofu_t fossil_stack_top(fossil_stack_t* stack, fossil_tofu_t default_valu
 }
 #endif
 
+#ifdef __cplusplus
+namespace fossil {
+    class Stack {
+    public:
+        Stack(char* type) : stack_(fossil_stack_create(type)) {}
+
+        ~Stack() {
+            fossil_stack_erase(stack_);
+        }
+
+        void insert(fossil_tofu_t data) {
+            fossil_stack_insert(stack_, data);
+        }
+
+        fossil_tofu_t remove() {
+            fossil_tofu_t data;
+            fossil_stack_remove(stack_, &data);
+            return data;
+        }
+
+        bool search(fossil_tofu_t data) {
+            return fossil_stack_search(stack_, data) == 0;
+        }
+
+        size_t size() {
+            return fossil_stack_size(stack_);
+        }
+
+        fossil_tofu_t* getter(fossil_tofu_t data) {
+            return fossil_stack_getter(stack_, data);
+        }
+
+        void setter(fossil_tofu_t data) {
+            fossil_stack_setter(stack_, data);
+        }
+
+        bool not_empty() {
+            return fossil_stack_not_empty(stack_);
+        }
+
+        bool not_cnullptr() {
+            return fossil_stack_not_cnullptr(stack_);
+        }
+
+        bool is_empty() {
+            return fossil_stack_is_empty(stack_);
+        }
+
+        bool is_cnullptr() {
+            return fossil_stack_is_cnullptr(stack_);
+        }
+
+        fossil_tofu_t top(fossil_tofu_t default_value) {
+            return fossil_stack_top(stack_, default_value);
+        }
+
+    private:
+        fossil_stack_t* stack_;
+    };
+}
+#endif
+
 #endif /* FOSSIL_TOFU_FRAMEWORK_H */
diff --git a/code/logic/fossil/tofu/tofu.h b/code/logic/fossil/tofu/tofu.h
index 6c22357..ead3fcc 100644
--- a/code/logic/fossil/tofu/tofu.h
+++ b/code/logic/fossil/tofu/tofu.h
@@ -149,6 +149,14 @@ void fossil_tofu_print(fossil_tofu_t tofu);
  */
 void fossil_tofu_erase(fossil_tofu_t *tofu);
 
+/**
+ * Utility function to check if a given type is valid.
+ *
+ * @param type The type string to be checked.
+ * @return `true` if the type is valid, `false` otherwise.
+ */
+bool fossil_tofu_is_valid_type(const char *type);
+
 /**
  * Utility function to convert a `fossil_tofu_t` object's type to a string representation.
  *
diff --git a/code/logic/fossil/tofu/vector.h b/code/logic/fossil/tofu/vector.h
index b910ed0..5c126f8 100644
--- a/code/logic/fossil/tofu/vector.h
+++ b/code/logic/fossil/tofu/vector.h
@@ -138,4 +138,64 @@ void fossil_vector_peek(const fossil_vector_t* vector);
 }
 #endif
 
+#ifdef __cplusplus
+namespace fossil {
+    class Vector {
+    public:
+        Vector(char* type) : vector_(fossil_vector_create(type)) {}
+
+        ~Vector() {
+            fossil_vector_erase(vector_);
+        }
+
+        void push_back(fossil_tofu_t element) {
+            fossil_vector_push_back(vector_, element);
+        }
+
+        int search(fossil_tofu_t target) {
+            return fossil_vector_search(vector_, target);
+        }
+
+        void reverse() {
+            fossil_vector_reverse(vector_);
+        }
+
+        bool is_cnullptr() {
+            return fossil_vector_is_cnullptr(vector_);
+        }
+
+        bool not_cnullptr() {
+            return fossil_vector_not_cnullptr(vector_);
+        }
+
+        bool is_empty() {
+            return fossil_vector_is_empty(vector_);
+        }
+
+        bool not_empty() {
+            return fossil_vector_not_empty(vector_);
+        }
+
+        void setter(size_t index, fossil_tofu_t element) {
+            fossil_vector_setter(vector_, index, element);
+        }
+
+        fossil_tofu_t* getter(size_t index) {
+            return fossil_vector_getter(vector_, index);
+        }
+
+        size_t size() {
+            return fossil_vector_size(vector_);
+        }
+
+        void peek() {
+            fossil_vector_peek(vector_);
+        }
+
+    private:
+        fossil_vector_t* vector_;
+    };
+}
+#endif
+
 #endif /* FOSSIL_TOFU_FRAMEWORK_H */

From 02b4d1fdd0dc3a74596e93f8d19955e25efbc30a Mon Sep 17 00:00:00 2001
From: "Michael Gene Brockus (Dreamer)" <michaelbrockus@gmail.com>
Date: Thu, 10 Oct 2024 09:24:41 -0600
Subject: [PATCH 2/7] add type check utility function

---
 code/logic/tofu.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/code/logic/tofu.c b/code/logic/tofu.c
index 2d93696..f549e7a 100644
--- a/code/logic/tofu.c
+++ b/code/logic/tofu.c
@@ -134,6 +134,17 @@ fossil_tofu_type_t string_to_tofu_type(const char *str) {
     return FOSSIL_TOFU_TYPE_GHOST; // Default to ghost type if not found
 }
 
+// Helper function to check if a type is valid.
+bool fossil_tofu_is_valid_type(const char *type) {
+    size_t num_types = sizeof(tofu_type_strings) / sizeof(tofu_type_strings[0]);
+    for (size_t i = 0; i < num_types; i++) {
+        if (strcmp(type, tofu_type_strings[i]) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
 // Function to create fossil_tofu_t based on type and value strings with validation checks
 fossil_tofu_t fossil_tofu_create(char *type, char *value) {
     fossil_tofu_type_t tofu_type = string_to_tofu_type(type);

From b9bcbc3e245d62ca9310d9cdc720f487e10f2e82 Mon Sep 17 00:00:00 2001
From: "Michael Gene Brockus (Dreamer)" <michaelbrockus@gmail.com>
Date: Thu, 10 Oct 2024 09:26:10 -0600
Subject: [PATCH 3/7] update tests

---
 code/tests/test_mapof.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/code/tests/test_mapof.c b/code/tests/test_mapof.c
index 8414a38..db92d3a 100644
--- a/code/tests/test_mapof.c
+++ b/code/tests/test_mapof.c
@@ -34,13 +34,13 @@
 // * * * * * * * * * * * * * * * * * * * * * * * *
 
 FOSSIL_TEST(test_fossil_tofu_mapof_create) {
-    fossil_tofu_mapof_t map = fossil_tofu_mapof_create(2);
+    fossil_tofu_mapof_t map = fossil_tofu_mapof_create("int");
     ASSUME_ITS_EQUAL_I32(0, fossil_tofu_mapof_size(&map));
     fossil_tofu_mapof_erase(&map);
 }
 
 FOSSIL_TEST(test_fossil_tofu_mapof_add_and_get) {
-    fossil_tofu_mapof_t map = fossil_tofu_mapof_create(2);
+    fossil_tofu_mapof_t map = fossil_tofu_mapof_create("int");
     fossil_tofu_t key = fossil_tofu_create("int", "1");
     fossil_tofu_t value = fossil_tofu_create("int", "100");
     fossil_tofu_mapof_add(&map, key, value);
@@ -50,7 +50,7 @@ FOSSIL_TEST(test_fossil_tofu_mapof_add_and_get) {
 }
 
 FOSSIL_TEST(test_fossil_tofu_mapof_contains) {
-    fossil_tofu_mapof_t map = fossil_tofu_mapof_create(2);
+    fossil_tofu_mapof_t map = fossil_tofu_mapof_create("int");
     fossil_tofu_t key = fossil_tofu_create("int", "1");
     fossil_tofu_t value = fossil_tofu_create("int", "100");
     fossil_tofu_mapof_add(&map, key, value);
@@ -59,7 +59,7 @@ FOSSIL_TEST(test_fossil_tofu_mapof_contains) {
 }
 
 FOSSIL_TEST(test_fossil_tofu_mapof_remove) {
-    fossil_tofu_mapof_t map = fossil_tofu_mapof_create(2);
+    fossil_tofu_mapof_t map = fossil_tofu_mapof_create("int");
     fossil_tofu_t key = fossil_tofu_create("int", "1");
     fossil_tofu_t value = fossil_tofu_create("int", "100");
     fossil_tofu_mapof_add(&map, key, value);
@@ -69,7 +69,7 @@ FOSSIL_TEST(test_fossil_tofu_mapof_remove) {
 }
 
 FOSSIL_TEST(test_fossil_tofu_mapof_size) {
-    fossil_tofu_mapof_t map = fossil_tofu_mapof_create(2);
+    fossil_tofu_mapof_t map = fossil_tofu_mapof_create("int");
     fossil_tofu_t key1 = fossil_tofu_create("int", "1");
     fossil_tofu_t value1 = fossil_tofu_create("int", "100");
     fossil_tofu_t key2 = fossil_tofu_create("int", "2");
@@ -81,7 +81,7 @@ FOSSIL_TEST(test_fossil_tofu_mapof_size) {
 }
 
 FOSSIL_TEST(test_fossil_tofu_mapof_is_empty) {
-    fossil_tofu_mapof_t map = fossil_tofu_mapof_create(2);
+    fossil_tofu_mapof_t map = fossil_tofu_mapof_create("int");
     ASSUME_ITS_TRUE(fossil_tofu_mapof_is_empty(&map));
     fossil_tofu_t key = fossil_tofu_create("int", "1");
     fossil_tofu_t value = fossil_tofu_create("int", "100");
@@ -91,7 +91,7 @@ FOSSIL_TEST(test_fossil_tofu_mapof_is_empty) {
 }
 
 FOSSIL_TEST(test_fossil_tofu_mapof_clear) {
-    fossil_tofu_mapof_t map = fossil_tofu_mapof_create(2);
+    fossil_tofu_mapof_t map = fossil_tofu_mapof_create("int");
     fossil_tofu_t key = fossil_tofu_create("int", "1");
     fossil_tofu_t value = fossil_tofu_create("int", "100");
     fossil_tofu_mapof_add(&map, key, value);

From cedba392074ea57915427e1b59ea9a3575ec08e4 Mon Sep 17 00:00:00 2001
From: "Michael Gene Brockus (Dreamer)" <michaelbrockus@gmail.com>
Date: Thu, 10 Oct 2024 09:27:11 -0600
Subject: [PATCH 4/7] update mapof to use string param and dynamic capacity.

---
 code/logic/mapof.c | 28 +++++++++++++++++++++++-----
 1 file changed, 23 insertions(+), 5 deletions(-)

diff --git a/code/logic/mapof.c b/code/logic/mapof.c
index 01def6c..38a3e5c 100644
--- a/code/logic/mapof.c
+++ b/code/logic/mapof.c
@@ -16,13 +16,31 @@
 #include <stdlib.h>
 #include <string.h>
 
-// Function to create a new map with a given capacity
-fossil_tofu_mapof_t fossil_tofu_mapof_create(size_t capacity) {
+// Function to create a new map with a given type instead of capacity
+fossil_tofu_mapof_t fossil_tofu_mapof_create(const char *type) {
     fossil_tofu_mapof_t map;
-    map.keys = (fossil_tofu_t *)fossil_tofu_alloc(capacity * sizeof(fossil_tofu_t));
-    map.values = (fossil_tofu_t *)fossil_tofu_alloc(capacity * sizeof(fossil_tofu_t));
+
+    // Validate if the provided type is supported
+    if (!fossil_tofu_is_valid_type(type)) {
+        fprintf(stderr, "Error: Invalid type '%s' for map creation.\n", type);
+        exit(EXIT_FAILURE);
+    }
+
+    // Assign an initial capacity based on type
+    if (strcmp(type, "int") == 0 || strcmp(type, "uint") == 0) {
+        map.capacity = 10;
+    } else if (strcmp(type, "cstr") == 0 || strcmp(type, "bstr") == 0 || strcmp(type, "wstr") == 0) {
+        map.capacity = 20;
+    } else if (strcmp(type, "float") == 0 || strcmp(type, "double") == 0) {
+        map.capacity = 15;
+    } else {
+        map.capacity = 5;
+    }
+
+    map.keys = (fossil_tofu_t *)fossil_tofu_alloc(map.capacity * sizeof(fossil_tofu_t));
+    map.values = (fossil_tofu_t *)fossil_tofu_alloc(map.capacity * sizeof(fossil_tofu_t));
     map.size = 0;
-    map.capacity = capacity;
+
     return map;
 }
 

From 24fdc2bde253b4f82b73316b126a3b3128cfdab7 Mon Sep 17 00:00:00 2001
From: "Michael Gene Brockus (Dreamer)" <michaelbrockus@gmail.com>
Date: Thu, 10 Oct 2024 09:34:41 -0600
Subject: [PATCH 5/7] add new method to ToFu

---
 code/logic/fossil/tofu/tofu.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/code/logic/fossil/tofu/tofu.h b/code/logic/fossil/tofu/tofu.h
index ead3fcc..3b55e82 100644
--- a/code/logic/fossil/tofu/tofu.h
+++ b/code/logic/fossil/tofu/tofu.h
@@ -414,6 +414,10 @@ namespace fossil {
         fossil_tofu_erase(tofu);
     }
 
+    bool is_valid_type(const char *type) {
+        return fossil_tofu_is_valid_type(type);
+    }
+
     const char* type_to_string(fossil_tofu_type_t type) {
         return fossil_tofu_type_to_string(type);
     }

From f959ed89af05fc658d274f74996e0bc8e11b5c9b Mon Sep 17 00:00:00 2001
From: "Michael Gene Brockus (Dreamer)" <michaelbrockus@gmail.com>
Date: Thu, 10 Oct 2024 09:46:48 -0600
Subject: [PATCH 6/7] use STL string for class interfaces

---
 code/logic/fossil/tofu/arrayof.h     | 5 ++++-
 code/logic/fossil/tofu/doublylist.h  | 5 ++++-
 code/logic/fossil/tofu/dqueue.h      | 5 ++++-
 code/logic/fossil/tofu/forwardlist.h | 5 ++++-
 code/logic/fossil/tofu/mapof.h       | 5 ++++-
 code/logic/fossil/tofu/pqueue.h      | 5 ++++-
 code/logic/fossil/tofu/queue.h       | 5 ++++-
 code/logic/fossil/tofu/setof.h       | 5 ++++-
 code/logic/fossil/tofu/stack.h       | 5 ++++-
 code/logic/fossil/tofu/vector.h      | 5 ++++-
 10 files changed, 40 insertions(+), 10 deletions(-)

diff --git a/code/logic/fossil/tofu/arrayof.h b/code/logic/fossil/tofu/arrayof.h
index 3fe1f40..b47b5e6 100644
--- a/code/logic/fossil/tofu/arrayof.h
+++ b/code/logic/fossil/tofu/arrayof.h
@@ -97,10 +97,13 @@ void fossil_tofu_arrayof_print(const fossil_tofu_arrayof_t *arrayof);
 #endif
 
 #ifdef __cplusplus
+
+#include <string>
+
 namespace fossil {
     class ArrayOf {
     public:
-        ArrayOf(char* type, size_t size, ...) : arrayof_(fossil_tofu_arrayof_create(type, size)) {}
+        ArrayOf(const std::string& type, size_t size, ...) : arrayof_(fossil_tofu_arrayof_create(const_cast<char*>(type.c_str()), size)) {}
 
         ~ArrayOf() {
             fossil_tofu_arrayof_erase(arrayof_);
diff --git a/code/logic/fossil/tofu/doublylist.h b/code/logic/fossil/tofu/doublylist.h
index 1414aff..c1c8a9c 100644
--- a/code/logic/fossil/tofu/doublylist.h
+++ b/code/logic/fossil/tofu/doublylist.h
@@ -154,10 +154,13 @@ bool fossil_dlist_is_cnullptr(const fossil_dlist_t* dlist);
 #endif
 
 #ifdef __cplusplus
+
+#include <string>
+
 namespace fossil {
     class DoublyList {
     public:
-        DoublyList(char* type) : dlist_(fossil_dlist_create(type)) {}
+        DoublyList(const std::string& type) : dlist_(fossil_dlist_create(const_cast<char*>(type.c_str()))) {}
 
         ~DoublyList() {
             fossil_dlist_erase(dlist_);
diff --git a/code/logic/fossil/tofu/dqueue.h b/code/logic/fossil/tofu/dqueue.h
index 238e347..d120c19 100644
--- a/code/logic/fossil/tofu/dqueue.h
+++ b/code/logic/fossil/tofu/dqueue.h
@@ -140,10 +140,13 @@ bool fossil_dqueue_is_cnullptr(const fossil_dqueue_t* dqueue);
 #endif
 
 #ifdef __cplusplus
+
+#include <string>
+
 namespace fossil {
     class DQueue {
     public:
-        DQueue(char* type) : dqueue_(fossil_dqueue_create(type)) {}
+        DQueue(const std::string& type) : dqueue_(fossil_dqueue_create(const_cast<char*>(type.c_str()))) {}
 
         ~DQueue() {
             fossil_dqueue_erase(dqueue_);
diff --git a/code/logic/fossil/tofu/forwardlist.h b/code/logic/fossil/tofu/forwardlist.h
index 846082f..2205799 100644
--- a/code/logic/fossil/tofu/forwardlist.h
+++ b/code/logic/fossil/tofu/forwardlist.h
@@ -152,10 +152,13 @@ bool fossil_flist_is_cnullptr(const fossil_flist_t* flist);
 #endif
 
 #ifdef __cplusplus
+
+#include <string>
+
 namespace fossil {
     class ForwardList {
     public:
-        ForwardList(char* type) : flist_(fossil_flist_create(type)) {}
+        ForwardList(const std::string& type) : flist_(fossil_flist_create(const_cast<char*>(type.c_str()))) {}
 
         ~ForwardList() {
             fossil_flist_erase(flist_);
diff --git a/code/logic/fossil/tofu/mapof.h b/code/logic/fossil/tofu/mapof.h
index 6055d6b..957e2df 100644
--- a/code/logic/fossil/tofu/mapof.h
+++ b/code/logic/fossil/tofu/mapof.h
@@ -114,10 +114,13 @@ void fossil_tofu_mapof_print(fossil_tofu_mapof_t *map);
 #endif
 
 #ifdef __cplusplus
+
+#include <string>
+
 namespace fossil {
     class Map {
     public:
-        Map(char *type) : map_(fossil_tofu_mapof_create(type)) {}
+        Map(const std::string &type) : map_(fossil_tofu_mapof_create(type.c_str())) {}
 
         ~Map() {
             fossil_tofu_mapof_erase(&map_);
diff --git a/code/logic/fossil/tofu/pqueue.h b/code/logic/fossil/tofu/pqueue.h
index aada890..ab384be 100644
--- a/code/logic/fossil/tofu/pqueue.h
+++ b/code/logic/fossil/tofu/pqueue.h
@@ -142,10 +142,13 @@ bool fossil_pqueue_is_cnullptr(const fossil_pqueue_t* pqueue);
 #endif
 
 #ifdef __cplusplus
+
+#include <string>
+
 namespace fossil {
     class PQueue {
     public:
-        PQueue(char* type) : pqueue_(fossil_pqueue_create(type)) {}
+        PQueue(const std::string& type) : pqueue_(fossil_pqueue_create(const_cast<char*>(type.c_str()))) {}
 
         ~PQueue() {
             fossil_pqueue_erase(pqueue_);
diff --git a/code/logic/fossil/tofu/queue.h b/code/logic/fossil/tofu/queue.h
index 72d8b69..d89d920 100644
--- a/code/logic/fossil/tofu/queue.h
+++ b/code/logic/fossil/tofu/queue.h
@@ -139,10 +139,13 @@ bool fossil_queue_is_cnullptr(const fossil_queue_t* queue);
 #endif
 
 #ifdef __cplusplus
+
+#include <string>
+
 namespace fossil {
     class Queue {
     public:
-        Queue(char* type) : queue_(fossil_queue_create(type)) {}
+        Queue(const std::string& type) : queue_(fossil_queue_create(const_cast<char*>(type.c_str()))) {}
 
         ~Queue() {
             fossil_queue_erase(queue_);
diff --git a/code/logic/fossil/tofu/setof.h b/code/logic/fossil/tofu/setof.h
index ed02b1c..13367bd 100644
--- a/code/logic/fossil/tofu/setof.h
+++ b/code/logic/fossil/tofu/setof.h
@@ -147,10 +147,13 @@ int32_t fossil_set_contains(const fossil_set_t* set, fossil_tofu_t data);
 #endif
 
 #ifdef __cplusplus
+
+#include <string>
+
 namespace fossil {
     class Set {
     public:
-        Set(char* type) : set_(fossil_set_create(type)) {}
+        Set(const std::string& type) : set_(fossil_set_create(const_cast<char*>(type.c_str()))) {}
 
         ~Set() {
             fossil_set_erase(set_);
diff --git a/code/logic/fossil/tofu/stack.h b/code/logic/fossil/tofu/stack.h
index 107cb61..a01a40b 100644
--- a/code/logic/fossil/tofu/stack.h
+++ b/code/logic/fossil/tofu/stack.h
@@ -146,10 +146,13 @@ fossil_tofu_t fossil_stack_top(fossil_stack_t* stack, fossil_tofu_t default_valu
 #endif
 
 #ifdef __cplusplus
+
+#include <string>
+
 namespace fossil {
     class Stack {
     public:
-        Stack(char* type) : stack_(fossil_stack_create(type)) {}
+        Stack(const std::string& type) : stack_(fossil_stack_create(const_cast<char*>(type.c_str()))) {}
 
         ~Stack() {
             fossil_stack_erase(stack_);
diff --git a/code/logic/fossil/tofu/vector.h b/code/logic/fossil/tofu/vector.h
index 5c126f8..a995e36 100644
--- a/code/logic/fossil/tofu/vector.h
+++ b/code/logic/fossil/tofu/vector.h
@@ -139,10 +139,13 @@ void fossil_vector_peek(const fossil_vector_t* vector);
 #endif
 
 #ifdef __cplusplus
+
+#include <string>
+
 namespace fossil {
     class Vector {
     public:
-        Vector(char* type) : vector_(fossil_vector_create(type)) {}
+        Vector(const std::string& type) : vector_(fossil_vector_create(const_cast<char*>(type.c_str()))) {}
 
         ~Vector() {
             fossil_vector_erase(vector_);

From d8cfebd43a6ad8bfb60c7c7097429be7899a2e7c Mon Sep 17 00:00:00 2001
From: "Michael Gene Brockus (Dreamer)" <michaelbrockus@gmail.com>
Date: Thu, 10 Oct 2024 09:47:21 -0600
Subject: [PATCH 7/7] 0.1.1 to 0.1.2

---
 README.md   | 2 +-
 meson.build | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index d4c3dcf..35b3ac7 100644
--- a/README.md
+++ b/README.md
@@ -64,7 +64,7 @@ Before using ToFu, ensure you have the following installed:
    # ======================
    [wrap-git]
    url = https://github.com/fossillogic/fossil-tofu.git
-   revision = v0.1.1
+   revision = v0.1.2
 
    [provide]
    fossil-tofu = fossil_tofu_dep
diff --git a/meson.build b/meson.build
index 7b2d3bf..3a66547 100644
--- a/meson.build
+++ b/meson.build
@@ -1,7 +1,7 @@
 project('Fossil ToFu', 'c', 'cpp',
     meson_version: '>=1.3.0',
     license: 'MPL-2.0',
-    version: '0.1.1',
+    version: '0.1.2',
     default_options: ['c_std=c18', 'cpp_std=c++20'])
 
 subdir('code')