Refactor node group handling. Grouped node list is not owned by the group, it is the responsibility of NodeManager from now.

Author: kovacsv

Sources/NodeEngine/NE_NodeGroup.cpp

@@ -11,61 +11,20 @@ NodeGroup::NodeGroup ()
 
 }
 
-NodeGroup::NodeGroup (const NodeCollection& nodes) :
-	nodes (nodes)
-{
-
-}
-
 NodeGroup::~NodeGroup ()
 {
 
 }
 
-bool NodeGroup::IsEmpty () const
-{
-	return nodes.IsEmpty ();
-}
-
-bool NodeGroup::ContainsNode (const NodeId& nodeId) const
-{
-	return nodes.Contains (nodeId);
-}
-
-bool NodeGroup::AddNode (const NodeId& nodeId)
-{
-	if (nodes.Contains (nodeId)) {
-		return false;
-	}
-	nodes.Insert (nodeId);
-	return true;
-}
-
-bool NodeGroup::DeleteNode (const NodeId& nodeId)
-{
-	if (!nodes.Contains (nodeId)) {
-		return false;
-	}
-	nodes.Erase (nodeId);
-	return true;
-}
-
-const NodeCollection& NodeGroup::GetNodes () const
-{
-	return nodes;
-}
-
 Stream::Status NodeGroup::Read (InputStream& inputStream)
 {
 	ObjectHeader header (inputStream);
-	nodes.Read (inputStream);
 	return inputStream.GetStatus ();
 }
 
 Stream::Status NodeGroup::Write (OutputStream& outputStream) const
 {
 	ObjectHeader header (outputStream, serializationInfo);
-	nodes.Write (outputStream);
 	return outputStream.GetStatus ();
 }
 
@@ -86,15 +45,4 @@ NodeGroupPtr NodeGroup::Clone (const NodeGroupConstPtr& node)
 	return result;
 }
 
-bool NodeGroup::IsEqual (const NodeGroupConstPtr& aNode, const NodeGroupConstPtr& bNode)
-{
-	MemoryOutputStream aStream;
-	MemoryOutputStream bStream;
-
-	aNode->Write (aStream);
-	bNode->Write (bStream);
-
-	return aStream.GetBuffer () == bStream.GetBuffer ();
-}
-
 }

Sources/NodeEngine/NE_NodeGroup.hpp

@@ -17,24 +17,12 @@ class NodeGroup : public DynamicSerializable
 
 public:
 	NodeGroup ();
-	NodeGroup (const NodeCollection& nodes);
 	~NodeGroup ();
 
-	bool					IsEmpty () const;
-	bool					ContainsNode (const NodeId& nodeId) const;
-
-	bool					AddNode (const NodeId& nodeId);
-	bool					DeleteNode (const NodeId& nodeId);
-	const NodeCollection&	GetNodes () const;
-
 	virtual Stream::Status	Read (InputStream& inputStream) override;
 	virtual Stream::Status	Write (OutputStream& outputStream) const override;
 
-	static NodeGroupPtr		Clone (const NodeGroupConstPtr& group);
-	static bool				IsEqual (const NodeGroupConstPtr& aGroup, const NodeGroupConstPtr& bGroup);
-
-protected:
-	NodeCollection nodes;
+	static NodeGroupPtr		Clone (const NodeGroupConstPtr& node);
 };
 
 }

Sources/NodeEngine/NE_NodeGroupList.cpp

@@ -36,53 +36,63 @@ void NodeGroupList::Enumerate (const std::function<bool (const NodeGroupPtr&)>&
 
 bool NodeGroupList::AddGroup (const NodeGroupPtr& group)
 {
-	NodeCollection nodes = group->GetNodes ();
-	nodes.Enumerate ([&] (const NodeId& nodeId) {
-		RemoveNodeFromGroup (nodeId);
-		nodeToGroup.insert ({ nodeId, group });
-		return true;
-	});
-
 	groups.push_back (group);
+	groupToNodes.insert ({ group, NodeCollection () });
 	return true;
 }
 
-void NodeGroupList::DeleteGroup (const NodeGroupPtr& group)
+void NodeGroupList::DeleteGroup (const NodeGroupConstPtr& group)
 {
-	NodeCollection nodes = group->GetNodes ();
+	const NodeCollection& nodes = GetGroupNodes (group);
 	nodes.Enumerate ([&] (const NodeId& nodeId) {
-		RemoveNodeFromGroup (nodeId);
+		nodeToGroup.erase (nodeId);
 		return true;
 	});
+	auto foundInGroups = std::find (groups.begin (), groups.end (), group);
+	groups.erase (foundInGroups);
+	groupToNodes.erase (group);
 }
 
-NodeGroupPtr NodeGroupList::GetGroup (const NodeId& nodeId)
+void NodeGroupList::AddNodeToGroup (const NodeGroupPtr& group, const NodeId& nodeId)
 {
-	auto found = nodeToGroup.find (nodeId);
-	if (found == nodeToGroup.end ()) {
-		return nullptr;
-	}
-	return found->second;
+	RemoveNodeFromGroup (nodeId);
+	groupToNodes[group].Insert (nodeId);
+	nodeToGroup.insert ({ nodeId, group });
+}
+
+const NodeCollection& NodeGroupList::GetGroupNodes (const NodeGroupConstPtr& group) const
+{
+	return groupToNodes.at (group);
 }
 
 void NodeGroupList::RemoveNodeFromGroup (const NodeId& nodeId)
 {
-	NodeGroupPtr group = GetGroup (nodeId);
+	NodeGroupConstPtr group = GetNodeGroup (nodeId);
 	if (group == nullptr) {
 		return;
 	}
-	group->DeleteNode (nodeId);
-	if (group->IsEmpty ()) {
-		auto foundInGroups = std::find (groups.begin (), groups.end (), group);
-		DBGASSERT (foundInGroups != groups.end ());
-		groups.erase (foundInGroups);
-	}
+
+	NodeCollection& nodes = groupToNodes[group];
+	nodes.Erase (nodeId);
 	nodeToGroup.erase (nodeId);
+	if (nodes.IsEmpty ()) {
+		DeleteGroup (group);
+	}
+}
+
+NodeGroupConstPtr NodeGroupList::GetNodeGroup (const NodeId& nodeId) const
+{
+	auto found = nodeToGroup.find (nodeId);
+	if (found == nodeToGroup.end ()) {
+		return nullptr;
+	}
+	return found->second;
 }
 
 void NodeGroupList::Clear ()
 {
 	groups.clear ();
+	groupToNodes.clear ();
 	nodeToGroup.clear ();
 }
 
@@ -94,10 +104,11 @@ Stream::Status NodeGroupList::Read (InputStream& inputStream)
 	inputStream.Read (groupCount);
 	for (size_t i = 0; i < groupCount; i++) {
 		NodeGroupPtr group (ReadDynamicObject<NodeGroup> (inputStream));
-		const NodeCollection& nodes = group->GetNodes ();
-		groups.push_back (group);
+		NodeCollection nodes;
+		nodes.Read (inputStream);
+		AddGroup (group);
 		nodes.Enumerate ([&] (const NodeId& nodeId) {
-			nodeToGroup.insert ({ nodeId, group });
+			AddNodeToGroup (group, nodeId);
 			return true;
 		});
 	}
@@ -108,8 +119,10 @@ Stream::Status NodeGroupList::Write (OutputStream& outputStream) const
 {
 	ObjectHeader header (outputStream, serializationInfo);
 	outputStream.Write (groups.size ());
-	for (const NodeGroupPtr& group : groups) {
+	for (const NodeGroupConstPtr& group : groups) {
 		WriteDynamicObject (outputStream, group.get ());
+		const NodeCollection& nodes = groupToNodes.at (group);
+		nodes.Write (outputStream);
 	}
 	return outputStream.GetStatus ();
 }

Sources/NodeEngine/NE_NodeGroupList.hpp

@@ -17,21 +17,26 @@ class NodeGroupList
 	NodeGroupList ();
 	~NodeGroupList ();
 
-	void			Enumerate (const std::function<bool (const NodeGroupConstPtr&)>& processor) const;
-	void			Enumerate (const std::function<bool (const NodeGroupPtr&)>& processor);
+	void					Enumerate (const std::function<bool (const NodeGroupConstPtr&)>& processor) const;
+	void					Enumerate (const std::function<bool (const NodeGroupPtr&)>& processor);
 
-	bool			AddGroup (const NodeGroupPtr& group);
-	void			DeleteGroup (const NodeGroupPtr& group);
-	NodeGroupPtr	GetGroup (const NodeId& nodeId);
-	void			RemoveNodeFromGroup (const NodeId& nodeId);
-	void			Clear ();
+	bool					AddGroup (const NodeGroupPtr& group);
+	void					DeleteGroup (const NodeGroupConstPtr& group);
 
-	Stream::Status	Read (InputStream& inputStream);
-	Stream::Status	Write (OutputStream& outputStream) const;
+	void					AddNodeToGroup (const NodeGroupPtr& group, const NodeId& nodeId);
+	void					RemoveNodeFromGroup (const NodeId& nodeId);
+	const NodeCollection&	GetGroupNodes (const NodeGroupConstPtr& group) const;
+	NodeGroupConstPtr		GetNodeGroup (const NodeId& nodeId) const;
+
+	void					Clear ();
+
+	Stream::Status			Read (InputStream& inputStream);
+	Stream::Status			Write (OutputStream& outputStream) const;
 
 private:
-	std::vector<NodeGroupPtr>					groups;
-	std::unordered_map<NodeId, NodeGroupPtr>	nodeToGroup;	
+	std::vector<NodeGroupPtr>								groups;
+	std::unordered_map<NodeGroupConstPtr, NodeCollection>	groupToNodes;
+	std::unordered_map<NodeId, NodeGroupConstPtr>			nodeToGroup;
 };
 
 }

Sources/NodeEngine/NE_NodeManager.cpp

@@ -425,19 +425,25 @@ void NodeManager::DeleteNodeGroup (const NodeGroupPtr& group)
 	return nodeGroupList.DeleteGroup (group);
 }
 
-void NodeManager::DeleteAllNodeGroups ()
+void NodeManager::AddNodeToGroup (const NodeGroupPtr& group, const NodeId& nodeId)
 {
-	nodeGroupList.Clear ();
+	DBGASSERT (ContainsNode (nodeId));
+	nodeGroupList.AddNodeToGroup (group, nodeId);
 }
 
-NodeGroupPtr NodeManager::GetNodeGroup (const NodeId& nodeId)
+void NodeManager::RemoveNodeFromGroup (const NodeId& nodeId)
 {
-	return nodeGroupList.GetGroup (nodeId);
+	nodeGroupList.RemoveNodeFromGroup (nodeId);
 }
 
-void NodeManager::RemoveNodeFromGroup (const NodeId& nodeId)
+NodeGroupConstPtr NodeManager::GetNodeGroup (const NodeId& nodeId) const
 {
-	nodeGroupList.RemoveNodeFromGroup (nodeId);
+	return nodeGroupList.GetNodeGroup (nodeId);
+}
+
+const NodeCollection& NodeManager::GetGroupNodes (const NodeGroupConstPtr& group) const
+{
+	return nodeGroupList.GetGroupNodes (group);
 }
 
 void NodeManager::EnumerateNodeGroups (const std::function<bool (const NodeGroupConstPtr&)>& processor) const
@@ -450,6 +456,11 @@ void NodeManager::EnumerateNodeGroups (const std::function<bool (const NodeGroup
 	nodeGroupList.Enumerate (processor);
 }
 
+void NodeManager::DeleteAllNodeGroups ()
+{
+	nodeGroupList.Clear ();
+}
+
 bool NodeManager::IsCalculationEnabled () const
 {
 	return updateMode == UpdateMode::Automatic || isForceCalculate;