MeshNetwork.mpp

export module CppUtils.Container.MeshNetwork;

import std;
import CppUtils.Thread.SharedLocker;
import CppUtils.Container.NetworkPtr;

export namespace CppUtils::Container
{
	template<class Key, class Value>
	struct MeshNode final
	{
		using SharedPtr = NetworkPtr<MeshNode<Key, Value>>::SharedPtr;
		using WeakPtr = NetworkPtr<MeshNode<Key, Value>>::WeakPtr;

		explicit inline MeshNode(auto&&... args):
			value{std::forward<decltype(args)>(args)...}
		{}

		[[nodiscard]] inline auto operator[](const Key& key) const -> const auto&
		{
			return m_branches.at(key);
		}

		[[nodiscard]] inline auto operator[](const Key& key) -> decltype(auto)
		{
			return m_branches[key];
		}

		static inline auto attach(SharedPtr& node0, const Key& key1, SharedPtr& node1) -> void
		{
			auto node0Accessor = node0->uniqueAccess();
			node0Accessor->attachChild(node1);
			node0Accessor->value[key1].push_back(node1);
		}

		static inline auto detach(SharedPtr& node0, const Key& key1, SharedPtr& node1) -> void
		{
			auto node0Accessor = node0->uniqueAccess();
			node0Accessor->value.erase(key1);
			node0Accessor->detachChild(node1);
		}

		static inline auto attach(const Key& key0, SharedPtr& node0, const Key& key1, SharedPtr& node1) -> void
		{
			attach(node0, key1, node1);
			attach(node1, key0, node0);
		}

		static inline auto detach(const Key& key0, SharedPtr& node0, const Key& key1, SharedPtr& node1) -> void
		{
			detach(node0, key1, node1);
			detach(node1, key0, node0);
		}

		Value value;

	private:
		std::unordered_map<Key, std::vector<WeakPtr>> m_branches;
	};

	template<class Key, class Value>
	using MeshNodePtr = NetworkPtr<MeshNode<Key, Value>>;
}