qosd: трассировка кон-/деструкторов переведена на отдельный логгер

Т.к. в основном меня либо интересует создание/удаление объектов, либо
нет. Смысла объединять это логи с другими логами объектов каждой
подсистемы я не вижу.

BFSIterator.h

@@ -1,21 +0,0 @@
-#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/ILinkMixin.h

@@ -11,7 +11,6 @@ public:
 	using ElemPtr = std::shared_ptr<TElem>;
 
 	virtual ~ILinkMixin() = default;
-	virtual operator std::shared_ptr<TElem>() = 0;
 	virtual void linkChild(const ElemPtr& child) = 0;
 	virtual void unlinkParent() = 0;
 	virtual const std::vector<ElemPtr>& children() = 0;

include/links/LeafLink.h

@@ -3,14 +3,10 @@
 #include <stdexcept>
 
 /// \brief Связь для листового узла, не допускающая дочерних элементов.
-template <class TElem>
-class LeafLink : public BaseLink<TElem> {
+class LeafLink : public BaseLink {
 public:
-	using ElemPtr = std::shared_ptr<TElem>;
-
-	LeafLink(std::shared_ptr<TElem> e) : BaseLink<TElem>(e) {}
-
-	void addChild(const ElemPtr&) override {
-		throw std::logic_error("Leaf cannot have children");
+	using BaseLink::BaseLink;
+	void addChild(const NodePtr&) override {
+		throw std::logic_error("LeafLink cannot have children");
 	}
 };

include/mixins/BaseLinkMixin.h

@@ -17,10 +17,6 @@ public:
 		Logger::get("ConDes").dbg("--- Destructor called for: BaseLinkMixin");
 	}
 
-	operator std::shared_ptr<INode>() override {
-		return this->getNode();
-	}
-
 	void linkChild(const ElemPtr& child) override {
 		getLink()->addChild(child);
 
@@ -37,15 +33,7 @@ public:
 
 		auto parentLink = parent->getLink();
 
-		/* NOTE:
-		 *
-		 * Keep a reference to the node we gonna to unlink.
-		 * Otherwise, we'll disappear between `removeChild` and
-		 * `setParent`. Do not rearrange these calls, because
-		 * we want to modify the tree top down.
-		 */
-		auto node = getNode();
-		parentLink->removeChild(node);
+		parentLink->removeChild(getNode());
 		getLink()->setParent(nullptr);
 	}
 

include/mixins/FabricMixin.h

@@ -1,11 +0,0 @@
-#pragma once
-#include <memory>
-
-template <typename T>
-class FabricMixin {
-public:
-	template <typename... Args>
-	static std::shared_ptr<T> create(Args&&... args) {
-		return std::shared_ptr<T>(new T(std::forward<Args>(args)...));
-	}
-};

include/mixins/HierarchicalLinkMixin.h

@@ -1,21 +1,18 @@
 #pragma once
 #include <iostream>
-#include <memory>
-
-#include "ifaces/INode.h"
 #include "mixins/LazyLinkMixin.h"
+#include <memory>
 #include "links/OneToManyLink.h"
 #include "links/OneToOneLink.h"
 #include "Logger.h"
 
 /// \brief Миксин для иерархических связей между элементами.
-/// \tparam INode Тип дочернего элемента.
-/// Автоматически выбирает тип связи (один-ко-многим или один-к-одному) в зависимости от типа
-/// дочернего узла. Если тип дочернего узла совпадает с родителем, то используется связь
-/// один-ко-многим. При попытке подключить узел отличного типа выбирается связь один-к-одному.
-class HierarchicalLinkMixin : public LazyLinkMixin<OneToOneLink<INode>> {
-	using LinkPtr = std::shared_ptr<ILink<INode>>;
-	using ElemPtr = std::shared_ptr<INode>;
+/// Автоматически выбирает тип связи (один-ко-многим или один-к-одному) в зависимости от типа дочернего элемента.
+/// \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 {
@@ -24,7 +21,7 @@ public:
 
 	void linkChild(const ElemPtr& child) override {
 		hierarchicalInit(child);
-		LazyLinkMixin<OneToOneLink<INode>>::linkChild(child);
+		LazyLinkMixin<OneToOneLink<TElem>>::linkChild(child);
 	}
 
 protected:
@@ -37,10 +34,10 @@ protected:
 
 		if (typeid(*child) == typeid(*this)) {
 			Logger::get("Mixin").dbg("---  Mutate to OneToMany");
-			newLink = std::make_shared<OneToManyLink<INode>>(*this);
+			newLink = std::make_shared<OneToManyLink<TElem>>(this->getNode());
 		} else {
 			Logger::get("Mixin").dbg("---  Mutate to OneToOne");
-			newLink = std::make_shared<OneToOneLink<INode>>(*this);
+			newLink = std::make_shared<OneToOneLink<TElem>>(this->getNode());
 		}
 
 		if (newLink && this->link_)

include/mixins/LazyLinkMixin.h

@@ -31,7 +31,8 @@ public:
 protected:
 	void lazyInit() {
 		if (!link_) {
-			link_ = std::make_shared<TLink>(*this);
+			link_ = std::make_shared<TLink>(
+					BaseLinkMixin::getNode());
 		}
 	}
 	LinkPtr link_;

include/nodes/ComplexNode.h

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

include/nodes/LeafNode.h

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

include/nodes/SimpleNode.h

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

src/main.cpp

@@ -4,7 +4,6 @@
 
 #include "nodes/SimpleNode.h"
 #include "nodes/ComplexNode.h"
-#include "nodes/LeafNode.h"
 #include "iterators/Traversal.h"
 
 
@@ -40,8 +39,8 @@ int main() {
 	logger.info("Entering main scope...");
 
 	{
-		auto root = ComplexNode::create("ComplexRoot");
-		auto child1 = ComplexNode::create("ComplexChild1");
+		auto root = std::make_shared<ComplexNode>("ComplexRoot");
+		auto child1 = std::make_shared<ComplexNode>("ComplexChild1");
 
 		root->linkChild(child1);
 
@@ -50,30 +49,23 @@ int main() {
 		std::cout << "\n";
 
 		{
-			auto child2 = ComplexNode::create("ComplexChild2");
+			auto child2 = std::make_shared<ComplexNode>("ComplexChild2");
 			root->linkChild(child2);
 
-			auto subchild2 = SimpleNode::create("SimpleSubChild2");
+			auto subchild2 = std::make_shared<SimpleNode>("SimpleSubChild2");
 			child2->linkChild(subchild2);
 
-			auto child3 = ComplexNode::create("ComplexChild3");
+			auto child3 = std::make_shared<ComplexNode>("ComplexChild3");
 			root->linkChild(child3);
 
-			auto leaf3 = LeafNode::create("LeafSubChild3");
-			child3->linkChild(leaf3);
+			auto subchild3 = std::make_shared<SimpleNode>("SimpleSubChild3");
+			child3->linkChild(subchild3);
 
 			{
-				// Негативный сценарий 0: попытка добавить SimpleNode к LeafNode
-				try {
-					leaf3->linkChild(SimpleNode::create("ShouldFail"));
-					logger.err("[ERROR] Не должно было получиться добавить SimpleNode к LeafNode!");
-				} catch (const std::logic_error& e) {
-					logger.warn(std::string("[Ожидаемое исключение] ") + e.what());
-				}
-
 				// Негативный сценарий 1: попытка добавить второй SimpleNode к ComplexNode
 				try {
-					child2->linkChild(SimpleNode::create("ShouldFail"));
+					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());
@@ -81,12 +73,14 @@ int main() {
 
 				// Негативный сценарий 2: попытка добавить ComplexNode к SimpleNode
 				// Это допустимо: SimpleNode может иметь ComplexNode в качестве единственного ребёнка
-				subchild2->linkChild(ComplexNode::create("GoodComplex"));
+				auto goodComplex = std::make_shared<ComplexNode>("GoodComplex");
+				subchild2->linkChild(goodComplex);
 				logger.info("[OK] ComplexNode успешно добавлен к SimpleNode как единственный ребёнок.");
 
 				// Негативный сценарий: попытка добавить второго ребёнка к SimpleNode
 				try {
-					subchild2->linkChild(SimpleNode::create("ShouldFail2"));
+					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());
@@ -94,7 +88,8 @@ int main() {
 
 				// Негативный сценарий: попытка добавить SimpleNode в ComplexNode, который уже содержит несколько ComplexNode-дочерних
 				try {
-					root->linkChild(SimpleNode::create("BadSimple"));
+					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());
@@ -129,36 +124,16 @@ int main() {
 
 		logger.info("Unlinking ComplexChild1 and ComplexChild3...\n");
 		child1->unlinkParent();
-		for (auto child : traversal::BFS(root)) {
-			if (child->name() == "ComplexChild3") {
-				/* Avoid of disconnecting a node of the tree
-				 * we're traversing. Method holds reference
-				 * to it's object itself. But iterator ignores
-				 * smart pointers, feeling free to dereference
-				 * the destroyed object.
-				 */
-#if 1
-				/* Keep in mind to keep your reference until
-				 * the cycle ends, if you want more than just
-				 * remove subtree.
-				 */
-				NodePtr node = *child;
-				node->unlinkParent();
-				std::cout << "Unlinked: "
-					  << node->name() << std::endl;
+		for (auto child : root->getLink()->getChildren()) {
+			NodePtr childNode = std::dynamic_pointer_cast<INode>(child);
+			if (childNode->name() == "ComplexChild3") {
+				childNode->unlinkParent();
 				break;
-#else
-				/* Otherwise, just break immediately you
-				 * unlinked a node. The current pointer is not
-				 * a valid pointer anymore.
-				 */
-				child->unlinkParent();
-				break;
-#endif
 			}
 		}
 
-		root->linkChild(SimpleNode::create("SimpleChild4"));
+		auto child4 = std::make_shared<SimpleNode>("SimpleChild4");
+		root->linkChild(child4);
 
 		std::cout << "\nTree flush and link SimpleChild4:\n";
 		printTreeLadder(*root);