reimplement the tree in c++

(mostly for testing)

vxorg.cpp

@@ -0,0 +1,134 @@
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <filesystem>
+
+/// Port of tree.py to C++
+template<class T>
+struct Tree {
+
+    // FIXME make T not require default constructability
+    struct Node {
+    protected:
+        friend Tree;
+        Node* parent = nullptr;
+        std::vector<Node*> children{};
+        T item{};
+    public:
+        ~Node() {
+            for(auto& child: children)
+                delete child;
+        }
+
+        T& data() {
+            return item;
+        }
+
+        const T& data() const {
+            return item;
+        }
+
+        bool is_leaf() const {
+            return children.size() == 0;
+        }
+
+        Node* create_leaf(const T& item) {
+            auto* node = new Node;
+            node->parent = this;
+            node->item = item;
+            children.push_back(node);
+            return node;
+        }
+
+        template<class Fn>
+        void walk(Fn&& fn) {
+            fn(this);
+            if(!is_leaf()) {
+                for(auto& child: children)
+                        child->walk(fn);
+            }
+        }
+
+        template<class Pred>
+        std::optional<Node*> find_child(Pred&& predicate) {
+            if(predicate(*this))
+                return this;
+
+            for(auto& child: children)
+                if(predicate(*child))
+                    return child;
+
+            return std::nullopt;
+        }
+
+        std::size_t parent_count() const {
+            auto* parent = this->parent;
+            auto parent_count = 0z;
+            while(parent) {
+                parent_count ++;
+                parent = parent->parent;
+            }
+            return parent_count;
+        }
+
+    };
+
+    Tree() {
+        root = new Node;
+    }
+
+    ~Tree() {
+        delete root;
+    }
+
+    // Trees are not copyable but they can move
+    Tree(const Tree&) = delete;
+    Tree(Tree&&) = default;
+
+    template<class Fn>
+    void walk(Fn&& fn) {
+        root->walk(fn);
+    }
+
+
+    Node* create_leaf(const T& item) {
+        return root->create_leaf(item);
+    }
+
+private:
+    Node* root;
+};
+
+void test_tree() {
+    Tree<std::string> tree;
+
+    auto* virus = tree.create_leaf("Virus");
+    auto* worm = tree.create_leaf("Worm");
+
+    auto* test = virus->create_leaf("test");
+
+    test->create_leaf("a");
+    test->create_leaf("b");
+    test->create_leaf("c");
+    test->create_leaf("884");
+
+    tree.walk([](auto* node) {
+        auto tab_count = node->parent_count();
+        auto& data = node->data();
+
+        for(auto i = 0; i < tab_count; ++i)
+                std::printf("\t");
+
+        if(data.empty()) {
+            std::printf("(root)\n");
+        } else {
+            std::printf("%s\n", data.c_str());
+        }
+    });
+}
+
+int main() {
+    test_tree();
+    return 0;
+}