unique_map.hh

Go to the documentation of this file.

#ifndef CASM_unique_map_HH
#define CASM_unique_map_HH
 
#include <functional>
#include <map>
 
#include "casm/misc/CASM_TMP.hh"
#include "casm/misc/cloneable_ptr.hh"
 
namespace notstd {
 
template <typename TransformFunc, typename MapIteratorType>
class UniqueMapIterator {
 public:
  typedef std::bidirectional_iterator_tag iterator_category;
  typedef typename MapIteratorType::difference_type difference_type;
  typedef typename std::result_of<TransformFunc(
      typename MapIteratorType::reference)>::type reference;
  typedef typename std::remove_reference<reference>::type value_type;
  typedef value_type *pointer;
 
  UniqueMapIterator() {}
 
  explicit UniqueMapIterator(MapIteratorType map_it)
      : m_it(map_it), m_transform(TransformFunc()) {}
 
  template <typename T, typename M>
  UniqueMapIterator(const UniqueMapIterator<T, M> &umap_it)
      : m_it(umap_it.base()), m_transform(TransformFunc()) {}
 
  template <typename T, typename M>
  bool operator==(const UniqueMapIterator<T, M> &B) const {
    return (!operator!=(B));
  }
 
  template <typename T, typename M>
  bool operator!=(const UniqueMapIterator<T, M> &B) const {
    return m_it != B.base();
  }
 
  int type() const { return m_it->first; }
 
  reference operator*() const { return m_transform(*m_it); }
 
  pointer operator->() const { return &(this->operator*()); }
 
  // prefix
  UniqueMapIterator &operator++() {
    ++m_it;
    return *this;
  }
 
  // postfix
  UniqueMapIterator operator++(int) {
    UniqueMapIterator result(*this);
    ++m_it;
    return result;
  }
 
  // prefix
  UniqueMapIterator &operator--() {
    --m_it;
    return *this;
  }
 
  // postfix
  UniqueMapIterator operator--(int) {
    UniqueMapIterator result(*this);
    --m_it;
    return result;
  }
 
  MapIteratorType base() const { return m_it; }
 
 private:
  MapIteratorType m_it;
  TransformFunc m_transform;
};
 
template <typename MapType>
struct GetSecond {
  typedef typename MapType::iterator::reference reference;
  typedef typename MapType::iterator::value_type::second_type &result_type;
 
  GetSecond() {}
 
  result_type operator()(reference pair) const { return pair.second; }
};
 
template <typename MapType>
struct GetSecondConst {
  typedef typename MapType::const_iterator::reference reference;
  typedef const typename MapType::const_iterator::value_type::second_type
      &result_type;
 
  GetSecondConst() {}
 
  result_type operator()(reference pair) const { return pair.second; }
};
 
template <typename KeyType, typename ValueType,
          typename MapType = std::map<KeyType, ValueType>,
          typename TransformFunction = GetSecond<MapType>,
          typename ConstTransformFunction = GetSecondConst<MapType> >
class unique_map {
 public:
  typedef ValueType value_type;
  typedef KeyType key_type;
  typedef std::function<KeyType(const ValueType &)> KeyFuncType;
  typedef std::function<typename MapType::mapped_type(const ValueType &)>
      ConvertType;
  typedef ValueType &reference;
  typedef ValueType *pointer;
 
  typedef typename MapType::iterator MapIterator;
  typedef typename MapType::const_iterator ConstMapIterator;
 
  typedef UniqueMapIterator<TransformFunction, MapIterator> iterator;
  typedef UniqueMapIterator<ConstTransformFunction, ConstMapIterator>
      const_iterator;
 
  typedef typename MapType::size_type size_type;
 
  explicit unique_map(KeyFuncType keyfunc, ConvertType _converter)
      : m_keyfunc(keyfunc), m_converter(_converter) {}
 
  key_type key(const value_type &value) const { return m_keyfunc(value); }
 
  std::pair<iterator, bool> insert(const value_type &value) {
    return _insert(value);
  }
 
  iterator insert(const_iterator hint, const value_type &value) {
    return iterator(m_map.insert(
        hint.base(),
        std::make_pair(key(value), std::move(m_converter(value)))));
  }
 
  iterator insert(iterator hint, const value_type &value) {
    return iterator(m_map.insert(
        hint.base(),
        std::make_pair(key(value), std::move(m_converter(value)))));
  }
 
  template <typename... ValuesOrMaps>
  void insert(const ValuesOrMaps &... more) {
    CASM::CASM_TMP::ignore_returnvalues(_insert(more)...);
  }
 
  template <typename Iterator>
  void insert(
      Iterator begin, Iterator end,
      typename CASM::CASM_TMP::enable_if_iterator<Iterator>::type * = nullptr) {
    for (auto it = begin; it != end; ++it) {
      _insert(*it);
    }
  }
 
  value_type &operator[](const key_type &key) {
    // insert if not existing
    m_map[key];
 
    // return reference
    return *find(key);
  }
 
  iterator find(const key_type &key) { return iterator(m_map.find(key)); }
 
  const_iterator find(const key_type &key) const {
    return const_iterator(m_map.find(key));
  }
 
  void clear() { m_map.clear(); }
 
  iterator erase(const_iterator pos) {
    return iterator(m_map.erase(pos.base()));
  }
 
  iterator erase(const_iterator first, const_iterator last) {
    return iterator(m_map.erase(first.base(), last.base()));
  }
 
  size_type erase(const key_type &key) { return m_map.erase(key); }
 
  size_type size() const { return m_map.size(); }
 
  bool empty() const { return m_map.empty(); }
 
  iterator begin() { return iterator(m_map.begin()); }
 
  const_iterator begin() const { return const_iterator(m_map.begin()); }
 
  const_iterator cbegin() const { return const_iterator(m_map.cbegin()); }
 
  iterator end() { return iterator(m_map.end()); }
 
  const_iterator end() const { return const_iterator(m_map.end()); }
 
  const_iterator cend() const { return const_iterator(m_map.cend()); }
 
 private:
  std::pair<iterator, bool> _insert(const value_type &value) {
    auto result =
        m_map.insert(std::make_pair(key(value), std::move(m_converter(value))));
    return std::make_pair(iterator(result.first), result.second);
  }
 
  template <typename A, typename B, typename C, typename D, typename E>
  int _insert(const unique_map<A, B, C, D, E> &value) {
    insert(value.begin(), value.end());
    return 0;
  }
 
  MapType m_map;
  KeyFuncType m_keyfunc;
  ConvertType m_converter;
};
 
}  // namespace notstd
 
#endif