cleanup

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.o
+/vxorg
+/tree_test
+/testdata

tree.hpp

@@ -2,37 +2,29 @@
 #include <vector>
 
 /// Port of tree.py to C++
-template<class T>
+template <class T>
 struct Tree {
-
 	// FIXME make T not require default constructability
 	struct Node {
 	   protected:
 		friend Tree;
 		Node* parent = nullptr;
-        std::vector<Node*> children{};
+		std::vector<Node*> children {};
-        T item{};
+		T item {};
+
 	   public:
 		~Node() {
-            for(auto& child: children)
+			for(auto& child : children)
 				delete child;
 		}
 
-        T& data() {
+		T& data() { return item; }
-            return item;
-        }
 
-        const T& data() const {
+		const T& data() const { return item; }
-            return item;
-        }
 
-        bool is_leaf() const {
+		bool is_leaf() const { return children.size() == 0; }
-            return children.size() == 0;
-        }
 
-        Node* parent_node() {
+		Node* parent_node() { return parent; }
-            return parent;
-        }
 
 		Node* create_leaf(const T& item) {
 			auto* node = new Node;
@@ -42,21 +34,21 @@ struct Tree {
 			return node;
 		}
 
-        template<class Fn>
+		template <class Fn>
 		void walk(Fn&& fn) {
 			fn(this);
 			if(!is_leaf()) {
-                for(auto& child: children)
+				for(auto& child : children)
 					child->walk(fn);
 			}
 		}
 
-        template<class Pred>
+		template <class Pred>
 		Node* find_child(Pred&& predicate) {
 			if(predicate(this) == true)
 				return this;
 
-            for(auto& child: children)
+			for(auto& child : children)
 				if(predicate(child) == true)
 					return child;
 
@@ -67,40 +59,30 @@ struct Tree {
 			auto* parent = this->parent;
 			auto parent_count = 0z;
 			while(parent) {
-                parent_count ++;
+				parent_count++;
 				parent = parent->parent;
 			}
 			return parent_count;
 		}
-
 	};
 
-    Tree() {
+	Tree() { root = new Node; }
-        root = new Node;
-    }
 
-    ~Tree() {
+	~Tree() { delete root; }
-        delete root;
-    }
 
 	// Trees are not copyable but they can move
 	Tree(const Tree&) = delete;
 	Tree(Tree&&) = default;
 
-    template<class Fn>
+	template <class Fn>
 	void walk(Fn&& fn) {
 		root->walk(fn);
 	}
 
+	Node* create_leaf(const T& item) { return root->create_leaf(item); }
 
-    Node* create_leaf(const T& item) {
+	Node* root_node() { return root; }
-        return root->create_leaf(item);
-    }
 
-    Node* root_node() {
+   private:
-        return root;
-    }
-
-private:
 	Node* root;
 };

vxheaven_parse.cpp

@@ -21,6 +21,34 @@ namespace vxorg {
 		return res;
 	}
 
+	std::string get_sample_name(VxHeavenTree::Node* node) {
+		if(node == nullptr)
+			return "";
+
+		if(!node->data().is_sample)
+			return node->data().name;
+
+		std::string sample_name {};
+		std::vector<vxorg::VxHeavenItem*> parent_list {};
+		vxorg::VxHeavenTree::Node* parent = node->parent_node();
+		
+		while(parent) {
+			if(parent->data().name.empty())
+				break;
+
+			parent_list.push_back(&parent->data());
+			parent = parent->parent_node();
+		}
+
+		for(auto& item : std::views::reverse(parent_list)) {
+			sample_name += std::format("{}.", item->name);
+		}
+
+		sample_name += node->data().name;
+
+		return sample_name;
+	}
+
 	void parse_into_tree(VxHeavenTree& tree, std::istream& is) {
 		std::string line {};
 		while(std::getline(is, line)) {

vxheaven_parse.hpp

@@ -1,7 +1,8 @@
 #pragma once
-#include "tree.hpp"
 #include <string>
 
+#include "tree.hpp"
+
 namespace vxorg {
 
 	struct VxHeavenItem {
@@ -12,5 +13,7 @@ namespace vxorg {
 
 	using VxHeavenTree = Tree<VxHeavenItem>;
 
+	std::string get_sample_name(VxHeavenTree::Node* node);
+
 	void parse_into_tree(VxHeavenTree& tree, std::istream& is);
-}
+} // namespace vxorg

vxorg.cpp

@@ -1,15 +1,12 @@
 #include <filesystem>
 #include <fstream>
-#include <ranges>
 #include <string>
-#include <string_view>
-#include <vector>
 
 #include "tree.hpp"
 #include "vxheaven_parse.hpp"
 
 int main() {
-	std::ifstream ifs("./samples.sort");
+	std::ifstream ifs("./testdata/samples.sort");
 	vxorg::VxHeavenTree tree;
 
 	vxorg::parse_into_tree(tree, ifs);
@@ -26,26 +23,8 @@ int main() {
 			std::printf("(root)\n");
 		} else {
 			if(data.is_sample) {
-				std::string sample_name {};
+				std::string sample_name = vxorg::get_sample_name(node);
-
-				std::vector<vxorg::VxHeavenItem*> parent_list {};
-				vxorg::VxHeavenTree::Node* parent = node->parent_node();
-				while(parent) {
-					if(parent->data().name.empty())
-						break;
-
-					parent_list.push_back(&parent->data());
-					parent = parent->parent_node();
-				}
-
-				for(auto& item : std::views::reverse(parent_list)) {
-					sample_name += std::format("{}.", item->name);
-				}
-
-				sample_name += data.name;
-
 				std::printf("%s (sample %s)\n", data.name.c_str(), sample_name.c_str());
-
 			} else {
 				std::printf("%s\n", data.name.c_str());
 			}