invertible_map.h

Go to the documentation of this file.

#ifndef META_INVERTIBLE_MAP_H_
#define META_INVERTIBLE_MAP_H_

#include <fstream>
#include <iterator>
#include <utility>
#include <map>
#include <unordered_map>
#include <string>

namespace meta
{
namespace util
{

template <class Key, class Value>
class invertible_map
{
  public:
    invertible_map();

    bool empty() const;

    size_t size() const;

    Key get_key(const Value& value) const;

    Value get_value(const Key& key) const;

    bool contains_key(const Key& key) const;

    bool contains_value(const Value& value) const;

    void insert(const Key& key, const Value& value);

    void insert(const std::pair<Key, Value>& pair);

    void clear();

    typedef typename std::unordered_map
        <Key, Value>::const_iterator InnerIterator;

    class Iterator : public std::iterator
                     <std::bidirectional_iterator_tag, InnerIterator>
    {
      private:
        InnerIterator iter;

      public:
        Iterator()
        {
            /* nothing */
        }

        Iterator(const InnerIterator& other) : iter{other}
        {
            /* nothing */
        }

        Iterator& operator++()
        {
            ++iter;
            return *this;
        }

        Iterator operator++(int)
        {
            InnerIterator save = iter;
            ++iter;
            return Iterator{save};
        }

        Iterator& operator--()
        {
            --iter;
            return *this;
        }

        Iterator operator--(int)
        {
            InnerIterator save = iter;
            --iter;
            return Iterator{save};
        }

        bool operator==(const Iterator& other)
        {
            return iter == other.iter;
        }

        bool operator!=(const Iterator& other)
        {
            return iter != other.iter;
        }

        const typename InnerIterator::value_type& operator*()
        {
            return *iter;
        }

        const typename InnerIterator::value_type* operator->()
        {
            return &(*iter);
        }
    };

    typedef Iterator iterator;

    typedef Iterator const_iterator;

    const_iterator begin() const;

    const_iterator end() const;

  private:
    std::unordered_map<Key, Value> forward_;

    std::unordered_map<Value, Key> backward_;

  public:
    class invertible_map_exception : public std::runtime_error
    {
      public:
        using std::runtime_error::runtime_error;
    };
};
}
}

#include "util/invertible_map.tcc"
#endif