tmp

.gitignore

@@ -0,0 +1,3 @@
+*.swp
+build
+.vscode

include/ifaces/ILink.h

@@ -12,9 +12,9 @@ class ILink {
 public:
 	virtual ~ILink() = default;
 	virtual NodePtr getNode() const = 0;
-    virtual LinkPtr getParent() const = 0;
-    virtual void setParent(const LinkPtr& parent) = 0;
-    virtual const std::vector<LinkPtr>& getChildren() const = 0;
-    virtual void addChild(const LinkPtr& child) = 0;
-    virtual void removeChild(const LinkPtr& child) = 0;
+	virtual NodePtr getParent() const = 0;
+	virtual void setParent(const NodePtr& parent) = 0;
+	virtual const std::vector<NodePtr>& getChildren() const = 0;
+	virtual void addChild(const NodePtr& child) = 0;
+	virtual void removeChild(const NodePtr& child) = 0;
 };

include/ifaces/ILinkMixin.h

@@ -13,4 +13,5 @@ public:
 	virtual void linkChild(const NodePtr& child) = 0;
 	virtual void unlinkParent() = 0;
 	virtual LinkPtr getLink() = 0;
+	virtual NodePtr getSelf() = 0;
 };

include/links/BaseLink.h

@@ -7,10 +7,10 @@ class BaseLink : public ILink {
 public:
 	explicit BaseLink(NodePtr node) : owner_node_(node) {}
 	NodePtr getNode() const override { return owner_node_.lock(); }
-    LinkPtr getParent() const override { return parent_.lock(); }
-    void setParent(const LinkPtr& parent) override { parent_ = parent; }
-    const std::vector<LinkPtr>& getChildren() const override { return children_; }
-    void removeChild(const LinkPtr& child) override {
+	NodePtr getParent() const override { return parent_.lock(); }
+	void setParent(const NodePtr& parent) override { parent_ = parent; }
+	const std::vector<NodePtr>& getChildren() const override { return children_; }
+	void removeChild(const NodePtr& child) override {
 		children_.erase(std::remove(children_.begin(), children_.end(), child), children_.end());
 	}
 
@@ -18,7 +18,7 @@ public:
 		std::cout << "--- Destructor called for: " << "BaseLink" << "\n";
 	}
 protected:
-    std::vector<LinkPtr> children_;
+	std::vector<NodePtr> children_;
 	std::weak_ptr<INode> owner_node_;
-    std::weak_ptr<ILink> parent_;
+	std::weak_ptr<INode> parent_;
 };

include/links/LeafLink.h

@@ -5,5 +5,5 @@
 class LeafLink : public BaseLink {
 public:
 	using BaseLink::BaseLink;
-    void addChild(const LinkPtr&) override { throw std::logic_error("LeafLink cannot have children"); }
+	void addChild(const NodePtr&) override { throw std::logic_error("LeafLink cannot have children"); }
 };

include/links/OneToManyLink.h

@@ -4,5 +4,5 @@
 class OneToManyLink : public BaseLink {
 public:
 	using BaseLink::BaseLink;
-    void addChild(const LinkPtr& child) override { children_.push_back(child); }
+	void addChild(const NodePtr& child) override { children_.push_back(child); }
 };

include/mixins/LazyLinkMixin.h

@@ -5,23 +5,29 @@
 #include "links/OneToManyLink.h"
 #include <memory>
 
-template <class TFinalNode>
-class LazyLinkMixin : public INode {
+template <class TLink>
+class LazyLinkMixin : public ILinkMixin {
 public:
 	void linkChild(const NodePtr& childNode) override {
-        lazyInit();
-        upgradeLinkIfNeeded();
 		LinkPtr childLink = childNode->getLink();
-        childLink->setParent(link_);
-        link_->addChild(childLink);
+		childLink->setParent(getSelf());
+
+		getLink()->addChild(childNode);
 	}
 
 	void unlinkParent() override {
-        lazyInit();
-        LinkPtr parentLink = link_->getParent();
-        if (!parentLink) return;
-        parentLink->removeChild(this->getLink());
-        link_->setParent(nullptr);
+		/* No link -- no parent, who'll unlinked? */
+		if (!link_)
+			throw std::logic_error("Link isn't inited!");
+
+		NodePtr parent = link_->getParent();
+		if (!parent)
+			throw std::logic_error("Have no parent!");
+
+		LinkPtr parentLink = parent->getLink();
+
+		parentLink->removeChild(getSelf());
+		getLink()->setParent(nullptr);
 	}
 
 	LinkPtr getLink() override {
@@ -34,36 +40,13 @@ public:
 	}
 
 protected:
-    virtual std::shared_ptr<TFinalNode> getShared() = 0;
+	virtual NodePtr getShared() = 0;
 	NodePtr getSelf() override { return getShared(); }
 
 private:
 	void lazyInit() {
 		if (!link_) {
-            link_ = std::make_shared<LeafLink>(getSelf());
-        }
-    }
-
-    void upgradeLinkIfNeeded() {
-        if (!std::dynamic_pointer_cast<LeafLink>(link_)) return;
-        auto newLink = std::make_shared<OneToManyLink>(getSelf());
-        if (auto parentLink = link_->getParent()) {
-            parentLink->removeChild(link_);
-            parentLink->addChild(newLink);
-        }
-        newLink->setParent(link_->getParent());
-        link_ = newLink;
-    }
-
-    void downgradeLinkIfPossible() {
-        if (link_->getChildren().empty() && std::dynamic_pointer_cast<OneToManyLink>(link_)) {
-            auto newLink = std::make_shared<LeafLink>(getSelf());
-            if (auto parentLink = link_->getParent()) {
-                parentLink->removeChild(link_);
-                parentLink->addChild(newLink);
-            }
-            newLink->setParent(link_->getParent());
-            link_ = newLink;
+			link_ = std::make_shared<TLink>(getSelf());
 		}
 	}
 

include/nodes/BaseNode.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "mixins/LazyLinkMixin.h"
+#include "ifaces/INode.h"
+#include <iostream>
+
+class BaseNode : public INode,
+		 public LazyLinkMixin<OneToManyLink>,
+		 public std::enable_shared_from_this<BaseNode> {
+public:
+	BaseNode(std::string name) : name_(std::move(name)) {}
+	const std::string& name() const override { return name_; }
+	~BaseNode() {
+		std::cout << "--- Destructor called for: " << name_ << "\n";
+	}
+protected:
+	NodePtr getShared() override {
+		return shared_from_this();
+	}
+	std::string name_;
+};

include/nodes/SimpleNode.h

@@ -1,26 +1,12 @@
 #pragma once
-#include "mixins/LazyLinkMixin.h"
+#include "nodes/BaseNode.h"
 #include <iostream>
 
-class SimpleNode : public LazyLinkMixin<SimpleNode>,
-                   public std::enable_shared_from_this<SimpleNode> {
+class SimpleNode :
+		   public BaseNode {
 public:
-    static NodePtr create(std::string name) {
-        struct EnableMakeShared : public SimpleNode {
-            EnableMakeShared(std::string n) : SimpleNode(std::move(n)) {}
-        };
-        return std::make_shared<EnableMakeShared>(std::move(name));
-    }
-    const std::string& name() const override { return name_; }
 	~SimpleNode() {
 		std::cout << "--- Destructor called for: " << name_ << "\n";
 	}
-protected:
-    std::shared_ptr<SimpleNode> getShared() override {
-        return shared_from_this();
-    }
-private:
-    friend class LazyLinkMixin<SimpleNode>;
-    explicit SimpleNode(std::string name) : name_(std::move(name)) {}
-    std::string name_;
+	SimpleNode(std::string name) : BaseNode(std::move(name)) {}
 };

src/main.cpp

@@ -6,8 +6,8 @@ void printTree(const NodePtr& startNode, int indent = 0) {
 	for (int i = 0; i < indent; ++i) std::cout << "  ";
 	std::cout << startNode->name() << "\n";
 	LinkPtr nodeLink = startNode->getLink();
-    for (const auto& childLink : nodeLink->getChildren()) {
-        printTree(childLink->getNode(), indent + 1);
+	for (const auto& child : nodeLink->getChildren()) {
+		printTree(child, indent + 1);
 	}
 }
 
@@ -16,19 +16,19 @@ int main() {
 
 	// Начало новой области видимости
 	{
-        auto root = SimpleNode::create("Root");
-        auto child2 = SimpleNode::create("Child2");
+		auto root = std::make_shared<SimpleNode>("Root");
+		auto child2 = std::make_shared<SimpleNode>("Child2");
 
 		root->linkChild(child2);
 
 		{
-		auto child1 = SimpleNode::create("Child1");
+			auto child1 = std::make_shared<SimpleNode>("Child1");
 			root->linkChild(child1);
-		auto subchild = SimpleNode::create("SubChild");
+			auto subchild = std::make_shared<SimpleNode>("SubChild");
 			child1->linkChild(subchild);
-		auto child3 = SimpleNode::create("Child3");
+			auto child3 = std::make_shared<SimpleNode>("Child3");
 			root->linkChild(child3);
-		auto subchild2 = SimpleNode::create("SubChild2");
+			auto subchild2 = std::make_shared<SimpleNode>("SubChild2");
 			child3->linkChild(subchild2);
 
 			std::cout << "Initial tree:\n";