combine functions for statements part done

include/name_tree.hpp

@@ -1,7 +1,11 @@
 #pragma once
 
+#include "statement_nodes.hpp"
 #include "tree_sitter_wrapper.hpp"
 
+#include <cstddef>
+#include <optional>
+#include <unordered_map>
 #include <vector>
 
 namespace names {
@@ -9,72 +13,85 @@ namespace names {
 // IN PROGRESS
 class NameTree {
 public:
-  struct Node {};
+  NameTree() {
+    nodes_.emplace_back(); // root
+  }
 
-  NameTree() {}
+  bool insert(const std::string &path, nodes::Statement &&statement);
 
-  bool insert_path(const std::vector<std::string> &path, Node node) {}
+  std::optional<nodes::Statement *> find(const std::string &path);
+
+  std::optional<const nodes::Statement *> find(const std::string &path) const;
 
 private:
+  struct Node {
+  public:
+    std::optional<nodes::Statement *> get_statement() {
+      if (statement_.has_value()) {
+        return &statement_.value();
+      }
+      return std::nullopt;
+    }
+
+    std::optional<const nodes::Statement *> get_statement() const {
+      if (statement_.has_value()) {
+        return &statement_.value();
+      }
+      return std::nullopt;
+    }
+
+    bool set_statement(nodes::Statement &&statement) {
+      if (statement_.has_value()) {
+        return false;
+      }
+      statement_ = std::move(statement);
+      return true;
+    }
+
+    std::optional<size_t> find(size_t name_id) const {
+      auto name_iter = children_.find(name_id);
+
+      if (name_iter == children_.end()) {
+        return std::nullopt;
+      }
+
+      return name_iter->second;
+    }
+
+    bool insert(size_t name_id, size_t node_id) {
+      if (children_.count(name_id) != 0) {
+        return false;
+      }
+      children_[name_id] = node_id;
+      return true;
+    }
+
+  private:
+    std::unordered_map<size_t, size_t> children_;
+    std::optional<nodes::Statement> statement_;
+  };
+
+  size_t get_root() const { return 0; }
+
+  size_t add_node(size_t current_node, const std::vector<size_t> &name_ids,
+                  size_t current_name = 0);
+
+  std::optional<size_t> find_node(size_t current_node,
+                                  const std::vector<size_t> &name_ids,
+                                  size_t current_name = 0) const;
+
+  std::vector<size_t> slice_path_to_name_ids(const std::string &path);
+
+  std::optional<std::vector<size_t>>
+  slice_path_to_existing_name_ids(const std::string &path) const;
+
+  size_t add_name_id(const std::string &name);
+
+  std::optional<size_t> find_name_id(const std::string &name) const;
+
+private:
+  std::unordered_map<std::string, size_t> name_to_id_;
+  std::vector<Node> nodes_;
 };
 
-class NameStorage;
-
-class NameProxy {
-  friend NameStorage;
-
-public:
-  NameProxy(NameStorage *name_storage, size_t id)
-      : name_storage_(name_storage), id_(id) {}
-
-  std::string *get();
-
-  const std::string *get() const;
-
-  bool operator==(const NameProxy &other) const {
-    return name_storage_ == other.name_storage_ && id_ == other.id_;
-  }
-
-  bool operator<(const NameProxy &other) const {
-    return name_storage_ < other.name_storage_ ||
-           (name_storage_ == other.name_storage_ && id_ < other.id_);
-  }
-
-private:
-  NameStorage *name_storage_;
-  size_t id_;
-};
-
-class NameStorage {
-  friend NameProxy;
-
-public:
-  NameProxy add_expression(const std::string &name) {
-    storage_.push_back(name);
-    return NameProxy(this, storage_.size() - 1);
-  }
-
-  NameProxy add_expression(std::string &&name) {
-    storage_.push_back(std::move(name));
-    return NameProxy(this, storage_.size() - 1);
-  }
-
-private:
-  std::string *get_expression(size_t id) { return &storage_.at(id); }
-
-  const std::string *get_expression(size_t id) const {
-    return &storage_.at(id);
-  }
-
-private:
-  std::vector<std::string> storage_;
-};
-
-std::vector<std::string> string_to_path(const std::string &str) {
-  std::vector<std::string> path;
-  for (;;) {
-  }
-  return path;
-} // IN PROGRESS
-
 } // namespace names