unlink the links

include/ifaces/ILink.h

@@ -1,17 +1,16 @@
 #pragma once
 #include <memory>
 #include <vector>
-#include "ifaces/INode.h"
-
-using LinkPtr = std::shared_ptr<ILink>;
+#include "ifaces/ILinkMixin.h"
 
+template <class TElem>
 class ILink {
 public:
 	virtual ~ILink() = default;
-	virtual NodePtr getNode() const = 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;
+	virtual std::shared_ptr<TElem> getNode() const = 0;
+	virtual std::shared_ptr<TElem> getParent() const = 0;
+	virtual void setParent(const std::shared_ptr<TElem>& parent) = 0;
+	virtual const std::vector<std::shared_ptr<TElem>>& getChildren() const = 0;
+	virtual void addChild(const std::shared_ptr<TElem>& child) = 0;
+	virtual void removeChild(const std::shared_ptr<TElem>& child) = 0;
 };

include/ifaces/ILinkMixin.h

@@ -1,11 +1,16 @@
 #pragma once
 #include <memory>
-#include "decls.h"
+#include "ifaces/ILink.h"
+
+class ILinkMixin;
+
+using MixinPtr = std::shared_ptr<ILinkMixin>;
+using LinkPtr = std::shared_ptr<ILink<ILinkMixin>>;
 
 class ILinkMixin {
 public:
 	virtual ~ILinkMixin() = default;
-	virtual void linkChild(const NodePtr& child) = 0;
+	virtual void linkChild(const MixinPtr& child) = 0;
 	virtual void unlinkParent() = 0;
 	virtual LinkPtr getLink() = 0;
 };

include/ifaces/INode.h

@@ -2,6 +2,8 @@
 #include "ifaces/ILinkMixin.h"
 #include <string>
 
+class INode;
+
 using NodePtr = std::shared_ptr<INode>;
 
 class INode : public virtual ILinkMixin {

include/links/BaseLink.h

@@ -1,16 +1,18 @@
 #pragma once
-#include "ifaces/ILink.h"
-#include "ifaces/INode.h"
+#include <vector>
 #include <algorithm>
 
-class BaseLink : public ILink {
+#include "ifaces/ILink.h"
+
+template <class TElem>
+class BaseLink : public ILink<TElem> {
 public:
-	explicit BaseLink(NodePtr node) : owner_node_(node) {}
-	NodePtr getNode() const override { return owner_node_.lock(); }
-	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 {
+	BaseLink(std::shared_ptr<TElem> node) : owner_node_(node) {}
+	std::shared_ptr<TElem> getNode() const override { return owner_node_.lock(); }
+	std::shared_ptr<TElem> getParent() const override { return parent_.lock(); }
+	void setParent(const std::shared_ptr<TElem>& parent) override { parent_ = parent; }
+	const std::vector<std::shared_ptr<TElem>>& getChildren() const override { return children_; }
+	void removeChild(const std::shared_ptr<TElem>& child) override {
 		children_.erase(std::remove(children_.begin(), children_.end(), child), children_.end());
 	}
 
@@ -18,7 +20,7 @@ public:
 		std::cout << "--- Destructor called for: " << "BaseLink" << "\n";
 	}
 protected:
-	std::vector<NodePtr> children_;
-	std::weak_ptr<INode> owner_node_;
-	std::weak_ptr<INode> parent_;
+	std::vector<std::shared_ptr<TElem>> children_;
+	std::weak_ptr<TElem> owner_node_;
+	std::weak_ptr<TElem> parent_;
 };

include/links/OneToManyLink.h

@@ -1,8 +1,9 @@
 #pragma once
 #include "links/BaseLink.h"
 
-class OneToManyLink : public BaseLink {
+template <class TElem>
+class OneToManyLink : public BaseLink<TElem> {
 public:
-	using BaseLink::BaseLink;
-	void addChild(const NodePtr& child) override { children_.push_back(child); }
+	OneToManyLink(std::shared_ptr<TElem> e) : BaseLink<TElem>(e) {}
+	void addChild(const std::shared_ptr<TElem>& child) override { this->children_.push_back(child); }
 };

include/mixins/BaseLinkMixin.h

@@ -1,26 +1,23 @@
 #pragma once
 #include <iostream>
-#include "ifaces/INode.h"
-#include "ifaces/ILinkMixin.h"
-#include "links/LeafLink.h"
-#include "links/OneToManyLink.h"
 #include <memory>
 
+#include "ifaces/ILinkMixin.h"
+
 class BaseLinkMixin : public virtual ILinkMixin,
-		      public virtual INode,
-		      public std::enable_shared_from_this<INode> {
+		      public std::enable_shared_from_this<ILinkMixin> {
 public:
-	void linkChild(const NodePtr& childNode) override {
-		LinkPtr childLink = childNode->getLink();
+	void linkChild(const MixinPtr& child) override {
+		LinkPtr childLink = child->getLink();
 		childLink->setParent(getNode());
 
-		getLink()->addChild(childNode);
+		getLink()->addChild(child);
 	}
 
 	void unlinkParent() override {
 		LinkPtr link = getLink();
 
-		NodePtr parent = link->getParent();
+		MixinPtr parent = link->getParent();
 		if (!parent)
 			throw std::logic_error("Have no parent!");
 
@@ -35,7 +32,7 @@ public:
 	}
 
 protected:
-	NodePtr getNode() {
+	MixinPtr getNode() {
 		return shared_from_this();
 	}
 };

include/mixins/LazyLinkMixin.h

@@ -19,14 +19,16 @@ public:
 		return this->link_;
 	}
 
+	LazyLinkMixin() {}
+
 	~LazyLinkMixin() override {
 		std::cout << "--- Destructor called for: " << "LazyLinkMixin" << "\n";
 	}
 
 protected:
 	void lazyInit() {
-		if (!this->link_) {
-			this->link_ = std::make_shared<TLink>(
+		if (!link_) {
+			link_ = std::make_shared<TLink>(
 					BaseLinkMixin::getNode());
 		}
 	}

include/nodes/BaseNode.h

@@ -1,8 +1,8 @@
 #pragma once
-#include "mixins/LazyLinkMixin.h"
-#include "ifaces/INode.h"
 #include <iostream>
 
+#include "ifaces/INode.h"
+
 class BaseNode : public virtual INode {
 public:
 	BaseNode(std::string name) : name_(std::move(name)) {

include/nodes/SimpleNode.h

@@ -1,9 +1,12 @@
 #pragma once
-#include "nodes/BaseNode.h"
 #include <iostream>
 
+#include "nodes/BaseNode.h"
+#include "mixins/LazyLinkMixin.h"
+#include "links/OneToManyLink.h"
+
 class SimpleNode : public BaseNode,
-		   public LazyLinkMixin<OneToManyLink> {
+		   virtual public LazyLinkMixin<OneToManyLink<ILinkMixin>> {
 public:
 	~SimpleNode() {
 		std::cout << "--- Simple destructor called for: " << name_ << "\n";