BidirectionalUnorderedMapping.hpp

Go to the documentation of this file.

 
#ifndef ECHOMAP_BIDIRECTIONALUNORDEREDMAPPING_HPP
#define ECHOMAP_BIDIRECTIONALUNORDEREDMAPPING_HPP
 
#include <cassert>
#include <unordered_map>
 
namespace echomap
{

template <typename Key, typename Value> class BidirectionalUnorderedMapping
{
    std::unordered_map<Key, Value> forward_map;

    std::unordered_map<Value, Key> reverse_map;
 
public:
    using iterator = decltype(forward_map)::iterator; 
    using const_iterator = decltype(forward_map)::const_iterator; 
 
    [[nodiscard]] const_iterator begin() const noexcept
    {
        return forward_map.begin();
    }
 
    [[nodiscard]] const_iterator cbegin() const noexcept
    {
        return forward_map.cbegin();
    }
 
    [[nodiscard]] const_iterator end() const noexcept
    {
        return forward_map.end();
    }
 
    [[nodiscard]] const_iterator cend() const noexcept
    {
        return forward_map.cend();
    }
 
    [[nodiscard]] bool empty() const noexcept
    {
        return forward_map.empty();
    }
 
    [[nodiscard]] std::size_t size() const noexcept
    {
        return forward_map.size();
    }

    void clear() noexcept
    {
        forward_map.clear();
        reverse_map.clear();
 
        assert(forward_map.empty());
        assert(reverse_map.empty());
    }

    template <
            typename KeyT,
            typename ValueT>
    std::pair<
            const_iterator,
            bool>
    emplace(
            KeyT&& key,
            ValueT&& value
    )
    {
        auto forward_insertion = forward_map.emplace(std::forward<KeyT>(key), std::forward<ValueT>(value));
        if (!forward_insertion.second)
            return {forward_insertion.first, false};
 
        try {
            const auto& inserted_key = forward_insertion.first->first;
            // ReSharper disable once CppTooWideScopeInitStatement - Intentionally wide for readability.
            const auto& inserted_value = forward_insertion.first->second;
 
            if (!reverse_map.emplace(inserted_value, inserted_key).second) {
                forward_map.erase(forward_insertion.first);
                return {forward_map.end(), false};
            }
        } catch (...) {
            forward_map.erase(forward_insertion.first);
            throw;
        }
 
        assert(forward_map.size() == reverse_map.size());
        return {forward_insertion.first, true};
    }

    bool erase_by_key(
            const Key& key
    )
    {
        const auto itr = forward_map.find(key);
        if (itr == forward_map.end())
            return false;
 
        reverse_map.erase(itr->second);
        forward_map.erase(itr);
 
        assert(forward_map.size() == reverse_map.size());
 
        return true;
    }

    bool erase_by_value(
            const Value& value
    )
    {
        const auto itr = reverse_map.find(value);
        if (itr == reverse_map.end())
            return false;
 
        forward_map.erase(itr->second);
        reverse_map.erase(itr);
 
        assert(forward_map.size() == reverse_map.size());
 
        return true;
    }

    const_iterator find_by_key(
            const Key& key
    ) const
    {
        return forward_map.find(key);
    }

    const_iterator find_by_value(
            const Value& value
    ) const
    {
        const auto reverse_map_it = reverse_map.find(value);
        if (reverse_map_it == reverse_map.end())
            return forward_map.end();
 
        const auto forward_map_it = forward_map.find(reverse_map_it->second);
        assert(forward_map_it != forward_map.end()); // Verify class invariant.
 
        return forward_map_it;
    }
};
 
} // namespace echomap
 
#endif // ECHOMAP_BIDIRECTIONALUNORDEREDMAPPING_HPP