Merge pull request #2 from dreamer-coding/cpp_classes

Adding C++ classes

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

code/logic/fossil/tofu/arrayof.h

@@ -96,4 +96,47 @@ void fossil_tofu_arrayof_print(const fossil_tofu_arrayof_t *arrayof);
 }
 #endif
 
+#ifdef __cplusplus
+
+#include <string>
+
+namespace fossil {
+    class ArrayOf {
+    public:
+        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_);
+        }
+
+        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 */

code/logic/fossil/tofu/doublylist.h

@@ -153,4 +153,73 @@ bool fossil_dlist_is_cnullptr(const fossil_dlist_t* dlist);
 }
 #endif
 
+#ifdef __cplusplus
+
+#include <string>
+
+namespace fossil {
+    class DoublyList {
+    public:
+        DoublyList(const std::string& type) : dlist_(fossil_dlist_create(const_cast<char*>(type.c_str()))) {}
+
+        ~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 */

code/logic/fossil/tofu/dqueue.h

@@ -139,4 +139,65 @@ bool fossil_dqueue_is_cnullptr(const fossil_dqueue_t* dqueue);
 }
 #endif
 
+#ifdef __cplusplus
+
+#include <string>
+
+namespace fossil {
+    class DQueue {
+    public:
+        DQueue(const std::string& type) : dqueue_(fossil_dqueue_create(const_cast<char*>(type.c_str()))) {}
+
+        ~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 */

code/logic/fossil/tofu/forwardlist.h

@@ -151,4 +151,73 @@ bool fossil_flist_is_cnullptr(const fossil_flist_t* flist);
 }
 #endif
 
+#ifdef __cplusplus
+
+#include <string>
+
+namespace fossil {
+    class ForwardList {
+    public:
+        ForwardList(const std::string& type) : flist_(fossil_flist_create(const_cast<char*>(type.c_str()))) {}
+
+        ~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 */

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,55 @@ void fossil_tofu_mapof_print(fossil_tofu_mapof_t *map);
 }
 #endif
 
+#ifdef __cplusplus
+
+#include <string>
+
+namespace fossil {
+    class Map {
+    public:
+        Map(const std::string &type) : map_(fossil_tofu_mapof_create(type.c_str())) {}
+
+        ~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 */