abbandoning Lua... Error in runtime

include/collections.hpp

@@ -0,0 +1,138 @@
+#pragma once
+#include <stdexcept>
+
+
+template<typename T>
+class tree
+{
+	size_t m_CountBranches = 0;
+	tree<T>* branches = nullptr;
+public:
+	T value;
+
+	tree() = default;
+
+	~tree()
+	{
+		delete[] branches;
+		m_CountBranches = 0;
+	}
+
+	bool operator==(const tree& rhs) const
+	{
+		return branches == rhs.branches;
+	}
+
+	template<typename ...Args>
+	explicit tree(Args&&... args) : value(std::forward<Args>(args)...) {}
+
+	tree<T>& get(size_t idx)
+	{
+		if (m_CountBranches <= idx || !branches) throw std::out_of_range("Index is out of range!");
+		return branches[idx];
+	}
+
+	void set(size_t idx, const tree<T>* t)
+	{
+		if (m_CountBranches >= idx || !t || !branches) throw std::out_of_range("Index is out of range!");
+		branches[idx] = *t;
+	}
+
+	void add(const tree<T>* t)
+	{
+		tree<T>* tmp = new tree<T>[m_CountBranches + 1];
+		if (branches) {
+			memcpy(tmp, branches, sizeof(tree<T>) * m_CountBranches);
+			delete[] branches;
+		}
+		branches = tmp;
+		tmp[m_CountBranches++] = *t;
+	}
+
+	void set(size_t idx, const T& val)
+	{
+		if (m_CountBranches >= idx || !branches) throw std::out_of_range("Index is out of range!");
+		branches[idx].value = value;
+	}
+
+	template<typename ...Args>
+	void add(Args&& ...args)
+	{
+		tree<T>* tmp = new tree<T>[m_CountBranches + 1];
+		if (branches) {
+			memcpy(tmp, branches, sizeof(tree<T>) * m_CountBranches);
+			delete[] branches;
+		}
+		branches = tmp;
+		tmp[m_CountBranches++] = tree(std::forward<Args>(args)...);
+	}
+
+	size_t depth()
+	{
+		if (branches) return 1;
+		size_t res = 0;
+		for (int i = 0; i < m_CountBranches; ++i)
+		{
+			res = max(res, branches[i].depth());
+		}
+		return res + 1;
+	}
+
+	size_t width() const
+	{
+		return m_CountBranches;
+	}
+
+	tree<T>& operator[](size_t idx)
+	{
+		return get(idx);
+	}
+};
+
+template<typename T>
+struct linked_list
+{
+	linked_list<T>* next = nullptr;
+	linked_list<T>* first = nullptr;
+	T value;
+
+	linked_list() = default;
+	linked_list(T val) : value(val) {}
+	~linked_list()
+	{
+		delete next;
+	}
+
+	bool operator==(const linked_list& rhs) const
+	{
+		return
+			this->first == rhs.first &&
+			this->next == rhs.next &&
+			this->value == rhs.value;
+	}
+
+	linked_list& put(const T& val)
+	{
+		if (!next)
+		{
+			next = new linked_list<T>(val);
+			if (first)
+				next->first = first;
+			else
+				next->first = this;
+			return *next;
+		}
+		next->put(val);
+		if (first)
+			next->first = first;
+		else
+			next->first = this;
+		return *next;
+	}
+
+	size_t depth()
+	{
+		if (!next) return 1;
+		return next->depth() + 1;
+	}
+};