BidirectionalMap.mpp

module;

#include <CppUtils/System/Compiler.hpp>

export module CppUtils.Container.BidirectionalMap;

import std;

namespace std
{
	template<class First, class Second>
	struct hash<std::pair<First, Second>>
	{
		[[nodiscard]] inline auto operator()(const std::pair<First, Second>& pair) const -> std::size_t
		{
			auto hash1 = std::hash<First>{}(pair.first);
			auto hash2 = std::hash<Second>{}(pair.second);
			return hash1 ^ (hash2 << 1);
		}
	};
}

export namespace CppUtils::Container
{
	template<class Lhs, class Rhs>
	struct BidirectionalMap final
	{
		using Set = std::unordered_set<std::pair<Lhs, Rhs>>;

	public:
		inline BidirectionalMap() = default;
		explicit inline BidirectionalMap(std::initializer_list<typename Set::value_type> values):
			values{values}
		{}

		[[nodiscard]] constexpr inline auto begin(this auto&& self) -> decltype(auto)
		{
			return std::begin(self.values);
		}

		[[nodiscard]] constexpr inline auto cbegin() const -> decltype(auto)
		{
			return std::cbegin(values);
		}

		[[nodiscard]] constexpr inline auto end(this auto&& self) -> decltype(auto)
		{
			return std::end(self.values);
		}
		[[nodiscard]] constexpr inline auto cend() const -> decltype(auto)
		{
			return std::cend(values);
		}

		[[nodiscard]] inline constexpr auto empty() const noexcept -> bool
		{
			return std::empty(values);
		}

		[[nodiscard]] inline constexpr auto size() const noexcept -> std::size_t
		{
			return std::size(values);
		}

		inline auto clear() noexcept -> void
		{
			values.clear();
		}

		inline auto insert(Set::value_type&& value) -> void
		{
			values.insert(value);
		}

		[[nodiscard]] inline auto findLeft(const Lhs& lhs) -> decltype(auto)
		{
			return std::find_if(std::cbegin(values), std::cend(values), [&lhs](auto&& pair) -> bool { return pair.first == lhs; });
		}

		[[nodiscard]] inline auto findRight(const Rhs& rhs) -> decltype(auto)
		{
			return std::find_if(std::cbegin(values), std::cend(values), [&rhs](auto&& pair) -> bool { return pair.second == rhs; });
		}

		[[nodiscard]] inline auto left(const Lhs& lhs) -> decltype(auto)
		{
			if (auto it = findLeft(lhs); it == std::cend(values))
				throw std::runtime_error{"Missing key in BidirectionalMap"};
			else
				return it->second;
		}

		[[nodiscard]] inline auto right(const Rhs& rhs) -> decltype(auto)
		{
			if (auto it = findRight(rhs); it == std::cend(values))
				throw std::runtime_error{"Missing key in BidirectionalMap"};
			else
				return it->first;
		}

		inline auto eraseLeft(const Lhs& lhs) noexcept -> void
		{
			std::erase_if(values, [&lhs](auto&& pair) -> bool { return pair.first == lhs; });
		}
		inline auto eraseRight(const Rhs& rhs) noexcept -> void
		{
			std::erase_if(values, [&rhs](auto&& pair) -> bool { return pair.second == rhs; });
		}

	private:
		Set values;
	};
}