// Copyright 2005 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// ---
//
// A dense hashtable is a particular implementation of
// a hashtable: one that is meant to minimize memory allocation.
// It does this by using an array to store all the data.  We
// steal a value from the key space to indicate "empty" array
// elements (ie indices where no item lives) and another to indicate
// "deleted" elements.
//
// (Note it is possible to change the value of the delete key
// on the fly; you can even remove it, though after that point
// the hashtable is insert_only until you set it again.  The empty
// value however can't be changed.)
//
// To minimize allocation and pointer overhead, we use internal
// probing, in which the hashtable is a single table, and collisions
// are resolved by trying to insert again in another bucket.  The
// most cache-efficient internal probing schemes are linear probing
// (which suffers, alas, from clumping) and quadratic probing, which
// is what we implement by default.
//
// Type requirements: value_type is required to be Move Constructible
// and Default Constructible. It is not required to be (and commonly
// isn't) Assignable.
//
// You probably shouldn't use this code directly.  Use dense_hash_map<>
// or dense_hash_set<> instead.

// You can change the following below:
// HT_OCCUPANCY_PCT      -- how full before we double size
// HT_EMPTY_PCT          -- how empty before we halve size
// HT_MIN_BUCKETS        -- default smallest bucket size
//
// You can also change enlarge_factor (which defaults to
// HT_OCCUPANCY_PCT), and shrink_factor (which defaults to
// HT_EMPTY_PCT) with set_resizing_parameters().
//
// How to decide what values to use?
// shrink_factor's default of .4 * OCCUPANCY_PCT, is probably good.
// HT_MIN_BUCKETS is probably unnecessary since you can specify
// (indirectly) the starting number of buckets at construct-time.
// For enlarge_factor, you can use this chart to try to trade-off
// expected lookup time to the space taken up.  By default, this
// code uses quadratic probing, though you can change it to linear
// via JUMP_ below if you really want to.
//
// From
// L = N / M,
// where N is the number of data items in the table and M is the table size.
// NUMBER OF PROBES / LOOKUP       Successful            Unsuccessful
// Quadratic collision resolution   1 - ln(1-L) - L/2    1/(1-L) - L - ln(1-L)
// Linear collision resolution     [1+1/(1-L)]/2         [1+1/(1-L)^2]/2
//
// -- enlarge_factor --           0.10  0.50  0.60  0.75  0.80  0.90  0.99
// QUADRATIC COLLISION RES.
//    probes/successful lookup    1.05  1.44  1.62  2.01  2.21  2.85  5.11
//    probes/unsuccessful lookup  1.11  2.19  2.82  4.64  5.81  11.4  103.6
// LINEAR COLLISION RES.
//    probes/successful lookup    1.06  1.5   1.75  2.5   3.0   5.5   50.5
//    probes/unsuccessful lookup  1.12  2.5   3.6   8.5   13.0  50.0  5000.0

#ifndef S2_UTIL_GTL_DENSEHASHTABLE_H_
#define S2_UTIL_GTL_DENSEHASHTABLE_H_

#include <cassert>
#include <cstddef>
#include <cstdio>              // for FILE, fwrite, fread
#include <algorithm>            // For swap(), eg
#include <functional>
#include <iterator>             // For iterator tags
#include <limits>               // for numeric_limits
#include <memory>               // For uninitialized_fill
#include <new>
#include <string>
#include <utility>
#include <vector>
#include <type_traits>

#include "s2/util/gtl/hashtable_common.h"
#include "s2/base/port.h"
#include <stdexcept>                 // For length_error

namespace gtl {


// Some files test for this symbol.
#define S2__DENSEHASHTABLE_H_

// The probing method
// Linear probing
// #define JUMP_(key, num_probes)    ( 1 )
// Quadratic probing
#define JUMP_(key, num_probes)    (num_probes)

// The weird mod in the offset is entirely to quiet compiler warnings
// as is the cast to int after doing the "x mod 256"
#define PUT_(take_from, offset)  do {                                    \
    if (putc(static_cast<int>(offset >= sizeof(take_from)*8)             \
                              ? 0 : ((take_from) >> (offset)) % 256, fp) \
        == EOF)                                                          \
    return false;                                                        \
} while (0)

#define GET_(add_to, offset)  do {                                      \
  if ((x=getc(fp)) == EOF)                                              \
    return false;                                                       \
  else if (offset >= sizeof(add_to) * 8)                                \
    assert(x == 0);   /* otherwise it's too big for us to represent */  \
  else                                                                  \
    add_to |= (static_cast<size_type>(x) << ((offset) % (sizeof(add_to)*8))); \
} while (0)


// Hashtable class, used to implement the hashed associative containers
// hash_set and hash_map.

// Value: what is stored in the table (each bucket is a Value).
// Key: something in a 1-to-1 correspondence to a Value, that can be used
//      to search for a Value in the table (find() takes a Key).
// HashFcn: Takes a Key and returns an integer, the more unique the better.
// ExtractKey: given a Value, returns the unique Key associated with it.
//             Must have a result_type enum indicating the return type of
//             operator().
// SetKey: given a Value* and a Key, modifies the value such that
//         ExtractKey(value) == key.  We guarantee this is only called
//         with key == deleted_key or key == empty_key.
// EqualKey: Given two Keys, says whether they are the same (that is,
//           if they are both associated with the same Value).
// Alloc: STL allocator to use to allocate memory.

template <class Value, class Key, class HashFcn,
          class ExtractKey, class SetKey, class EqualKey, class Alloc>
class dense_hashtable;

template <class V, class K, class HF, class ExK, class SetK, class EqK, class A>
struct dense_hashtable_const_iterator;

// We're just an array, but we need to skip over empty and deleted elements
template <class V, class K, class HF, class ExK, class SetK, class EqK, class A>
struct dense_hashtable_iterator {
 private:
  typedef typename A::template rebind<V>::other value_alloc_type;

 public:
  typedef dense_hashtable_iterator<V, K, HF, ExK, SetK, EqK, A>
      iterator;
  typedef dense_hashtable_const_iterator<V, K, HF, ExK, SetK, EqK, A>
      const_iterator;

  typedef std::forward_iterator_tag iterator_category;  // very little defined!
  typedef V value_type;
  typedef typename value_alloc_type::difference_type difference_type;
  typedef typename value_alloc_type::size_type size_type;
  typedef typename value_alloc_type::reference reference;
  typedef typename value_alloc_type::pointer pointer;

  // "Real" constructor and default constructor
  dense_hashtable_iterator(
      const dense_hashtable<V, K, HF, ExK, SetK, EqK, A> *h,
      pointer it, pointer it_end, bool advance)
    : ht(h), pos(it), end(it_end)   {
    if (advance)  advance_past_empty_and_deleted();
  }
  dense_hashtable_iterator() { }
  // The default destructor is fine; we don't define one
  // The default operator= is fine; we don't define one

  // Happy dereferencer
  reference operator*() const { return *pos; }
  pointer operator->() const { return &(operator*()); }

  // Arithmetic.  The only hard part is making sure that
  // we're not on an empty or marked-deleted array element
  void advance_past_empty_and_deleted() {
    while (pos != end && (ht->test_empty(*this) || ht->test_deleted(*this)) )
      ++pos;
  }
  iterator& operator++() {
    assert(pos != end);
    ++pos;
    advance_past_empty_and_deleted();
    return *this;
  }
  iterator operator++(int /*unused*/) {
    auto tmp(*this);
    ++*this;
    return tmp;
  }

  // Comparison.
  bool operator==(const iterator& it) const { return pos == it.pos; }
  bool operator!=(const iterator& it) const { return pos != it.pos; }


  // The actual data
  const dense_hashtable<V, K, HF, ExK, SetK, EqK, A> *ht;
  pointer pos, end;
};


// Now do it all again, but with const-ness!
template <class V, class K, class HF, class ExK, class SetK, class EqK, class A>
struct dense_hashtable_const_iterator {
 private:
  typedef typename A::template rebind<V>::other value_alloc_type;

 public:
  typedef dense_hashtable_iterator<V, K, HF, ExK, SetK, EqK, A>
      iterator;
  typedef dense_hashtable_const_iterator<V, K, HF, ExK, SetK, EqK, A>
      const_iterator;

  typedef std::forward_iterator_tag iterator_category;  // very little defined!
  typedef V value_type;
  typedef typename value_alloc_type::difference_type difference_type;
  typedef typename value_alloc_type::size_type size_type;
  typedef typename value_alloc_type::const_reference reference;
  typedef typename value_alloc_type::const_pointer pointer;

  // "Real" constructor and default constructor
  dense_hashtable_const_iterator(
      const dense_hashtable<V, K, HF, ExK, SetK, EqK, A> *h,
      pointer it, pointer it_end, bool advance)
    : ht(h), pos(it), end(it_end)   {
    if (advance)  advance_past_empty_and_deleted();
  }
  dense_hashtable_const_iterator()
    : ht(nullptr), pos(pointer()), end(pointer()) { }
  // This lets us convert regular iterators to const iterators
  dense_hashtable_const_iterator(const iterator &it)
    : ht(it.ht), pos(it.pos), end(it.end) { }
  // The default destructor is fine; we don't define one
  // The default operator= is fine; we don't define one

  // Happy dereferencer
  reference operator*() const { return *pos; }
  pointer operator->() const { return &(operator*()); }

  // Arithmetic.  The only hard part is making sure that
  // we're not on an empty or marked-deleted array element
  void advance_past_empty_and_deleted() {
    while (pos != end && (ht->test_empty(*this) || ht->test_deleted(*this)))
      ++pos;
  }
  const_iterator& operator++()   {
    assert(pos != end);
    ++pos;
    advance_past_empty_and_deleted();
    return *this;
  }
  const_iterator operator++(int /*unused*/) {
    auto tmp(*this);
    ++*this;
    return tmp;
  }

  // Comparison.
  bool operator==(const const_iterator& it) const { return pos == it.pos; }
  bool operator!=(const const_iterator& it) const { return pos != it.pos; }


  // The actual data
  const dense_hashtable<V, K, HF, ExK, SetK, EqK, A> *ht;
  pointer pos, end;
};

template <class Value, class Key, class HashFcn,
          class ExtractKey, class SetKey, class EqualKey, class Alloc>
class dense_hashtable {
 private:
  typedef typename Alloc::template rebind<Value>::other value_alloc_type;


 public:
  typedef Key key_type;
  typedef Value value_type;
  typedef HashFcn hasher;
  typedef EqualKey key_equal;
  typedef Alloc allocator_type;

  typedef typename value_alloc_type::size_type size_type;
  typedef typename value_alloc_type::difference_type difference_type;
  typedef typename value_alloc_type::reference reference;
  typedef typename value_alloc_type::const_reference const_reference;
  typedef typename value_alloc_type::pointer pointer;
  typedef typename value_alloc_type::const_pointer const_pointer;
  typedef dense_hashtable_iterator<Value, Key, HashFcn,
                                   ExtractKey, SetKey, EqualKey, Alloc>
  iterator;

  typedef dense_hashtable_const_iterator<Value, Key, HashFcn,
                                         ExtractKey, SetKey, EqualKey, Alloc>
  const_iterator;

  // These come from tr1.  For us they're the same as regular iterators.
  typedef iterator local_iterator;
  typedef const_iterator const_local_iterator;


  // How full we let the table get before we resize, by default.
  // Knuth says .8 is good -- higher causes us to probe too much,
  // though it saves memory.
  static const int HT_OCCUPANCY_PCT;  // defined at the bottom of this file

  // How empty we let the table get before we resize lower, by default.
  // (0.0 means never resize lower.)
  // It should be less than OCCUPANCY_PCT / 2 or we thrash resizing
  static const int HT_EMPTY_PCT;      // defined at the bottom of this file

  // Minimum size we're willing to let hashtables be.
  // Must be a power of two, and at least 4.
  // Note, however, that for a given hashtable, the initial size is a
  // function of the first constructor arg, and may be >HT_MIN_BUCKETS.
  static const size_type HT_MIN_BUCKETS = 4;

  // By default, if you don't specify a hashtable size at
  // construction-time, we use this size.  Must be a power of two, and
  // at least HT_MIN_BUCKETS.
  static const size_type HT_DEFAULT_STARTING_BUCKETS = 32;

  // ITERATOR FUNCTIONS
  iterator begin() {
    return iterator(this, table, table + num_buckets, true);
  }
  iterator end() {
    return iterator(this, table + num_buckets, table + num_buckets, true);
  }
  const_iterator begin() const {
    return const_iterator(this, table, table+num_buckets, true);
  }
  const_iterator end() const   {
    return const_iterator(this, table + num_buckets, table+num_buckets, true);
  }

  // These come from tr1 unordered_map.  They iterate over 'bucket' n.
  // We'll just consider bucket n to be the n-th element of the table.
  local_iterator begin(size_type i) {
    return local_iterator(this, table + i, table + i+1, false);
  }
  local_iterator end(size_type i) {
    local_iterator it = begin(i);
    if (!test_empty(i) && !test_deleted(i))
      ++it;
    return it;
  }
  const_local_iterator begin(size_type i) const {
    return const_local_iterator(this, table + i, table + i+1, false);
  }
  const_local_iterator end(size_type i) const {
    const_local_iterator it = begin(i);
    if (!test_empty(i) && !test_deleted(i))
      ++it;
    return it;
  }

  // ACCESSOR FUNCTIONS for the things we templatize on, basically
  hasher hash_funct() const               { return settings; }
  key_equal key_eq() const                { return key_info; }
  value_alloc_type get_allocator() const { return key_info; }

  // Accessor function for statistics gathering.
  int num_table_copies() const { return settings.num_ht_copies(); }

 private:
  // Annoyingly, we can't copy values around, because they might have
  // const components (they're probably std::pair<const X, Y>).  We use
  // explicit destructor invocation and placement new to get around
  // this.  Arg.
  static void set_value(pointer dst, const_reference src) {
    dst->~value_type();   // delete the old value, if any
    new(dst) value_type(src);
  }

  static void set_value(pointer dst, value_type&& src) {  // NOLINT
    dst->~value_type();
    new(dst) value_type(std::move(src));
  }

  void destroy_buckets(size_type first, size_type last) {
    for ( ; first != last; ++first)
      table[first].~value_type();
  }

  // DELETE HELPER FUNCTIONS
  // This lets the user describe a key that will indicate deleted
  // table entries.  This key should be an "impossible" entry --
  // if you try to insert it for real, you won't be able to retrieve it!
  // (NB: while you pass in an entire value, only the key part is looked
  // at.  This is just because I don't know how to assign just a key.)
 private:
  // Gets rid of any deleted entries we have.
  void squash_deleted() {
    if (num_deleted > 0) {
      rebucket(settings.min_buckets(size(), num_buckets));
    }
    assert(num_deleted == 0);
  }

  // Test if the given key is the deleted indicator.  Requires
  // num_deleted > 0, for correctness of read(), and because that
  // guarantees that key_info.delkey is valid.
  bool test_deleted_key(const key_type& key) const {
    assert(num_deleted > 0);
    return equals(key_info.delkey, key);
  }

 public:
  void set_deleted_key(const key_type &key) {
    // the empty indicator (if specified) and the deleted indicator
    // must be different
    assert((!settings.use_empty() || !equals(key, key_info.empty)) &&
           "Passed the empty-key to set_deleted_key");
    // It's only safe to change what "deleted" means if we purge deleted guys
    squash_deleted();
    settings.set_use_deleted(true);
    key_info.delkey = key;
  }
  key_type deleted_key() const {
    assert(settings.use_deleted()
           && "Must set deleted key before calling deleted_key");
    return key_info.delkey;
  }

  // These are public so the iterators can use them
  // True if the item at position bucknum is "deleted" marker
  bool test_deleted(size_type bucknum) const {
    // Invariant: !use_deleted() implies num_deleted is 0.
    assert(settings.use_deleted() || num_deleted == 0);
    return num_deleted > 0 && test_deleted_key(get_key(table[bucknum]));
  }
  bool test_deleted(const iterator &it) const {
    // Invariant: !use_deleted() implies num_deleted is 0.
    assert(settings.use_deleted() || num_deleted == 0);
    return num_deleted > 0 && test_deleted_key(get_key(*it));
  }
  bool test_deleted(const const_iterator &it) const {
    // Invariant: !use_deleted() implies num_deleted is 0.
    assert(settings.use_deleted() || num_deleted == 0);
    return num_deleted > 0 && test_deleted_key(get_key(*it));
  }

 private:
  void check_use_deleted(const char* caller) {
    (void)caller;    // could log it if the assert failed
    assert(settings.use_deleted());
  }

  // Write the deleted key to the position specified.
  // Requires: !test_deleted(it)
  void set_deleted(iterator &it) {
    check_use_deleted("set_deleted()");
    assert(!test_deleted(it));
    // &* converts from iterator to value-type.
    set_key(&(*it), key_info.delkey);
  }

  // We also allow to set/clear the deleted bit on a const iterator.
  // We allow a const_iterator for the same reason you can delete a
  // const pointer: it's convenient, and semantically you can't use
  // 'it' after it's been deleted anyway, so its const-ness doesn't
  // really matter.
  // Requires: !test_deleted(it)
  void set_deleted(const_iterator &it) {
    check_use_deleted("set_deleted()");
    assert(!test_deleted(it));
    set_key(const_cast<pointer>(&(*it)), key_info.delkey);
  }

  // EMPTY HELPER FUNCTIONS
  // This lets the user describe a key that will indicate empty (unused)
  // table entries.  This key should be an "impossible" entry --
  // if you try to insert it for real, you won't be able to retrieve it!
  // (NB: while you pass in an entire value, only the key part is looked
  // at.  This is just because I don't know how to assign just a key.)
 public:
  // These are public so the iterators can use them
  // True if the item at position bucknum is "empty" marker
  bool test_empty(size_type bucknum) const {
    assert(settings.use_empty());  // we always need to know what's empty!
    return equals(key_info.empty, get_key(table[bucknum]));
  }
  bool test_empty(const iterator &it) const {
    assert(settings.use_empty());  // we always need to know what's empty!
    return equals(key_info.empty, get_key(*it));
  }
  bool test_empty(const const_iterator &it) const {
    assert(settings.use_empty());  // we always need to know what's empty!
    return equals(key_info.empty, get_key(*it));
  }

 private:
  bool test_empty(size_type bucknum, const_pointer table) const {
    assert(settings.use_empty());
    return equals(key_info.empty, get_key(table[bucknum]));
  }

  void fill_range_with_empty(pointer table_start, pointer table_end) {
    for (; table_start != table_end; ++table_start) {
      new (table_start) value_type();
      set_key(table_start, key_info.empty);
    }
  }

 public:
  // TODO(user): change all callers of this to pass in a key instead,
  //                 and take a const key_type instead of const value_type.
  void set_empty_key(const_reference val) {
    // Once you set the empty key, you can't change it
    assert(!settings.use_empty() && "Calling set_empty_key multiple times");
    // The deleted indicator (if specified) and the empty indicator
    // must be different.
    const key_type& key = get_key(val);
    assert((!settings.use_deleted() || !equals(key, key_info.delkey)) &&
           "Setting the empty key the same as the deleted key");
    settings.set_use_empty(true);
    key_info.empty.~key_type();
    new (&key_info.empty) key_type(key);

    assert(!table);                  // must set before first use
    // num_buckets was set in constructor even though table was nullptr
    table = get_internal_allocator().allocate(num_buckets);
    fill_range_with_empty(table, table + num_buckets);
  }
  // TODO(user): this should return the key by const reference.
  value_type empty_key() const {
    assert(settings.use_empty());
    value_type ret = value_type();
    set_key(&ret, key_info.empty);
    return ret;
  }

  // FUNCTIONS CONCERNING SIZE
 public:
  size_type size() const      { return num_elements - num_deleted; }
  size_type max_size() const { return get_allocator().max_size(); }
  bool empty() const          { return size() == 0; }
  size_type bucket_count() const      { return num_buckets; }
  size_type max_bucket_count() const  { return max_size(); }
  size_type nonempty_bucket_count() const { return num_elements; }
  // These are tr1 methods.  Their idea of 'bucket' doesn't map well to
  // what we do.  We just say every bucket has 0 or 1 items in it.
  size_type bucket_size(size_type i) const {
    return begin(i) == end(i) ? 0 : 1;
  }

 private:
  // Because of the above, size_type(-1) is never legal; use it for errors
  static const size_type ILLEGAL_BUCKET = size_type(-1);

  // Used after a string of deletes.  Returns true if we actually shrunk.
  // TODO(user): take a delta so we can take into account inserts
  // done after shrinking.  Maybe make part of the Settings class?
  bool maybe_shrink() {
    assert(num_elements >= num_deleted);
    assert((bucket_count() & (bucket_count()-1)) == 0);  // is a power of two
    assert(bucket_count() >= HT_MIN_BUCKETS);
    bool retval = false;

    // If you construct a hashtable with < HT_DEFAULT_STARTING_BUCKETS,
    // we'll never shrink until you get relatively big, and we'll never
    // shrink below HT_DEFAULT_STARTING_BUCKETS.  Otherwise, something
    // like "dense_hash_set<int> x; x.insert(4); x.erase(4);" will
    // shrink us down to HT_MIN_BUCKETS buckets, which is too small.
    const size_type num_remain = num_elements - num_deleted;
    const size_type shrink_threshold = settings.shrink_threshold();
    if (shrink_threshold > 0 && num_remain < shrink_threshold &&
        bucket_count() > HT_DEFAULT_STARTING_BUCKETS) {
      const float shrink_factor = settings.shrink_factor();
      size_type sz = bucket_count() / 2;    // find how much we should shrink
      while (sz > HT_DEFAULT_STARTING_BUCKETS &&
             num_remain < sz * shrink_factor) {
        sz /= 2;                            // stay a power of 2
      }
      rebucket(sz);
      retval = true;
    }
    settings.set_consider_shrink(false);    // because we just considered it
    return retval;
  }

  // We'll let you resize a hashtable -- though this makes us copy all!
  // When you resize, you say, "make it big enough for this many more elements"
  // Returns true if we actually resized, false if size was already ok.
  bool resize_delta(size_type delta) {
    bool did_resize = false;
    if (settings.consider_shrink()) {  // see if lots of deletes happened
      if (maybe_shrink())
        did_resize = true;
    }
    if (num_elements >= std::numeric_limits<size_type>::max() - delta) {
      throw std::length_error("resize overflow");
    }

    assert(settings.enlarge_threshold() < bucket_count());
    // Check if our work is done.
    if (bucket_count() >= HT_MIN_BUCKETS &&
        num_elements + delta <= settings.enlarge_threshold()) {
      return did_resize;
    }

    // Sometimes, we need to resize just to get rid of all the
    // "deleted" buckets that are clogging up the hashtable.  So when
    // deciding whether to resize, count the deleted buckets (which
    // are currently taking up room).  But later, when we decide what
    // size to resize to, *don't* count deleted buckets, since they
    // get discarded during the resize.
    const size_type needed_size = settings.min_buckets(num_elements + delta, 0);
    if (needed_size <= bucket_count())      // we have enough buckets
      return did_resize;

    // We will rebucket.
    size_type resize_to =
      settings.min_buckets(num_elements - num_deleted + delta, bucket_count());

    if (resize_to < needed_size) {
      // This situation means that we have enough deleted elements,
      // that once we purge them, we won't actually have needed to
      // grow.  But we may want to grow anyway: if we just purge one
      // element, say, we'll have to grow anyway next time we
      // insert.  Might as well grow now, since we're already going
      // through the trouble of rebucketing in order to purge the
      // deleted elements.  (Safety note: Can resize_to * 2 overflow? No.
      // The output of min_buckets() is always a power of two, so resize_to
      // and needed_size are powers of two. That plus resize_to < needed_size
      // proves that overflow isn't a concern.)
      const size_type target =
          static_cast<size_type>(settings.shrink_size(resize_to*2));
      if (num_elements - num_deleted + delta >= target) {
        // Good, we won't be below the shrink threshhold even if we double.
        resize_to *= 2;
      }
    }
    rebucket(resize_to);
    return true;
  }

  // We require table be non-null and empty before calling this.
  void resize_table(size_type old_size, size_type new_size) {
    get_internal_allocator().deallocate(table, old_size);
    table = get_internal_allocator().allocate(new_size);
  }

  // Copy (or, if Iter is a move_iterator, move) the elements from
  // [src_first, src_last) into dest_table, which we assume has size
  // dest_bucket_count and has been initialized to the empty key.
  template<class Iter>
  void copy_elements(Iter src_first, Iter src_last, pointer dest_table,
                     size_type dest_bucket_count) {
    assert((dest_bucket_count & (dest_bucket_count - 1)) == 0);  // a power of 2
    // We use a normal iterator to get non-deleted bcks from ht
    // We could use insert() here, but since we know there are
    // no duplicates and no deleted items, we can be more efficient
    for (; src_first != src_last; ++src_first) {
      size_type num_probes = 0;               // how many times we've probed
      size_type bucknum;
      const size_type bucket_count_minus_one = dest_bucket_count - 1;
      for (bucknum = hash(get_key(*src_first)) & bucket_count_minus_one;
           !test_empty(bucknum, dest_table);  // not empty
           bucknum = (bucknum +
                      JUMP_(key, num_probes)) & bucket_count_minus_one) {
        ++num_probes;
        assert(num_probes < dest_bucket_count
               && "Hashtable is full: an error in key_equal<> or hash<>");
      }
      // Copies or moves the value into dest_table.
      set_value(&dest_table[bucknum], *src_first);
    }
  }

  // Used to actually do the rehashing when we grow/shrink a hashtable
  void copy_from(const dense_hashtable &ht, size_type min_buckets_wanted) {
    size_type size = ht.size();  // clear_to_size() sets ht.size() to 0.
    clear_to_size(settings.min_buckets(ht.size(), min_buckets_wanted));
    copy_elements(ht.begin(), ht.end(), table, bucket_count());
    num_elements = size;
    settings.inc_num_ht_copies();
  }

  // Rebuckets and resizes the hashtable.  Gets rid of any deleted entries.
  void rebucket(size_type new_num_buckets) {
    if (table == nullptr) {
      // When we eventually allocate the table, it will have this many buckets.
      num_buckets = new_num_buckets;
      return;
    }
    assert(settings.use_empty());
    assert((new_num_buckets & (new_num_buckets - 1)) == 0);  // a power of two
    // If settings.shrink_factor() is zero then we must not shrink.
    assert(settings.shrink_factor() > 0 || new_num_buckets >= num_buckets);
    pointer new_table = get_internal_allocator().allocate(new_num_buckets);

    fill_range_with_empty(new_table, new_table + new_num_buckets);
    copy_elements(std::make_move_iterator(begin()),
                  std::make_move_iterator(end()),
                  new_table, new_num_buckets);

    destroy_buckets(0, num_buckets);  // Destroy table's elements.
    get_internal_allocator().deallocate(table, num_buckets);

    table = new_table;
    num_buckets = new_num_buckets;
    assert(num_elements >= num_deleted);
    num_elements -= num_deleted;
    num_deleted = 0;
    settings.reset_thresholds(bucket_count());
    settings.inc_num_ht_copies();
  }

  // Required by the spec for hashed associative container
 public:
  // Though the docs say this should be num_buckets, I think it's much
  // more useful as num_elements.  As a special feature, calling with
  // req_elements==0 will cause us to shrink if we can, saving space.
  void resize(size_type req_elements) {       // resize to this or larger
    if ( settings.consider_shrink() || req_elements == 0 )
      maybe_shrink();
    if ( req_elements > num_elements )
      resize_delta(req_elements - num_elements);
  }

  // Get and change the value of shrink_factor and enlarge_factor.  The
  // description at the beginning of this file explains how to choose
  // the values.  Setting the shrink parameter to 0.0 ensures that the
  // table never shrinks.
  void get_resizing_parameters(float* shrink, float* grow) const {
    *shrink = settings.shrink_factor();
    *grow = settings.enlarge_factor();
  }
  void set_resizing_parameters(float shrink, float grow) {
    settings.set_resizing_parameters(shrink, grow);
    settings.reset_thresholds(bucket_count());
  }

  // CONSTRUCTORS -- as required by the specs, we take a size,
  // but also let you specify a hashfunction, key comparator,
  // and key extractor.  We also define a copy constructor and =.
  // DESTRUCTOR -- needs to free the table
  explicit dense_hashtable(size_type expected_max_items_in_table = 0,
                           const HashFcn& hf = HashFcn(),
                           const EqualKey& eql = EqualKey(),
                           const ExtractKey& ext = ExtractKey(),
                           const SetKey& set = SetKey(),
                           const Alloc& alloc = Alloc())
      : settings(hf),
        key_info(ext, set, eql, value_alloc_type(alloc)),
        num_deleted(0),
        num_elements(0),
        num_buckets(expected_max_items_in_table == 0
                        ? HT_DEFAULT_STARTING_BUCKETS
                        : settings.min_buckets(expected_max_items_in_table, 0)),
        table(nullptr) {
    // table is nullptr until the empty key is set. However, we set num_buckets
    // here so we know how much space to allocate once the empty key is set.
    settings.reset_thresholds(bucket_count());
  }

  // As a convenience for resize(), we allow an optional second argument
  // which lets you make this new hashtable a different size than ht
  dense_hashtable(const dense_hashtable& ht,
                  size_type min_buckets_wanted = HT_DEFAULT_STARTING_BUCKETS)
      : settings(ht.settings),
        key_info(ht.key_info.as_extract_key(), ht.key_info.as_set_key(),
                 ht.key_info.as_equal_key(),
                 value_alloc_type(
                     std::allocator_traits<value_alloc_type>::
                         select_on_container_copy_construction(
                             ht.key_info.as_value_alloc()))),
        num_deleted(0),
        num_elements(0),
        num_buckets(0),
        table(nullptr) {
    key_info.delkey = ht.key_info.delkey;
    key_info.empty = ht.key_info.empty;
    if (!ht.settings.use_empty()) {
      // If use_empty isn't set, copy_from will crash, so we do our own copying.
      assert(ht.empty());
      num_buckets = settings.min_buckets(ht.size(), min_buckets_wanted);
      settings.reset_thresholds(bucket_count());
      return;
    }
    settings.reset_thresholds(bucket_count());
    copy_from(ht, min_buckets_wanted);   // copy_from() ignores deleted entries
  }

  dense_hashtable& operator=(const dense_hashtable& ht) {
    if (&ht == this)  return *this;        // don't copy onto ourselves
    settings = ht.settings;
    key_info.as_extract_key() = ht.key_info.as_extract_key();
    key_info.as_set_key() = ht.key_info.as_set_key();
    key_info.as_equal_key() = ht.key_info.as_equal_key();
    if (std::allocator_traits<
            value_alloc_type>::propagate_on_container_copy_assignment::value) {
      // If we're about to overwrite our allocator, we need to free all
      // memory using our old allocator.
      if (key_info.as_value_alloc() != ht.key_info.as_value_alloc()) {
        destroy_table();
      }
      static_cast<value_alloc_type&>(key_info) =
          static_cast<const value_alloc_type&>(ht.key_info);
    }
    key_info.empty = ht.key_info.empty;
    key_info.delkey = ht.key_info.delkey;

    if (ht.settings.use_empty()) {
      // copy_from() calls clear and sets num_deleted to 0 too
      copy_from(ht, HT_MIN_BUCKETS);
    } else {
      assert(ht.empty());
      destroy_table();
    }

    // we purposefully don't copy the allocator, which may not be copyable
    return *this;
  }

  dense_hashtable(dense_hashtable&& ht)
      : settings(std::move(ht.settings)),
        key_info(std::move(ht.key_info)),
        num_deleted(ht.num_deleted),
        num_elements(ht.num_elements),
        num_buckets(ht.num_buckets),
        table(ht.table) {
    ht.num_deleted = 0;
    ht.num_elements = 0;
    ht.table = nullptr;
    ht.num_buckets = HT_DEFAULT_STARTING_BUCKETS;
    ht.settings.set_use_empty(false);
    ht.settings.set_use_deleted(false);
  }

  dense_hashtable& operator=(dense_hashtable&& ht) {
    if (&ht == this) return *this;        // don't move onto ourselves

    const bool can_move_table =
        std::allocator_traits<
            Alloc>::propagate_on_container_move_assignment::value ||
        key_info.as_value_alloc() == ht.key_info.as_value_alloc();

    // First, deallocate with this's allocator.
    destroy_table();

    if (std::allocator_traits<
            value_alloc_type>::propagate_on_container_move_assignment::value) {
      // This moves the allocator.
      key_info = std::move(ht.key_info);
    } else {
      // Move all other base classes of key_info from ht, but don't move the
      // allocator.
      key_info.as_extract_key() = std::move(ht.key_info.as_extract_key());
      key_info.as_set_key() = std::move(ht.key_info.as_set_key());
      key_info.as_equal_key() = std::move(ht.key_info.as_equal_key());
      key_info.delkey = std::move(ht.key_info.delkey);
      key_info.empty = std::move(ht.key_info.empty);
    }

    settings = std::move(ht.settings);
    num_deleted = ht.num_deleted;
    ht.num_deleted = 0;
    num_elements = ht.num_elements;
    ht.num_elements = 0;
    num_buckets = ht.num_buckets;
    ht.num_buckets = HT_DEFAULT_STARTING_BUCKETS;
    ht.settings.set_use_empty(false);
    ht.settings.set_use_deleted(false);

    if (can_move_table) {
      // We can transfer ownership of the table from ht to this because either
      // we're propagating the allocator or ht's allocator is equal to this's.
      table = ht.table;
      ht.table = nullptr;
    } else if (ht.table) {
      // We can't transfer ownership of any memory from ht to this, so the
      // best we can do is move element-by-element.
      table = get_internal_allocator().allocate(num_buckets);
      for (size_type i = 0; i < num_buckets; ++i) {
        new(table + i) Value(std::move(ht.table[i]));
      }
      ht.destroy_table();
    }

    return *this;
  }

  ~dense_hashtable() { destroy_table(); }

  // Many STL algorithms use swap instead of copy constructors
  void swap(dense_hashtable& ht) {
    if (this == &ht) return;  // swap with self.
    using std::swap;
    swap(settings, ht.settings);
    // Swap everything in key_info but the allocator.
    swap(key_info.as_extract_key(), ht.key_info.as_extract_key());
    swap(key_info.as_set_key(), ht.key_info.as_set_key());
    swap(key_info.as_equal_key(), ht.key_info.as_equal_key());
    if (std::allocator_traits<
            value_alloc_type>::propagate_on_container_swap::value) {
      swap(static_cast<value_alloc_type&>(key_info),
           static_cast<value_alloc_type&>(ht.key_info));
    } else {
      // Swapping when allocators are unequal and
      // propagate_on_container_swap is false is undefined behavior.
      S2_CHECK(key_info.as_value_alloc() == ht.key_info.as_value_alloc());
    }
    swap(key_info.empty, ht.key_info.empty);
    swap(key_info.delkey, ht.key_info.delkey);
    swap(num_deleted, ht.num_deleted);
    swap(num_elements, ht.num_elements);
    swap(num_buckets, ht.num_buckets);
    swap(table, ht.table);
  }

 private:
  void destroy_table() {
    if (table) {
      destroy_buckets(0, num_buckets);
      get_internal_allocator().deallocate(table, num_buckets);
      table = nullptr;
    }
  }

  void clear_to_size(size_type new_num_buckets) {
    if (!table) {
      table = get_internal_allocator().allocate(new_num_buckets);
    } else {
      destroy_buckets(0, num_buckets);
      if (new_num_buckets != num_buckets) {   // resize, if necessary
        resize_table(num_buckets, new_num_buckets);
      }
    }
    assert(table);
    fill_range_with_empty(table, table + new_num_buckets);
    num_elements = 0;
    num_deleted = 0;
    num_buckets = new_num_buckets;          // our new size
    settings.reset_thresholds(bucket_count());
  }

 public:
  // It's always nice to be able to clear a table without deallocating it
  void clear() {
    // If the table is already empty, and the number of buckets is
    // already as we desire, there's nothing to do.
    const size_type new_num_buckets = settings.min_buckets(0, 0);
    if (num_elements == 0 && new_num_buckets == num_buckets) {
      return;
    }
    clear_to_size(new_num_buckets);
  }

  // Clear the table without resizing it.
  // Mimicks the stl_hashtable's behaviour when clear()-ing in that it
  // does not modify the bucket count
  void clear_no_resize() {
    if (num_elements > 0) {
      assert(table);
      destroy_buckets(0, num_buckets);
      fill_range_with_empty(table, table + num_buckets);
    }
    // don't consider to shrink before another erase()
    settings.reset_thresholds(bucket_count());
    num_elements = 0;
    num_deleted = 0;
  }

  // LOOKUP ROUTINES
 private:
  template <class K>
  void assert_key_is_not_empty_or_deleted(const K& key) const {
    assert(settings.use_empty() && "set_empty_key() was not called");
    assert(!equals(key, key_info.empty) &&
           "Using the empty key as a regular key");
    assert((!settings.use_deleted() || !equals(key, key_info.delkey))
           && "Using the deleted key as a regular key");
  }

  template <class K>
  std::pair<size_type, size_type> find_position(const K& key) const {
    return find_position_using_hash(hash(key), key);
  }

  // Returns a pair of positions: 1st where the object is, 2nd where
  // it would go if you wanted to insert it.  1st is ILLEGAL_BUCKET
  // if object is not found; 2nd is ILLEGAL_BUCKET if it is.
  // Note: because of deletions where-to-insert is not trivial: it's the
  // first deleted bucket we see, as long as we don't find the key later
  template <class K>
  std::pair<size_type, size_type> find_position_using_hash(
      const size_type key_hash, const K& key) const {
    assert_key_is_not_empty_or_deleted(key);
    size_type num_probes = 0;              // how many times we've probed
    const size_type bucket_count_minus_one = bucket_count() - 1;
    size_type bucknum = key_hash & bucket_count_minus_one;
    size_type insert_pos = ILLEGAL_BUCKET;  // where we would insert
    while (1) {                             // probe until something happens
      if (test_empty(bucknum)) {            // bucket is empty
        if (insert_pos == ILLEGAL_BUCKET)   // found no prior place to insert
          return std::pair<size_type, size_type>(ILLEGAL_BUCKET, bucknum);
        else
          return std::pair<size_type, size_type>(ILLEGAL_BUCKET, insert_pos);

      } else if (test_deleted(bucknum)) {
        // keep searching, but mark to insert
        if ( insert_pos == ILLEGAL_BUCKET )
          insert_pos = bucknum;

      } else if (equals(key, get_key(table[bucknum]))) {
        return std::pair<size_type, size_type>(bucknum, ILLEGAL_BUCKET);
      }
      ++num_probes;                        // we're doing another probe
      bucknum = (bucknum + JUMP_(key, num_probes)) & bucket_count_minus_one;
      assert(num_probes < bucket_count()
             && "Hashtable is full: an error in key_equal<> or hash<>");
    }
  }

  template <class K>
  std::pair<size_type, bool> find_if_present(const K& key) const {
    return find_if_present_using_hash(hash(key), key);
  }

  // Return where the key is (if at all), and if it is present.  If
  // the key isn't present then the first part of the return value is
  // undefined.  The same information can be extracted from the result
  // of find_position(), but that tends to be slower in practice.
  template <class K>
  std::pair<size_type, bool> find_if_present_using_hash(
      const size_type key_hash, const K& key) const {
    assert_key_is_not_empty_or_deleted(key);
    size_type num_probes = 0;              // how many times we've probed
    const size_type bucket_count_minus_one = bucket_count() - 1;
    size_type bucknum = key_hash & bucket_count_minus_one;
    while (1) {                             // probe until something happens
      if (equals(key, get_key(table[bucknum]))) {
        return std::pair<size_type, bool>(bucknum, true);
      } else if (test_empty(bucknum)) {
        return std::pair<size_type, bool>(0, false);
      }
      ++num_probes;                        // we're doing another probe
      bucknum = (bucknum + JUMP_(key, num_probes)) & bucket_count_minus_one;
      assert(num_probes < bucket_count()
             && "Hashtable is full: an error in key_equal<> or hash<>");
    }
  }

 private:
  template <class K>
  iterator find_impl(const K& key) {
    std::pair<size_type, bool> pos = find_if_present(key);
    return pos.second ?
        iterator(this, table + pos.first, table + num_buckets, false) :
        end();
  }

  template <class K>
  const_iterator find_impl(const K& key) const {
    std::pair<size_type, bool> pos = find_if_present(key);
    return pos.second ?
        const_iterator(this, table + pos.first, table + num_buckets, false) :
        end();
  }

  template <class K>
  size_type bucket_impl(const K& key) const {
    std::pair<size_type, size_type> pos = find_position(key);
    return pos.first == ILLEGAL_BUCKET ? pos.second : pos.first;
  }

  template <class K>
  size_type count_impl(const K& key) const {
    return find_if_present(key).second ? 1 : 0;
  }

  template <class K>
  std::pair<iterator, iterator>
  equal_range_impl(const K& key) {
    iterator pos = find(key);
    if (pos == end()) {
      return std::pair<iterator, iterator>(pos, pos);
    } else {
      const iterator startpos = pos++;
      return std::pair<iterator, iterator>(startpos, pos);
    }
  }

  template <class K>
  std::pair<const_iterator, const_iterator>
  equal_range_impl(const K& key) const {
    const_iterator pos = find(key);
    if (pos == end()) {
      return std::pair<const_iterator, const_iterator>(pos, pos);
    } else {
      const const_iterator startpos = pos++;
      return std::pair<const_iterator, const_iterator>(startpos, pos);
    }
  }

 public:
  iterator find(const key_type& key) { return find_impl(key); }

  const_iterator find(const key_type& key) const { return find_impl(key); }

  // This is a tr1 method: the bucket a given key is in, or what bucket
  // it would be put in, if it were to be inserted.  Shrug.
  size_type bucket(const key_type& key) const { return bucket_impl(key); }

  // Counts how many elements have key key.  For maps, it's either 0 or 1.
  size_type count(const key_type &key) const { return count_impl(key); }

  // Likewise, equal_range doesn't really make sense for us.  Oh well.
  std::pair<iterator, iterator>
  equal_range(const key_type& key) { return equal_range_impl(key); }

  std::pair<const_iterator, const_iterator>
  equal_range(const key_type& key) const { return equal_range_impl(key); }



  // INSERTION ROUTINES
 private:
  // Private method used by insert_noresize and find_or_insert.
  // 'obj' is either value_type&& or const value_type&.
  template <typename U>
  iterator insert_at(U&& obj, size_type pos) {
    if (size() >= max_size()) {
      throw std::length_error("insert overflow");
    }
    if ( test_deleted(pos) ) {      // just replace if it's been del.
      assert(num_deleted > 0);
      --num_deleted;                // used to be, now it isn't
    } else {
      ++num_elements;               // replacing an empty bucket
    }
    set_value(&table[pos], std::forward<U>(obj));
    return iterator(this, table + pos, table + num_buckets, false);
  }

  // If you know *this is big enough to hold obj, use this routine
  // 'obj' is value_type&& or const value_type&.
  template <typename U>
  std::pair<iterator, bool> insert_noresize(U&& obj) {  // NOLINT
    return insert_noresize_using_hash(hash(get_key(obj)), std::forward<U>(obj));
  }

  // If you know *this is big enough to hold obj, use this routine
  // 'obj' is value_type&& or const value_type&.
  template <typename U>
  std::pair<iterator, bool> insert_noresize_using_hash(const size_type key_hash,
                                                       U&& obj) {
    const std::pair<size_type, size_type> pos =
        find_position_using_hash(key_hash, get_key(obj));
    if (pos.first != ILLEGAL_BUCKET) {      // object was already there
      return std::pair<iterator, bool>(iterator(this, table + pos.first,
                                          table + num_buckets, false),
                                 false);          // false: we didn't insert
    } else {                                 // pos.second says where to put it
      iterator i = insert_at(std::forward<U>(obj), pos.second);
      return std::pair<iterator, bool>(i, true);
    }
  }

  // Specializations of insert(it, it) depending on the power of the iterator:
  // (1) Iterator supports operator-, resize before inserting
  template <class ForwardIterator>
  void insert(ForwardIterator f, ForwardIterator l, std::forward_iterator_tag) {
    size_t dist = std::distance(f, l);
    if (dist >= std::numeric_limits<size_type>::max()) {
      throw std::length_error("insert-range overflow");
    }
    resize_delta(static_cast<size_type>(dist));
    for ( ; dist > 0; --dist, ++f) {
      insert_noresize(*f);
    }
  }

  // (2) Arbitrary iterator, can't tell how much to resize
  template <class InputIterator>
  void insert(InputIterator f, InputIterator l, std::input_iterator_tag) {
    for ( ; f != l; ++f)
      insert(*f);
  }

 public:
  // This is the normal insert routine, used by the outside world
  std::pair<iterator, bool> insert(const value_type& obj) {
    resize_delta(1);                      // adding an object, grow if need be
    return insert_noresize(obj);
  }

  std::pair<iterator, bool> insert(value_type&& obj) {  // NOLINT
    resize_delta(1);                      // adding an object, grow if need be
    return insert_noresize(std::move(obj));
  }

  // When inserting a lot at a time, we specialize on the type of iterator
  template <class InputIterator>
  void insert(InputIterator f, InputIterator l) {
    // specializes on iterator type
    insert(f, l,
           typename std::iterator_traits<InputIterator>::iterator_category());
  }

  template <class DefaultValue>
  value_type& find_or_insert(const key_type& key) {
    return find_or_insert_using_hash<DefaultValue>(hash(key), key);
  }

  // DefaultValue is a functor that takes a key and returns a value_type
  // representing the default value to be inserted if none is found.
  template <class DefaultValue>
  value_type& find_or_insert_using_hash(const size_type key_hash,
                                        const key_type& key) {
    const std::pair<size_type, size_type> pos =
        find_position_using_hash(key_hash, key);
    DefaultValue default_value;
    if (pos.first != ILLEGAL_BUCKET) {  // object was already there
      return table[pos.first];
    } else if (resize_delta(1)) {        // needed to rehash to make room
      // Since we resized, we can't use pos, so recalculate where to insert.
      return *insert_noresize(default_value(key)).first;
    } else {                             // no need to rehash, insert right here
      return *insert_at(default_value(key), pos.second);
    }
  }


  // DELETION ROUTINES
 private:
  template <class K>
  size_type erase_impl(const K& key) {
    iterator pos = find(key);
    if (pos != end()) {
      assert(!test_deleted(pos));  // or find() shouldn't have returned it
      set_deleted(pos);
      ++num_deleted;
      // will think about shrink after next insert
      settings.set_consider_shrink(true);
      return 1;                    // because we deleted one thing
    } else {
      return 0;                    // because we deleted nothing
    }
  }

 public:
  size_type erase(const key_type& key) {
    return erase_impl(key);
  }


  void erase(iterator pos) {
    if (pos == end()) return;    // sanity check
    set_deleted(pos);
    ++num_deleted;
    // will think about shrink after next insert
    settings.set_consider_shrink(true);
  }

  void erase(iterator f, iterator l) {
    for (; f != l; ++f) {
      set_deleted(f);
      ++num_deleted;
    }
    // will think about shrink after next insert
    settings.set_consider_shrink(true);
  }

  // We allow you to erase a const_iterator just like we allow you to
  // erase an iterator.  This is in parallel to 'delete': you can delete
  // a const pointer just like a non-const pointer.  The logic is that
  // you can't use the object after it's erased anyway, so it doesn't matter
  // if it's const or not.
  void erase(const_iterator pos) {
    if (pos == end()) return;    // sanity check
    set_deleted(pos);
    ++num_deleted;
    // will think about shrink after next insert
    settings.set_consider_shrink(true);
  }
  void erase(const_iterator f, const_iterator l) {
    for ( ; f != l; ++f) {
      set_deleted(f);
      ++num_deleted;
    }
    // will think about shrink after next insert
    settings.set_consider_shrink(true);
  }


  // COMPARISON
  bool operator==(const dense_hashtable& ht) const {
    if (size() != ht.size()) {
      return false;
    } else if (this == &ht) {
      return true;
    } else {
      // Iterate through the elements in "this" and see if the
      // corresponding element is in ht
      for ( const_iterator it = begin(); it != end(); ++it ) {
        const_iterator it2 = ht.find(get_key(*it));
        if ((it2 == ht.end()) || (*it != *it2)) {
          return false;
        }
      }
      return true;
    }
  }
  bool operator!=(const dense_hashtable& ht) const {
    return !(*this == ht);
  }


  // I/O
  // We support reading and writing hashtables to disk.  Alas, since
  // I don't know how to write a hasher or key_equal, you have to make
  // sure everything but the table is the same.  We compact before writing.
 private:
  // Every time the disk format changes, this should probably change too
  typedef unsigned long MagicNumberType;
  static const MagicNumberType MAGIC_NUMBER = 0x13578642;

  // Package functors with another class to eliminate memory needed for
  // zero-size functors.  Since ExtractKey and hasher's operator() might
  // have the same function signature, they must be packaged in
  // different classes.
  struct Settings :
      sh_hashtable_settings<key_type, hasher, size_type, HT_MIN_BUCKETS> {
    explicit Settings(const hasher& hf)
        : sh_hashtable_settings<key_type, hasher, size_type, HT_MIN_BUCKETS>(
            hf, HT_OCCUPANCY_PCT / 100.0f, HT_EMPTY_PCT / 100.0f) {}
  };

  // Packages ExtractKey, SetKey, EqualKey functors, allocator and deleted and
  // empty key values.
  struct KeyInfo : public ExtractKey,
                   public SetKey,
                   public EqualKey,
                   public value_alloc_type {
    KeyInfo(const ExtractKey& ek, const SetKey& sk, const EqualKey& eq,
            const value_alloc_type& a)
        : ExtractKey(ek),
          SetKey(sk),
          EqualKey(eq),
          value_alloc_type(a),
          delkey(),
          empty() {}

    // Accessors for convenient access to base classes.
    ExtractKey& as_extract_key() { return *this; }
    const ExtractKey& as_extract_key() const { return *this; }
    SetKey& as_set_key() { return *this; }
    const SetKey& as_set_key() const { return *this; }
    EqualKey& as_equal_key() { return *this; }
    const EqualKey& as_equal_key() const { return *this; }
    value_alloc_type& as_value_alloc() { return *this; }
    const value_alloc_type& as_value_alloc() const { return *this; }

    // We want to return the exact same type as ExtractKey: Key or const Key&
    typename ExtractKey::result_type get_key(const_reference v) const {
      return ExtractKey::operator()(v);
    }
    void set_key(pointer v, const key_type& k) const {
      SetKey::operator()(v, k);
    }

    // We only ever call EqualKey::operator()(key_type, K) -- we never use the
    // other order of args.  This allows consumers to get away with implementing
    // only half of operator==.
    template <class K>
    bool equals(const key_type& a, const K& b) const {
      return EqualKey::operator()(a, b);
    }

    pointer allocate(size_type size) {
      pointer memory = value_alloc_type::allocate(size);
      assert(memory != nullptr);
      return memory;
    }

    // Which key marks deleted entries.
    // TODO(user): make a pointer, and get rid of use_deleted (benchmark!)
    typename std::remove_const<key_type>::type delkey;
    // Key value used to mark unused entries.
    typename std::remove_const<key_type>::type empty;
  };

  // Returns the value_alloc_type used to allocate and deallocate
  // the table. This can be different from the one returned by get_allocator().
  value_alloc_type& get_internal_allocator() { return key_info; }

  // Utility functions to access the templated operators
  size_type hash(const key_type& v) const {
    return settings.hash(v);
  }
  bool equals(const key_type& a, const key_type& b) const {
    return key_info.equals(a, b);
  }


  typename ExtractKey::result_type get_key(const_reference v) const {
    return key_info.get_key(v);
  }
  void set_key(pointer v, const key_type& k) const {
    key_info.set_key(v, k);
  }

 private:
  // Actual data
  Settings settings;
  KeyInfo key_info;

  size_type num_deleted;  // how many occupied buckets are marked deleted
  size_type num_elements;
  size_type num_buckets;
  pointer table;
};


// We need a global swap as well
template <class V, class K, class HF, class ExK, class SetK, class EqK, class A>
inline void swap(dense_hashtable<V, K, HF, ExK, SetK, EqK, A> &x,
                 dense_hashtable<V, K, HF, ExK, SetK, EqK, A> &y) {
  x.swap(y);
}

#undef JUMP_
#undef PUT_
#undef GET_

template <class V, class K, class HF, class ExK, class SetK, class EqK, class A>
const typename dense_hashtable<V, K, HF, ExK, SetK, EqK, A>::size_type
  dense_hashtable<V, K, HF, ExK, SetK, EqK, A>::ILLEGAL_BUCKET;

// How full we let the table get before we resize.  Knuth says .8 is
// good -- higher causes us to probe too much, though saves memory.
// However, we go with .5, getting better performance at the cost of
// more space (a trade-off densehashtable explicitly chooses to make).
// Feel free to play around with different values, though, via
// max_load_factor() and/or set_resizing_parameters().
template <class V, class K, class HF, class ExK, class SetK, class EqK, class A>
const int dense_hashtable<V,K,HF,ExK,SetK,EqK,A>::HT_OCCUPANCY_PCT = 50;

// How empty we let the table get before we resize lower.
// It should be less than OCCUPANCY_PCT / 2 or we thrash resizing.
template <class V, class K, class HF, class ExK, class SetK, class EqK, class A>
const int dense_hashtable<V, K, HF, ExK, SetK, EqK, A>::HT_EMPTY_PCT =
  static_cast<int>(
      0.4 * dense_hashtable<V, K, HF, ExK, SetK, EqK, A>::HT_OCCUPANCY_PCT);

}

#endif  // S2_UTIL_GTL_DENSEHASHTABLE_H_
