add iterators

New iterators can be used to iterate through Nodes.

Squashed commit of the following:

commit 602ed679631647dd1c8874b0b0145fcb09458341
Author: GRayHook <s@marinkevich.ru>
Date:   Fri Aug 1 19:36:46 2025 +0700

    fup after CR

commit 08f7b59aa7
Author: GRayHook <s@marinkevich.ru>
Date:   Fri Aug 1 19:20:48 2025 +0700

    normalize members of iterator

commit 038cbb73f4
Author: GRayHook <s@marinkevich.ru>
Date:   Fri Aug 1 18:57:08 2025 +0700

    bump

commit 0f93988fb6
Author: GRayHook <s@marinkevich.ru>
Date:   Fri Aug 1 11:32:35 2025 +0700

    tmp

BFSIterator.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "iterators/BaseIterator.h"
+
+template <typename T>
+struct IteratorForward : public BaseIterator<T> {
+	explicit IteratorForward(T* ptr) : Iterator<T>(first(ptr)) {}
+
+	static T* first(T* node) {
+		return node;
+	}
+
+	static T* next(T* node) {
+		return node ? node->get_next() : nullptr;
+	}
+
+	Iterator<T>& operator++() override {
+		this->current = next(this->current);
+		return *this;
+	}
+};

include/ifaces/IIterator.h

@@ -0,0 +1,14 @@
+#pragma once
+
+/// \brief Интерфейс для классов-итераторов.
+/// \tparam T Тип итерируемого элемента.
+template <typename T>
+class IIterator {
+public:
+	virtual T* operator->() const = 0;
+	virtual operator const T*() const = 0;
+
+	virtual bool operator!=(const IIterator& other) const = 0;
+
+	virtual IIterator& operator++() = 0;
+};

include/ifaces/ILinkMixin.h

@@ -14,5 +14,6 @@ public:
 	virtual void linkChild(const ElemPtr& child) = 0;
 	virtual void unlinkParent() = 0;
 	virtual const std::vector<ElemPtr>& children() = 0;
+	virtual ElemPtr parent() = 0;
 	virtual LinkPtr getLink() = 0;
 };

include/iterators/BFSIterator.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <queue>
+
+#include "iterators/BaseIterator.h"
+
+template <typename T>
+class BFSIterator : public BaseIterator<T> {
+public:
+	explicit BFSIterator(T* ptr) : BaseIterator<T>(ptr) {
+		if (!this->current())
+			return;
+
+		for (auto& it : this->current()->children())
+			q.push({it.get(), 1});
+	}
+
+	IIterator<T>& operator++() override {
+		advance();
+		return *this;
+	}
+
+protected:
+	std::queue<std::pair<T*, size_t>> q;
+
+	void advance() {
+		if (q.empty()) {
+			this->set_current(nullptr);
+			return;
+		}
+
+		auto& [node, lvl] = q.front();
+		q.pop();
+
+		this->set_current(node);
+		this->set_level(lvl);
+
+		for (auto& it : this->current()->children())
+			q.push({it.get(), lvl + 1});
+	}
+};

include/iterators/BaseIterator.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "ifaces/IIterator.h"
+
+/// \brief Базовый итератор.
+/// \tparam T Тип итерируемого элемента.
+/// Предоставляет базовую реализацию методов для работы с итерируемыми объектами.
+/// Возвращает объект-прокси, мимикрирующий под итерируемый элемент. Позволяет использовать
+/// распаковку структуры для получения уровня элемента в поддереве.
+template <typename T>
+class BaseIterator : public IIterator<T> {
+public:
+	explicit BaseIterator(T* ptr) : proxy{ptr, 0} {}
+
+	struct Proxy {
+		T* e;
+		size_t level;
+
+		T& operator*() const { return *e; }
+		T* operator->() const { return e; }
+	};
+	Proxy& operator*() { return proxy; }
+
+	T* operator->() const override { return current(); }
+	operator const T*() const { return current(); }
+	operator T&() const { return *current(); }
+	operator T*() const { return current(); }
+
+	bool operator!=(const IIterator<T>& other) const override {
+		const T* other_current = other;
+		return current() != other_current;
+	}
+
+protected:
+	T* current() const { return proxy.e; }
+	void set_current(T* e) { proxy.e = e; }
+
+	size_t level() const { return proxy.level; }
+	void set_level(size_t level) { proxy.level = level; }
+private:
+	Proxy proxy;
+};

include/iterators/DFSIterator.h

@@ -0,0 +1,43 @@
+#pragma once
+#include <stack>
+#include <iterator>
+
+#include "iterators/BaseIterator.h"
+
+template <typename T>
+class DFSIterator : public BaseIterator<T> {
+public:
+	explicit DFSIterator(T* ptr) : BaseIterator<T>(ptr) {
+		if (!this->current())
+			return;
+
+		for (auto it = this->current()->children().rbegin();
+		     it != this->current()->children().rend(); ++it)
+			s.push({it->get(), 1});
+	}
+
+	IIterator<T>& operator++() override {
+		advance();
+		return *this;
+	}
+
+protected:
+	std::stack<std::pair<T*, size_t>> s;
+
+	void advance() {
+		if (s.empty()) {
+			this->set_current(nullptr);
+			return;
+		}
+
+		auto [node, lvl] = s.top();
+		s.pop();
+
+		this->set_current(node);
+		this->set_level(lvl);
+
+		for (auto it = this->current()->children().rbegin();
+		     it != this->current()->children().rend(); ++it)
+			s.push({it->get(), lvl + 1});
+	}
+};

include/iterators/Traversal.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "ifaces/INode.h"
+
+#include "iterators/DFSIterator.h"
+#include "iterators/BFSIterator.h"
+
+namespace traversal {
+	/// \brief Фабрика итераторов узлов дерева.
+	/// \tparam T Тип алгоритма для обхода дерева.
+	/// Конструирует итерируемый объект с заданным алгоритмом обхода. Например, в ширину
+	/// или глубину.
+	template<typename Policy>
+	class Traversal {
+		INode* start;
+
+	public:
+		explicit Traversal(INode* start) : start(start) {}
+		explicit Traversal(NodePtr start) : start(start.get()) {}
+
+		Policy begin() const { return Policy(start); }
+		Policy end() const { return Policy(nullptr); }
+	};
+
+	using DFS = Traversal<DFSIterator<INode>>;
+	using BFS = Traversal<BFSIterator<INode>>;
+}

include/mixins/BaseLinkMixin.h

@@ -37,6 +37,13 @@ public:
 		getLink()->setParent(nullptr);
 	}
 
+	ElemPtr parent() override {
+		auto link = getLink();
+
+		ElemPtr parent = link->getParent();
+
+		return parent;
+	}
 
 	const std::vector<ElemPtr>& children() override {
 		auto link = getLink();

src/main.cpp

@@ -1,19 +1,29 @@
-#include "nodes/SimpleNode.h"
-#include "nodes/ComplexNode.h"
 #include <iostream>
+
 #include "Logger.h"
 
-void printTree(const NodePtr& node, int indent = 0) {
+#include "nodes/SimpleNode.h"
-	if (!node) {
+#include "nodes/ComplexNode.h"
-		Logger::get("MAIN").err("No node");
+#include "iterators/Traversal.h"
-		return;
+
-	}
 
-	for (int i = 0; i < indent; ++i) std::cout << "  ";
+void printNode(INode& node, size_t level) {
-	std::cout << node->name() << "\n";
+	for (size_t i = level; i > 0; i--)
+		std::cout << "  ";
+	std::cout << node.name() << "\n";
+}
 
-	for (const auto& child : node->children())
+void printTreeBFS(INode& node) {
-		printTree(child, indent + 1);
+	for (auto& child : traversal::BFS(&node))
+		printNode(*child, 0);
+}
+void printTreeList(INode& node) {
+	for (auto& child : traversal::DFS(&node))
+		printNode(*child, 0);
+}
+void printTreeLadder(INode& node) {
+	for (auto& [child, level] : traversal::DFS(&node))
+		printNode(*child, level);
 }
 
 int main() {
@@ -31,7 +41,7 @@ int main() {
 		root->linkChild(child1);
 
 		std::cout << "\nInit tree:\n";
-		printTree(root);
+		printTreeLadder(*root);
 		std::cout << "\n";
 
 		{
@@ -83,21 +93,29 @@ int main() {
 			}
 
 			std::cout << "\nAnother tree:\n";
-			printTree(root);
+			printTreeLadder(*root);
+			std::cout << "\n";
+
+			std::cout << "\nList:\n";
+			printTreeList(*root);
+			std::cout << "\n";
+
+			std::cout << "\nBFS:\n";
+			printTreeBFS(*root);
 			std::cout << "\n";
 
 			logger.info("Unlinking ComplexChild2...\n");
 			child2->unlinkParent();
 
 			std::cout << "\nTree after unlink:\n";
-			printTree(root);
+			printTreeLadder(*root);
 			std::cout << "\n";
 
 			logger.info("Put refs of ComplexChild2, ComplexChild3 and its children");
 		}
 
 		std::cout << "\nTree after scope out:\n";
-		printTree(root);
+		printTreeLadder(*root);
 		std::cout << "\n";
 
 		logger.info("Unlinking ComplexChild1 and ComplexChild3...\n");
@@ -114,7 +132,7 @@ int main() {
 		root->linkChild(child4);
 
 		std::cout << "\nTree flush and link SimpleChild4:\n";
-		printTree(root);
+		printTreeLadder(*root);
 		std::cout << "\n";
 	}