normalize members of iterator

.gitignore

@@ -0,0 +1,4 @@
+*.swp
+build
+.vscode
+doc

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;
+	}
+};

CMakeLists.txt

@@ -0,0 +1,23 @@
+# CMakeLists.txt
+
+cmake_minimum_required(VERSION 3.10)
+
+project(ModernTree LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Находим все исходные файлы в директории src
+file(GLOB_RECURSE SOURCES "src/*.cpp")
+
+# Создаем исполняемый файл из исходников
+add_executable(tree_app ${SOURCES})
+
+# Указываем, что директория include является публичной для нашего проекта
+# Это позволит использовать #include "ifaces/INode.h" и т.д.
+target_include_directories(tree_app PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+# Сообщение для удобства
+message(STATUS "Project configured. To build, run: cmake --build .")
+message(STATUS "To run the application: ./tree_app")

Doxyfile

@@ -0,0 +1,20 @@
+# Doxyfile 1.9.8
+# Основной конфиг для генерации документации Doxygen
+
+PROJECT_NAME           = "links project"
+OUTPUT_DIRECTORY       = doc
+CREATE_SUBDIRS         = NO
+OUTPUT_LANGUAGE        = Russian
+INPUT                  = src include
+FILE_PATTERNS          = *.h *.cpp
+RECURSIVE              = YES
+EXTRACT_ALL            = YES
+GENERATE_LATEX         = NO
+GENERATE_HTML          = YES
+GENERATE_MAN           = NO
+GENERATE_RTF           = NO
+GENERATE_XML           = NO
+QUIET                  = NO
+WARN_IF_UNDOCUMENTED   = YES
+
+# Можно добавить дополнительные настройки по необходимости 

Makefile

@@ -0,0 +1,13 @@
+all: build run
+
+clean:
+	rm -rf build/
+
+build:
+	cmake -B build
+
+compile: build
+	cmake --build build
+
+run: compile
+	./build/tree_app

include/Logger.h

@@ -0,0 +1,92 @@
+#pragma once
+#include <string>
+#include <iostream>
+#include <unordered_map>
+#include <unordered_set>
+#include <memory>
+#include <mutex>
+
+/// \brief Класс для логирования сообщений по категориям и уровням серьезности.
+/// Позволяет вести логирование с разными уровнями и подавлять вывод по категориям.
+class Logger {
+public:
+	/// \brief Уровни серьезности сообщений для логгера.
+	enum class Severity {
+		Debug,   ///< Отладочная информация
+		Info,    ///< Информационные сообщения
+		Warning, ///< Предупреждения
+		Error    ///< Ошибки
+	};
+
+	// Получить логгер по категории (создаёт, если нет)
+	static Logger& get(const std::string& category) {
+		std::lock_guard<std::mutex> lock(registry_mutex_);
+		auto it = registry_.find(category);
+		if (it == registry_.end()) {
+			auto logger = std::unique_ptr<Logger>(new Logger(category));
+			auto [inserted_it, _] = registry_.emplace(category, std::move(logger));
+			return *(inserted_it->second);
+		}
+		return *(it->second);
+	}
+
+	// Настроить suppression для категории
+	static void suppressCategory(const std::string& category) {
+		get(category).suppressed_ = true;
+	}
+	static void unsuppressCategory(const std::string& category) {
+		get(category).suppressed_ = false;
+	}
+	static void setMinSeverity(const std::string& category, Severity level) {
+		get(category).min_severity_ = level;
+	}
+	static Severity getMinSeverity(const std::string& category) {
+		return get(category).min_severity_;
+	}
+	static bool isSuppressed(const std::string& category) {
+		return get(category).suppressed_;
+	}
+
+	void log(const std::string& message, Severity severity = Severity::Info) const {
+		if (suppressed_) return;
+		if (severity < min_severity_) return;
+		std::cout << "[" << category_ << "] " << severityToString(severity) << ": " << message << std::endl << std::flush;
+	}
+
+	// Удобные методы для логирования по уровню
+	void dbg(const std::string& message) const { log(message, Severity::Debug); }
+	void info(const std::string& message) const { log(message, Severity::Info); }
+	void warn(const std::string& message) const { log(message, Severity::Warning); }
+	void err(const std::string& message) const { log(message, Severity::Error); }
+
+	static std::string severityToString(Severity severity) {
+		switch (severity) {
+			case Severity::Debug: return "DEBUG";
+			case Severity::Info: return "INFO";
+			case Severity::Warning: return "WARNING";
+			case Severity::Error: return "ERROR";
+			default: return "UNKNOWN";
+		}
+	}
+
+	const std::string& category() const { return category_; }
+	Severity minSeverity() const { return min_severity_; }
+	void setMinSeverity(Severity s) { min_severity_ = s; }
+	bool suppressed() const { return suppressed_; }
+	void setSuppressed(bool s) { suppressed_ = s; }
+
+private:
+	explicit Logger(std::string category)
+		: category_(std::move(category)), min_severity_(Severity::Debug), suppressed_(false) {}
+
+	std::string category_;
+	Severity min_severity_;
+	bool suppressed_;
+
+	static std::unordered_map<std::string, std::unique_ptr<Logger>> registry_;
+	static std::mutex registry_mutex_;
+};
+
+// Определения статических членов
+inline std::unordered_map<std::string, std::unique_ptr<Logger>> Logger::registry_{};
+inline std::mutex Logger::registry_mutex_;

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/ILink.h

@@ -0,0 +1,21 @@
+#pragma once
+#include <memory>
+#include <vector>
+#include "ifaces/ILinkMixin.h"
+
+/// \brief Интерфейс для классов-связей между элементами.
+/// \tparam TElem Тип элемента, между которыми устанавливается связь.
+template <class TElem>
+class ILink {
+public:
+	using ElemPtr = std::shared_ptr<TElem>;
+
+	virtual ~ILink() = default;
+	virtual ElemPtr getNode() const = 0;
+	virtual ElemPtr getParent() const = 0;
+	virtual void setParent(const ElemPtr& parent) = 0;
+	virtual const std::vector<ElemPtr>& getChildren() const = 0;
+	virtual void addChild(const ElemPtr& child) = 0;
+	virtual void removeChild(const ElemPtr& child) = 0;
+	virtual void replaceChild(const ElemPtr& oldChild, const ElemPtr& newChild) = 0;
+};

include/ifaces/ILinkMixin.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <memory>
+#include "ifaces/ILink.h"
+
+/// \brief Интерфейс для классов, поддерживающих связь с дочерними элементами через ILink.
+/// \tparam TElem Тип дочернего элемента.
+template <class TElem>
+class ILinkMixin {
+public:
+	using LinkPtr = std::shared_ptr<ILink<TElem>>;
+	using ElemPtr = std::shared_ptr<TElem>;
+
+	virtual ~ILinkMixin() = default;
+	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;
+	//virtual operator ElemPtr() const = 0;
+};

include/ifaces/INode.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "ifaces/ILinkMixin.h"
+#include <string>
+
+class INode;
+
+/// \brief Умный указатель на INode.
+using NodePtr = std::shared_ptr<INode>;
+
+/// \brief Интерфейс для узлов дерева.
+/// Определяет базовые методы для работы с именем и типом узла.
+class INode : public virtual ILinkMixin<INode> {
+public:
+	~INode() = default;
+	virtual const std::string& name() const = 0;
+	virtual const std::string& kind() const = 0;
+};

include/iterators/BFSIterator.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <stack>
+
+#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,43 @@
+#pragma once
+#include <tuple>
+
+#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,22 @@
+#pragma once
+#include <queue>
+
+#include "ifaces/INode.h"
+
+#include "iterators/DFSIterator.h"
+#include "iterators/BFSIterator.h"
+
+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 TraversalDFS = Traversal<DFSIterator<INode>>;
+using TraversalBFS = Traversal<BFSIterator<INode>>;

include/links/BaseLink.h

@@ -0,0 +1,43 @@
+#pragma once
+#include <vector>
+#include <algorithm>
+
+#include "ifaces/ILink.h"
+#include "Logger.h"
+
+/// \brief Базовая реализация интерфейса ILink для хранения связей между элементами.
+/// \tparam TElem Тип элемента, между которыми устанавливается связь.
+template <class TElem>
+class BaseLink : public ILink<TElem> {
+public:
+	using ElemPtr = std::shared_ptr<TElem>;
+
+	BaseLink(ElemPtr node) : owner_node_(node) {}
+	ElemPtr getNode() const override { return owner_node_.lock(); }
+	ElemPtr getParent() const override { return parent_.lock(); }
+	void setParent(const ElemPtr& parent) override { parent_ = parent; }
+	const std::vector<ElemPtr>& getChildren() const override { return children_; }
+
+	void addChild(const ElemPtr& child) override {
+		this->children_.push_back(child);
+	}
+
+	void removeChild(const ElemPtr& child) override {
+		children_.erase(std::remove(children_.begin(), children_.end(), child), children_.end());
+	}
+
+	void replaceChild(const ElemPtr& oldChild, const ElemPtr& newChild) override {
+		auto it = std::find(children_.begin(), children_.end(), oldChild);
+		if (it != children_.end()) {
+			*it = newChild;
+		}
+	}
+
+	~BaseLink() override {
+		Logger::get("Link").dbg("--- Destructor called for: BaseLink");
+	}
+protected:
+	std::vector<ElemPtr> children_;
+	std::weak_ptr<TElem> owner_node_;
+	std::weak_ptr<TElem> parent_;
+};

include/links/LeafLink.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "links/BaseLink.h"
+#include <stdexcept>
+
+/// \brief Связь для листового узла, не допускающая дочерних элементов.
+class LeafLink : public BaseLink {
+public:
+	using BaseLink::BaseLink;
+	void addChild(const NodePtr&) override {
+		throw std::logic_error("LeafLink cannot have children");
+	}
+};

include/links/NotImplementedLink.h

@@ -0,0 +1,27 @@
+#pragma once
+#include <vector>
+
+#include "ifaces/ILink.h"
+#include "Logger.h"
+
+/// \brief Заглушка для не реализованной связи между элементами.
+/// Все методы возвращают пустые значения или не выполняют действий.
+/// \tparam TElem Тип элемента.
+template <class TElem>
+class NotImplementedLink : public ILink<TElem> {
+	using ElemPtr = std::shared_ptr<TElem>>;
+public:
+	NotImplementedLink(ElemPtr node) {}
+	ElemPtr getNode() const override { return nullptr; }
+	ElemPtr getParent() const override { return nullptr; }
+	void setParent(const ElemPtr& parent) override { }
+	const std::vector<ElemPtr>& getChildren() const override { return empty_; }
+	void addChild(const ElemPtr& child) override { }
+	void removeChild(const ElemPtr& child) override { }
+
+	~NotImplementedLink() override {
+		Logger::get("Link").dbg("--- Destructor called for: NotImplementedLink");
+	}
+private:
+	std::vector<ElemPtr> empty_;
+};

include/links/OneToManyLink.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "links/BaseLink.h"
+
+/// \brief Связь "один-ко-многим" между элементами одного типа.
+/// Каждый дочерний элемент должен быть того же типа, что и родитель.
+/// \tparam TElem Тип элемента.
+template <class TElem>
+class OneToManyLink : public BaseLink<TElem> {
+public:
+	OneToManyLink(std::shared_ptr<TElem> e) : BaseLink<TElem>(e) {}
+	void addChild(const std::shared_ptr<TElem>& child) override {
+		/* Each child must be exactly the same type as parent */
+		if (typeid(*child) != typeid(*this->owner_node_.lock()))
+			throw std::logic_error("Foundling child");
+		BaseLink<TElem>::addChild(child);
+	}
+};

include/links/OneToOneLink.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "links/BaseLink.h"
+#include <stdexcept>
+
+/// \brief Связь "один-к-одному" между элементами.
+/// Позволяет добавить только одного дочернего элемента.
+/// \tparam TElem Тип элемента.
+template <class TElem>
+class OneToOneLink : public BaseLink<TElem> {
+public:
+	using ElemPtr = std::shared_ptr<TElem>;
+
+	OneToOneLink(ElemPtr e) : BaseLink<TElem>(e) {}
+
+	void addChild(const ElemPtr& child) override {
+		if (!this->children_.empty())
+			throw std::logic_error("Too many children");
+
+		BaseLink<TElem>::addChild(child);
+	}
+};

include/mixins/BaseLinkMixin.h

@@ -0,0 +1,57 @@
+#pragma once
+#include <iostream>
+#include <memory>
+
+#include "ifaces/ILinkMixin.h"
+#include "ifaces/INode.h"
+#include "Logger.h"
+
+/// \brief Базовый миксин для реализации ILinkMixin для INode.
+/// Предоставляет базовую реализацию методов для работы с дочерними узлами и родителем.
+class BaseLinkMixin : public virtual ILinkMixin<INode>,
+		      public std::enable_shared_from_this<ILinkMixin<INode>> {
+	using ElemPtr = std::shared_ptr<INode>;
+
+public:
+	~BaseLinkMixin() override {
+		Logger::get("Mixin").dbg("--- Destructor called for: BaseLinkMixin");
+	}
+
+	void linkChild(const ElemPtr& child) override {
+		getLink()->addChild(child);
+
+		auto childLink = child->getLink();
+		childLink->setParent(getNode());
+	}
+
+	void unlinkParent() override {
+		auto link = getLink();
+
+		ElemPtr parent = link->getParent();
+		if (!parent)
+			throw std::logic_error("Have no parent!");
+
+		auto parentLink = parent->getLink();
+
+		parentLink->removeChild(getNode());
+		getLink()->setParent(nullptr);
+	}
+
+	ElemPtr parent() override {
+		auto link = getLink();
+
+		ElemPtr parent = link->getParent();
+
+		return parent;
+	}
+
+	const std::vector<ElemPtr>& children() override {
+		auto link = getLink();
+		return link->getChildren();
+	}
+
+protected:
+	ElemPtr getNode() {
+		return std::dynamic_pointer_cast<INode>(shared_from_this());
+	}
+};

include/mixins/HierarchicalLinkMixin.h

@@ -0,0 +1,48 @@
+#pragma once
+#include <iostream>
+#include "mixins/LazyLinkMixin.h"
+#include <memory>
+#include "links/OneToManyLink.h"
+#include "links/OneToOneLink.h"
+#include "Logger.h"
+
+/// \brief Миксин для иерархических связей между элементами.
+/// Автоматически выбирает тип связи (один-ко-многим или один-к-одному) в зависимости от типа дочернего элемента.
+/// \tparam TElem Тип дочернего элемента.
+template <class TElem>
+class HierarchicalLinkMixin : public LazyLinkMixin<OneToOneLink<TElem>> {
+	using LinkPtr = std::shared_ptr<ILink<TElem>>;
+	using ElemPtr = std::shared_ptr<TElem>;
+
+public:
+	~HierarchicalLinkMixin() override {
+		Logger::get("Mixin").dbg("--- Destructor called for: HierarchicalLinkMixin");
+	}
+
+	void linkChild(const ElemPtr& child) override {
+		hierarchicalInit(child);
+		LazyLinkMixin<OneToOneLink<TElem>>::linkChild(child);
+	}
+
+protected:
+	void hierarchicalInit(const ElemPtr& child) {
+		Logger::get("Mixin").dbg("---  hierarchicalInit called");
+		if (this->link_ && !this->link_->getChildren().empty())
+			return;
+
+		LinkPtr newLink;
+
+		if (typeid(*child) == typeid(*this)) {
+			Logger::get("Mixin").dbg("---  Mutate to OneToMany");
+			newLink = std::make_shared<OneToManyLink<TElem>>(this->getNode());
+		} else {
+			Logger::get("Mixin").dbg("---  Mutate to OneToOne");
+			newLink = std::make_shared<OneToOneLink<TElem>>(this->getNode());
+		}
+
+		if (newLink && this->link_)
+			newLink->setParent(this->link_->getParent());
+
+		this->link_ = newLink;
+	}
+};

include/mixins/LazyLinkMixin.h

@@ -0,0 +1,39 @@
+#pragma once
+#include <iostream>
+#include "mixins/BaseLinkMixin.h"
+#include <memory>
+#include "Logger.h"
+
+/// \brief Миксин для ленивой инициализации связи (link) с дочерними элементами.
+/// \tparam TLink Тип используемой связи (link).
+template <class TLink>
+class LazyLinkMixin : public BaseLinkMixin {
+public:
+	void unlinkParent() override {
+		/* No link -- no parent, who'll unlinked? */
+		if (!this->link_)
+			throw std::logic_error("Link isn't inited!");
+
+		BaseLinkMixin::unlinkParent();
+	}
+
+	LinkPtr getLink() override {
+		lazyInit();
+		return this->link_;
+	}
+
+	LazyLinkMixin() {}
+
+	~LazyLinkMixin() override {
+		Logger::get("Mixin").dbg("--- Destructor called for: LazyLinkMixin");
+	}
+
+protected:
+	void lazyInit() {
+		if (!link_) {
+			link_ = std::make_shared<TLink>(
+					BaseLinkMixin::getNode());
+		}
+	}
+	LinkPtr link_;
+};

include/nodes/BaseNode.h

@@ -0,0 +1,22 @@
+#pragma once
+#include <iostream>
+
+#include "ifaces/INode.h"
+#include "Logger.h"
+
+/// \brief Базовый класс для всех узлов дерева.
+/// Содержит имя и тип узла, реализует интерфейс INode.
+class BaseNode : public virtual INode {
+public:
+	BaseNode(std::string name) : name_(std::move(name)) {
+		Logger::get("Node").dbg(std::string("--- Base constructor called for: ") + name_);
+	}
+	const std::string& name() const override { return name_; }
+	const std::string& kind() const override { return kind_; }
+	~BaseNode() {
+		Logger::get("Node").dbg(std::string("--- Base destructor called for: ") + name_);
+	}
+protected:
+	std::string name_;
+	std::string kind_;
+};

include/nodes/ComplexNode.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <iostream>
+
+#include "nodes/BaseNode.h"
+#include "mixins/HierarchicalLinkMixin.h"
+#include "Logger.h"
+
+/// \brief Класс сложного (составного) узла дерева.
+/// Может содержать несколько дочерних ComplexNode и один SimpleNode.
+class ComplexNode : public BaseNode,
+		    virtual public HierarchicalLinkMixin<INode> {
+public:
+	~ComplexNode() {
+		Logger::get("Node").dbg(std::string("--- Complex destructor called for: ") + name_);
+	}
+	ComplexNode(std::string name) : BaseNode(std::move(name)) {
+		Logger::get("Node").dbg(std::string("--- Complex constructor called for: ") + name_);
+	}
+};

include/nodes/SimpleNode.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <iostream>
+
+#include "nodes/BaseNode.h"
+#include "mixins/LazyLinkMixin.h"
+#include "links/OneToOneLink.h"
+#include "Logger.h"
+
+/// \brief Класс простого (листового) узла дерева.
+/// Может содержать только одного дочернего ComplexNode.
+class SimpleNode : public BaseNode,
+		   virtual public LazyLinkMixin<OneToOneLink<INode>> {
+public:
+	~SimpleNode() {
+		Logger::get("Node").dbg(std::string("--- Simple destructor called for: ") + name_);
+	}
+	SimpleNode(std::string name) : BaseNode(std::move(name)) {
+		Logger::get("Node").dbg(std::string("--- Simple constructor called for: ") + name_);
+	}
+};

src/main.cpp

@@ -0,0 +1,142 @@
+#include <iostream>
+
+#include "Logger.h"
+
+#include "nodes/SimpleNode.h"
+#include "nodes/ComplexNode.h"
+#include "iterators/Traversal.h"
+
+
+void printNode(INode& node, size_t level) {
+	for (size_t i = level; i > 0; i--)
+		std::cout << "  ";
+	std::cout << node.name() << "\n";
+}
+
+void printTreeBFS(INode& node) {
+	for (auto& child : TraversalBFS(&node))
+		printNode(*child, 0);
+}
+void printTreeList(INode& node) {
+	for (auto& child : TraversalDFS(&node))
+		printNode(*child, 0);
+}
+void printTreeLadder(INode& node) {
+	for (auto& [child, level] : TraversalDFS(&node))
+		printNode(*child, level);
+}
+
+int main() {
+	Logger::setMinSeverity("MAIN", Logger::Severity::Debug);
+	Logger::suppressCategory("Node");
+	Logger::suppressCategory("Link");
+	Logger::suppressCategory("Mixin");
+	auto& logger = Logger::get("MAIN");
+	logger.info("Entering main scope...");
+
+	{
+		auto root = std::make_shared<ComplexNode>("ComplexRoot");
+		auto child1 = std::make_shared<ComplexNode>("ComplexChild1");
+
+		root->linkChild(child1);
+
+		std::cout << "\nInit tree:\n";
+		printTreeLadder(*root);
+		std::cout << "\n";
+
+		{
+			auto child2 = std::make_shared<ComplexNode>("ComplexChild2");
+			root->linkChild(child2);
+
+			auto subchild2 = std::make_shared<SimpleNode>("SimpleSubChild2");
+			child2->linkChild(subchild2);
+
+			auto child3 = std::make_shared<ComplexNode>("ComplexChild3");
+			root->linkChild(child3);
+
+			auto subchild3 = std::make_shared<SimpleNode>("SimpleSubChild3");
+			child3->linkChild(subchild3);
+
+			{
+				// Негативный сценарий 1: попытка добавить второй SimpleNode к ComplexNode
+				try {
+					auto anotherSimple = std::make_shared<SimpleNode>("ShouldFail");
+					child2->linkChild(anotherSimple);
+					logger.err("[ERROR] Не должно было получиться добавить второй SimpleNode к ComplexNode!");
+				} catch (const std::logic_error& e) {
+					logger.warn(std::string("[Ожидаемое исключение] ") + e.what());
+				}
+
+				// Негативный сценарий 2: попытка добавить ComplexNode к SimpleNode
+				// Это допустимо: SimpleNode может иметь ComplexNode в качестве единственного ребёнка
+				auto goodComplex = std::make_shared<ComplexNode>("GoodComplex");
+				subchild2->linkChild(goodComplex);
+				logger.info("[OK] ComplexNode успешно добавлен к SimpleNode как единственный ребёнок.");
+
+				// Негативный сценарий: попытка добавить второго ребёнка к SimpleNode
+				try {
+					auto anotherSimple = std::make_shared<SimpleNode>("ShouldFail2");
+					subchild2->linkChild(anotherSimple);
+					logger.err("[ERROR] Не должно было получиться добавить второго ребёнка к SimpleNode!");
+				} catch (const std::logic_error& e) {
+					logger.warn(std::string("[Ожидаемое исключение] ") + e.what());
+				}
+
+				// Негативный сценарий: попытка добавить SimpleNode в ComplexNode, который уже содержит несколько ComplexNode-дочерних
+				try {
+					auto badSimple = std::make_shared<SimpleNode>("BadSimple");
+					root->linkChild(badSimple);
+					logger.err("[ERROR] Не должно было получиться добавить SimpleNode в ComplexNode с несколькими ComplexNode-дочерними!");
+				} catch (const std::logic_error& e) {
+					logger.warn(std::string("[Ожидаемое исключение] ") + e.what());
+				}
+			}
+
+			std::cout << "\nAnother tree:\n";
+			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";
+			printTreeLadder(*root);
+			std::cout << "\n";
+
+			logger.info("Put refs of ComplexChild2, ComplexChild3 and its children");
+		}
+
+		std::cout << "\nTree after scope out:\n";
+		printTreeLadder(*root);
+		std::cout << "\n";
+
+		logger.info("Unlinking ComplexChild1 and ComplexChild3...\n");
+		child1->unlinkParent();
+		for (auto child : root->getLink()->getChildren()) {
+			NodePtr childNode = std::dynamic_pointer_cast<INode>(child);
+			if (childNode->name() == "ComplexChild3") {
+				childNode->unlinkParent();
+				break;
+			}
+		}
+
+		auto child4 = std::make_shared<SimpleNode>("SimpleChild4");
+		root->linkChild(child4);
+
+		std::cout << "\nTree flush and link SimpleChild4:\n";
+		printTreeLadder(*root);
+		std::cout << "\n";
+	}
+
+	logger.info("Exited main scope. All smart pointers destroyed.");
+
+	return 0;
+}

tree.cc

@@ -1,306 +0,0 @@
-#include <iostream>
-#include <vector>
-#include <memory>
-#include <mutex>
-#include <algorithm>
-#include <stdexcept>
-
-class INode;
-class ILink;
-class ILinkMixin;
-
-using NodePtr = std::shared_ptr<INode>;
-using LinkPtr = std::shared_ptr<ILink>;
-using LinkMixinPtr = std::shared_ptr<ILinkMixin>;
-
-class ILink {
-public:
-    virtual ~ILink() = default;
-
-    virtual LinkPtr getParent() const = 0;
-    virtual void setParent(LinkPtr parent) = 0;
-
-    virtual const std::vector<LinkPtr>& getChildren() const = 0;
-    virtual void addChild(LinkPtr child) = 0;
-    virtual void removeChild(LinkPtr child) = 0;
-
-    virtual std::mutex& getLock() = 0;
-    virtual LinkMixinPtr getLinkMixin() const = 0;
-};
-
-class ILinkMixin {
-public:
-    virtual ~ILinkMixin() = default;
-    virtual void linkChild(const NodePtr& child) = 0;
-    virtual void unlinkParent() = 0;
-    virtual void unlinkChild(const NodePtr& child) = 0;
-    virtual LinkPtr getLink() const = 0;
-    virtual NodePtr getNode() const = 0;
-};
-
-class INode {
-public:
-    virtual ~INode() = default;
-    virtual LinkPtr getLink() const = 0;
-    virtual LinkMixinPtr getLinkMixin() const = 0;
-};
-
-class LeafLink : public ILink {
-public:
-    explicit LeafLink(NodePtr node) : node_(std::move(node)) {}
-
-    LinkPtr getParent() const override { return parent_; }
-    void setParent(LinkPtr parent) override { parent_ = std::move(parent); }
-
-    const std::vector<LinkPtr>& getChildren() const override {
-        static std::vector<LinkPtr> empty;
-        return empty;
-    }
-
-    void addChild(LinkPtr) override {
-        throw std::logic_error("LeafLink cannot have children");
-    }
-
-    void removeChild(LinkPtr) override {}
-
-    std::mutex& getLock() override { return lock_; }
-    LinkMixinPtr getLinkMixin() const override { return node_->getLinkMixin(); }
-
-private:
-    NodePtr node_;
-    LinkPtr parent_;
-    mutable std::mutex lock_;
-};
-
-class OneToManyLink : public ILink {
-public:
-    explicit OneToManyLink(NodePtr node) : node_(std::move(node)) {}
-
-    LinkPtr getParent() const override { return parent_; }
-    void setParent(LinkPtr parent) override { parent_ = std::move(parent); }
-
-    const std::vector<LinkPtr>& getChildren() const override { return children_; }
-
-    void addChild(LinkPtr child) override { children_.push_back(std::move(child)); }
-
-    void removeChild(LinkPtr child) override {
-        children_.erase(std::remove(children_.begin(), children_.end(), child), children_.end());
-    }
-
-    std::mutex& getLock() override { return lock_; }
-    LinkMixinPtr getLinkMixin() const override { return node_->getLinkMixin(); }
-
-private:
-    NodePtr node_;
-    LinkPtr parent_;
-    std::vector<LinkPtr> children_;
-    mutable std::mutex lock_;
-};
-
-class OneToOneLink : public ILink {
-public:
-    explicit OneToOneLink(NodePtr node) : node_(std::move(node)) {}
-
-    LinkPtr getParent() const override { return parent_; }
-    void setParent(LinkPtr parent) override { parent_ = std::move(parent); }
-
-    const std::vector<LinkPtr>& getChildren() const override { return singleChildVec_; }
-
-    void addChild(LinkPtr child) override {
-        if (!singleChildVec_.empty()) {
-            throw std::logic_error("OneToOneLink already has a child");
-        }
-        singleChildVec_.push_back(std::move(child));
-    }
-
-    void removeChild(LinkPtr child) override {
-        if (!singleChildVec_.empty() && singleChildVec_.front() == child) {
-            singleChildVec_.clear();
-        }
-    }
-
-    std::mutex& getLock() override { return lock_; }
-    LinkMixinPtr getLinkMixin() const override { return node_->getLinkMixin(); }
-
-private:
-    NodePtr node_;
-    LinkPtr parent_;
-    std::vector<LinkPtr> singleChildVec_;
-    mutable std::mutex lock_;
-};
-
-// Note: TypedOneToManyLink ensures type-safety on child linkage
-
-template <typename TChild>
-class TypedOneToManyLink : public OneToManyLink {
-public:
-    explicit TypedOneToManyLink(NodePtr node) : OneToManyLink(std::move(node)) {}
-
-    void addChild(LinkPtr child) override {
-        NodePtr n = child->getLinkMixin()->getNode();
-        if (!std::dynamic_pointer_cast<TChild>(n)) {
-            throw std::invalid_argument("TypedOneToManyLink: child is not of expected type");
-        }
-        OneToManyLink::addChild(std::move(child));
-    }
-};
-
-// Note: BaseLinkMixin is used for direct eager link composition (non-lazy)
-
-class BaseLinkMixin : public ILinkMixin {
-public:
-    explicit BaseLinkMixin(NodePtr self) {
-        link_ = std::make_shared<OneToManyLink>(self);
-    }
-
-    void linkChild(const NodePtr& child) override {
-        LinkPtr childLink = child->getLink();
-        childLink->setParent(link_);
-        link_->addChild(childLink);
-    }
-
-    void unlinkParent() override {
-        if (!link_ || !link_->getParent()) return;
-        auto parent = link_->getParent();
-        parent->getLinkMixin()->unlinkChild(getNode());
-        link_->setParent(nullptr);
-    }
-
-    void unlinkChild(const NodePtr& child) override {
-        LinkPtr childLink = child->getLink();
-        link_->removeChild(childLink);
-        childLink->setParent(nullptr);
-    }
-
-    LinkPtr getLink() const override { return link_; }
-    NodePtr getNode() const override { return self_; }
-
-private:
-    LinkPtr link_;
-    NodePtr self_;
-};
-
-// Note: LazyLinkMixin starts with LeafLink and upgrades dynamically
-
-template <typename TNode>
-class LazyLinkMixin : public ILinkMixin {
-public:
-    explicit LazyLinkMixin(NodePtr self) : self_(self) {
-        link_ = std::make_shared<LeafLink>(self);
-    }
-
-    void linkChild(const NodePtr& child) override {
-        ensureInitialized(child);
-
-        LinkPtr childLink = child->getLink();
-        childLink->setParent(link_);
-        link_->addChild(childLink);
-    }
-
-    void unlinkParent() override {
-        if (!link_ || !link_->getParent()) return;
-        auto parent = link_->getParent();
-        parent->getLinkMixin()->unlinkChild(getNode());
-        link_->setParent(nullptr);
-
-        if (link_->getChildren().empty()) {
-            link_ = std::make_shared<LeafLink>(getNode());
-        }
-    }
-
-    void unlinkChild(const NodePtr& child) override {
-        if (!link_) return;
-        LinkPtr childLink = child->getLink();
-        link_->removeChild(childLink);
-        childLink->setParent(nullptr);
-
-        if (link_->getChildren().empty()) {
-            link_ = std::make_shared<LeafLink>(getNode());
-        }
-    }
-
-    LinkPtr getLink() const override { return link_; }
-    NodePtr getNode() const override { return self_; }
-
-private:
-    void ensureInitialized(const NodePtr& child) {
-        if (link_ && !std::dynamic_pointer_cast<LeafLink>(link_)) return;
-
-        LinkPtr oldLink = link_;
-        LinkPtr newLink;
-
-        if (std::dynamic_pointer_cast<TNode>(child)) {
-            newLink = std::make_shared<TypedOneToManyLink<TNode>>(getNode());
-        } else {
-            newLink = std::make_shared<OneToOneLink>(getNode());
-        }
-
-        newLink->setParent(oldLink->getParent());
-        link_ = newLink;
-    }
-
-    LinkPtr link_;
-    NodePtr self_;
-};
-
-class SimpleNode : public INode, public std::enable_shared_from_this<SimpleNode> {
-public:
-    static std::shared_ptr<SimpleNode> create(std::string name) {
-        struct EnableMakeShared : public SimpleNode {
-            EnableMakeShared(std::string n) : SimpleNode(std::move(n)) {}
-        };
-        auto ptr = std::make_shared<EnableMakeShared>(std::move(name));
-        ptr->initMixin();
-        return ptr;
-    }
-
-    const std::string& name() const { return name_; }
-    LinkPtr getLink() const override { return mixin_->getLink(); }
-    LinkMixinPtr getLinkMixin() const override { return mixin_; }
-
-    void linkChild(const std::shared_ptr<SimpleNode>& child) { mixin_->linkChild(child); }
-    void unlinkParent() { mixin_->unlinkParent(); }
-
-private:
-    explicit SimpleNode(std::string name) : name_(std::move(name)) {}
-
-    void initMixin() {
-        mixin_ = std::make_shared<LazyLinkMixin<SimpleNode>>(shared_from_this());
-    }
-
-    std::string name_;
-    LinkMixinPtr mixin_;
-};
-
-void printTree(const LinkPtr& link, int indent = 0) {
-    for (int i = 0; i < indent; ++i) std::cout << "  ";
-    auto node = link->getLinkMixin()->getNode();
-    auto simpleNode = std::dynamic_pointer_cast<SimpleNode>(node);
-    if (simpleNode) {
-        std::cout << simpleNode->name() << "\n";
-    }
-    for (const auto& child : link->getChildren()) {
-        printTree(child, indent + 1);
-    }
-}
-
-int main() {
-    auto root = SimpleNode::create("Root");
-    auto child1 = SimpleNode::create("Child1");
-    auto child2 = SimpleNode::create("Child2");
-
-    root->linkChild(child1);
-    root->linkChild(child2);
-
-    auto subchild = SimpleNode::create("SubChild");
-    child1->linkChild(subchild);
-
-    printTree(root->getLink());
-
-    std::cout << "\nUnlinking Child2...\n";
-    child2->unlinkParent();
-
-    printTree(root->getLink());
-
-    return 0;
-}