BiMap.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <functional>
#include <unordered_map>
 
namespace Physics::Utils {
template <typename TLeft, typename TRight> class BiMap {
  public:
    BiMap() = default;
    ~BiMap() = default;
 
    BiMap(const BiMap &) = delete;
    BiMap &operator=(const BiMap &) = delete;
    BiMap(BiMap &&) noexcept = default;
    BiMap &operator=(BiMap &&) noexcept = default;
 
    void Add(const TLeft &left, const TRight &right)
    {
        if (auto existingIt = this->_leftToRight.find(left); existingIt != this->_leftToRight.end())
        {
            this->_rightToLeft.erase(existingIt->second);
        }
        if (auto existingRightIt = this->_rightToLeft.find(right); existingRightIt != this->_rightToLeft.end())
        {
            this->_leftToRight.erase(existingRightIt->second);
        }
        this->_leftToRight.insert_or_assign(left, right);
        this->_rightToLeft.insert_or_assign(right, left);
    }
    void Remove(const TLeft &left)
    {
        auto it = this->_leftToRight.find(left);
        if (it != this->_leftToRight.end())
        {
            this->_rightToLeft.erase(it->second);
            this->_leftToRight.erase(it);
        }
    }
    void Remove(const TRight &right)
    {
        auto it = this->_rightToLeft.find(right);
        if (it != this->_rightToLeft.end())
        {
            this->_leftToRight.erase(it->second);
            this->_rightToLeft.erase(it);
        }
    }
    auto Size() const { return static_cast<std::uint32_t>(this->_leftToRight.size()); }
    const TRight &Get(const TLeft &left) const { return this->_leftToRight.at(left); }
    const TLeft &Get(const TRight &right) const { return this->_rightToLeft.at(right); }
    bool Contains(const TLeft &left) const { return this->_leftToRight.contains(left); }
    bool Contains(const TRight &right) const { return this->_rightToLeft.contains(right); }
 
  private:
    std::unordered_map<TLeft, TRight> _leftToRight;
    std::unordered_map<TRight, TLeft> _rightToLeft;
};
} // namespace Physics::Utils