core: Tree container impl. Partially broken, fix on laptop

2 files changed, 97 insertions, 35 deletions

diff --git a/c++/core/mcts.h b/c++/core/mcts.h
index f0f3ba5..8a8f5ea 100644
--- a/c++/core/mcts.h
+++ b/c++/core/mcts.h
@@ -3,18 +3,50 @@
 #include "tree.h"
 
 namespace saw {
-template<typename State>
-struct mcts_value {
-		State state;
-};
-
-template<typename State>
+template<typename T>
 class mcts_tree {
 private:
-		/**
-		 * @todo
-		 * Basically I need to a tree with tree<mcts_value<State>> 
-		 */
+	struct value {
+		uint64_t numerater;
+		uint64_t denominater;
+		T state;
+
+		value() = default;
+		value(T st):
+			numerater{0},
+			denominater{0},
+			state{std::move(st)}
+		{}
+	};
+
+	tree_container<value, mcts_tree<T>> data_;
 public:
+	mcts_tree() = default{
+		data_.add(value{});
+	}
+
+	mcts_tree(T state){
+		data_.add(value{std::move(state)});
+	}
+
+	size_t size() const {
+		return data_.size() - 1;
+	}
+
+	T& get_state(){
+		return data_.at(0).get_value().state;
+	}
+
+	const T& get_state() const {
+		return data_.at(0).get_value().state;
+	}
+
+	mcts_tree<T>& get_tree(size_t i){
+		return data_.at(i+1).get_tree();
+	}
+
+	const mcts_tree<T>& get_tree(size_t i) const {
+		return data_.at(i+1).get_tree();
+	}
 };
 }
diff --git a/c++/core/tree.h b/c++/core/tree.h
index 32572fc..43f6c2c 100644
--- a/c++/core/tree.h
+++ b/c++/core/tree.h
@@ -19,27 +19,26 @@ class branch;
  * edge to a leaf or other nodes. A tree holds the branches while the branch either has
  * a leaf or another sub tree.
  */
-template<typename T>
-class tree final {
+template<typename T, typename Tree>
+class tree_container final {
 private:
 	/**
 	 * Object holding the treeed branch instances
 	 */
-    using branch = std::variant<T, tree<T>>;
-	std::vector<branch> children_;
+	std::vector<branch<T,Tree>> children_;
 public:
 	/**
 	 * Default constructor
 	 */
-	tree() = default;
+	tree_container() = default;
 
 	/**
 	 * Destructor
 	 */
-	~tree() = default;
+	~tree_container() = default;
 
-	SAW_FORBID_COPY(tree);
-	SAW_DEFAULT_MOVE(tree);
+	SAW_FORBID_COPY(tree_container);
+	SAW_DEFAULT_MOVE(tree_container);
 
 	/**
 	 * Reserve space for siz elements
@@ -102,36 +101,36 @@ public:
 	/**
 	 * Returns the branch at i
 	 */
-	branch& at(std::size_t i){
+	branch<T,Tree>& at(std::size_t i){
 		return children_.at(i);
 	}
 
 	/**
 	 * Returns the branch at i
 	 */
-	const branch& at(std::size_t i) const {
+	const branch<T,Tree>& at(std::size_t i) const {
 		return children_.at(i);
 	}
 };
 
-template<typename T>
+template<typename T, typename Tree>
 class branch final {
 private:
-	using type = std::variant<tree<T>,T>;
+	using type = std::variant<Tree,T>;
 	type tov_;
 
 	/**
 	 * We're friend classing the tree since it's way easier this way and the branch and tree
 	 * class are intertwined heavily anyway.
 	 */
-	friend class tree<T>;
+	friend class Tree;
 public:
 	/**
 	 * 
 	 */
-	branch():tov_{tree<T>{}}{}
+	branch():tov_{Tree{}}{}
 
-	branch(tree<T> nd):tov_{std::move(nd)}{}
+	branch(Tree nd):tov_{std::move(nd)}{}
 
 	branch(T val):tov_{std::move(val)}{}
 
@@ -144,7 +143,7 @@ public:
 	}
 
 	bool is_tree() const {
-		return std::holds_alternative<tree>(tov_);
+		return std::holds_alternative<Tree>(tov_);
 	}
 
 	bool is_value() const {
@@ -161,12 +160,12 @@ public:
 		return std::get<NT>(tov_);
 	}
 
-	tree<T>& get_tree(){
-		return std::get<tree<T>>(tov_);
+	Tree& get_tree(){
+		return std::get<Tree>(tov_);
 	}
 
-	const tree<T>& get_tree() const {
-		return std::get<tree<T>>(tov_);
+	const Tree& get_tree() const {
+		return std::get<Tree>(tov_);
 	}
 
 	T& get_value(){
@@ -179,12 +178,13 @@ public:
 
 	template<typename NT>
 	error_or<NT> extract(){
+	error_or<void> reserve(std::size_t siz){
 		if(!is<NT>()){
 			return make_error<err::invalid_state>();
 		}
 		
 		NT nd = std::move(std::get<NT>(tov_));
-		tov_ = tree<T>{};
+		tov_ = Tree{};
 
 		return nd;
 	}
@@ -201,12 +201,12 @@ public:
 		return eon;
 	}
 
-	error_or<tree<T>> extract_tree() {
-		return extract<tree<T>>();
+	error_or<Tree> extract_tree() {
+		return extract<Tree>();
 	}
 
-	error_or<tree<T>> replace_tree(type nd){
-		return replace<tree<T>>(std::move(nd));
+	error_or<Tree> replace_tree(type nd){
+		return replace<Tree>(std::move(nd));
 	}
 
 	error_or<T> extract_value() {
@@ -217,4 +217,34 @@ public:
 		return replace<T>(std::move(nd));
 	}
 };
+
+template<typename T>
+class tree {
+	private:
+		tree_container<T,tree<T>> data_;
+	public:
+		error_or<void> reserve(std::size_t size){
+			return data_.reserve(size);
+		}
+
+		size_t size() const {
+			return data_.size();
+		}
+
+		error_or<void> add() {
+			return data_.add();
+		}
+
+		error_or<void> add(T leaf){
+			return data_.add(std::move(leaf));
+		}
+
+		branch<T, tree<T>>& at(size_t i){
+			return data_.at(i);
+		}
+
+		const branch<T, tree<T>>& at(size_t i) const {
+			return data_.at(i);
+		}
+};
 }