chilon Code

#ifndef CHILON_VECTOR_HASH_MAP_HPP
#define CHILON_VECTOR_HASH_MAP_HPP

#include <chilon/detail/vector_hash_map.hpp>
#include <chilon/key_value.hpp>
#include <chilon/meta/return.hpp>
#include <chilon/safe_iterator.hpp>
#include <chilon/append.hpp>

#include <unordered_map>
#include <vector>

namespace chilon {

template <class T, class H = std::hash<typename T::first_type>>
class vector_hash_map;

template <class K, class V, class C, class H>
class vector_hash_map< key_value<K, V, C>, H>
  : public detail::vector_hash_map
{
    typedef vector_hash_map<key_value<K, V, C>, H> self;
    typedef detail::vector_hash_index<C>           collision_t;

  public:
    // store key indexes
    typedef std::unordered_map<K, int, H>       unordered_map;
    typedef typename unordered_map::value_type  hash_value_type;

    typedef std::vector<key_value<K, V, C>>  vector;
    typedef typename vector::value_type      value_type;
    typedef typename vector::reference       reference;
    typedef typename vector::iterator        iterator;
    typedef typename vector::const_iterator  const_iterator;
    typedef std::pair<iterator, bool>        insert_type;

  private:
    vector         vector_;
    unordered_map  hash_;

  public:
    // these return an iterator that is safe after insert
    safe_iterator<vector const> safe_ordered_begin() const {
        return safe_iterator<vector const>(vector_);
    }

    safe_iterator<vector> safe_ordered_begin() {
        return safe_iterator<vector>(vector_);
    }

    const_iterator find(K const& k) const {
        auto it = hash_.find(k);
        if (it == hash_.end()) return vector_.end();
        else return vector_.begin() + it->second;
    }

    iterator find(K const& k) {
        auto it = hash_.find(k);
        if (it == hash_.end()) return vector_.end();
        else return vector_.begin() + it->second;
    }

    const_iterator begin() const { return vector_.begin(); }
    const_iterator end()   const { return vector_.end(); }
    iterator       begin()       { return vector_.begin(); }
    iterator       end()         { return vector_.end(); }

    auto empty() const CHILON_RETURN(vector_.empty())
    auto size()  const CHILON_RETURN(vector_.size())

    auto count(K const& k) const CHILON_RETURN(hash_.count(k))

    insert_type insert(value_type const& value) {
        auto mapIt = hash_.insert(hash_value_type(value.first, vector_.size()));

        if (mapIt.second) {
            vector_.push_back(value);
            return insert_type(vector_.end() - 1, true);
        }
        else return
            collision_t::insert(begin() + mapIt.first->second, value);
    }

    insert_type emplace(value_type&& value) {
        auto mapIt = hash_.insert(hash_value_type(value.first, vector_.size()));

        if (mapIt.second) {
            vector_.push_back(std::move(value));
            return insert_type(vector_.end() - 1, true);
        }
        else return
            collision_t::insert(begin() + mapIt.first->second, std::move(value));
    }
};

template <class U, class T, class H>
static inline void append(vector_hash_map<T, H>& t, U const& u) {
    append_map(t, u);
}

template <class U, class T, class H>
static inline void append(vector_hash_map<T, H>& t, U&& u) {
    append_map(t, u);
}

}
#endif