/*
Copyright (C) 2005,2009-2010 Electronic Arts, Inc.  All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1.  Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
2.  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.
3.  Neither the name of Electronic Arts, Inc. ("EA") 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 ELECTRONIC ARTS AND ITS 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 ELECTRONIC ARTS OR ITS 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.
*/

///////////////////////////////////////////////////////////////////////////////
// EASTL/internal/hashtable.h
//
// Written and maintained by Paul Pedriana - 2005.
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
// This file implements a hashtable, much like the C++ TR1 hash_set/hash_map.
// proposed classes.
// The primary distinctions between this hashtable and TR1 hash tables are:
//    - hashtable is savvy to an environment that doesn't have exception handling,
//      as is sometimes the case with console or embedded environments.
//    - hashtable is slightly more space-efficient than a conventional std hashtable
//      implementation on platforms with 64 bit size_t. This is
//      because std STL uses size_t (64 bits) in data structures whereby 32 bits
//      of data would be fine.
//    - hashtable can contain objects with alignment requirements. TR1 hash tables
//      cannot do so without a bit of tedious non-portable effort.
//    - hashtable supports debug memory naming natively.
//    - hashtable provides a find function that lets you specify a type that is
//      different from the hash table key type. This is particularly useful for
//      the storing of string objects but finding them by char pointers.
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
// This file is currently partially based on the TR1 (technical report 1)
// reference implementation of the hash_set/hash_map C++ classes
// as of about 4/2005.
///////////////////////////////////////////////////////////////////////////////


#ifndef EASTL_INTERNAL_HASHTABLE_H
#define EASTL_INTERNAL_HASHTABLE_H


#include <stk_util/util/config_eastl.h>
#include <stk_util/util/type_traits_eastl.h>
#include <stk_util/util/allocator_eastl.h>
#include <stk_util/util/iterator_eastl.h>
#include <stk_util/util/functional_eastl.h>
#include <stk_util/util/utility_eastl.h>
#include <stk_util/util/algorithm_eastl.h>
#include <string.h>

#ifdef _MSC_VER
    #pragma warning(push, 0)
    #include <new>
    #include <stddef.h>
    #pragma warning(pop)
#else
    #include <new>
    #include <stddef.h>
#endif

#ifdef _MSC_VER
    #pragma warning(push)
    #pragma warning(disable: 4512)  // 'class' : assignment operator could not be generated.
    #pragma warning(disable: 4530)  // C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc
#endif


namespace eastl
{

    /// EASTL_HASHTABLE_DEFAULT_NAME
    ///
    /// Defines a default container name in the absence of a user-provided name.
    ///
    #ifndef EASTL_HASHTABLE_DEFAULT_NAME
        #define EASTL_HASHTABLE_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " hashtable" // Unless the user overrides something, this is "EASTL hashtable".
    #endif


    /// EASTL_HASHTABLE_DEFAULT_ALLOCATOR
    ///
    #ifndef EASTL_HASHTABLE_DEFAULT_ALLOCATOR
        #define EASTL_HASHTABLE_DEFAULT_ALLOCATOR allocator_type(EASTL_HASHTABLE_DEFAULT_NAME)
    #endif



    /// gpEmptyBucketArray
    ///
    /// A shared representation of an empty hash table. This is present so that
    /// a new empty hashtable allocates no memory. It has two entries, one for
    /// the first lone empty (NULL) bucket, and one for the non-NULL trailing sentinel.
    ///
    extern EASTL_API void* gpEmptyBucketArray[2];



    /// hash_node
    ///
    /// A hash_node stores an element in a hash table, much like a
    /// linked list node stores an element in a linked list.
    /// A hash_node additionally can, via template parameter,
    /// store a hash code in the node to speed up hash calculations
    /// and comparisons in some cases.
    ///
    template <typename Value, bool bCacheHashCode>
    struct hash_node;

    template <typename Value>
    struct hash_node<Value, true>
    {
        Value        mValue;
        hash_node*   mpNext;
        eastl_size_t mnHashCode;      // See config.h for the definition of eastl_size_t, which defaults to uint32_t.
    } EASTL_MAY_ALIAS;

    template <typename Value>
    struct hash_node<Value, false>
    {
        Value      mValue;
        hash_node* mpNext;
    } EASTL_MAY_ALIAS;



    /// node_iterator_base
    ///
    /// Node iterators iterate nodes within a given bucket.
    ///
    /// We define a base class here because it is shared by both const and
    /// non-const iterators.
    ///
    template <typename Value, bool bCacheHashCode>
    struct node_iterator_base
    {
    public:
        typedef hash_node<Value, bCacheHashCode> node_type;

        node_type* mpNode;

    public:
        node_iterator_base(node_type* pNode)
            : mpNode(pNode) { }

        void increment()
            { mpNode = mpNode->mpNext; }
    };



    /// node_iterator
    ///
    /// Node iterators iterate nodes within a given bucket.
    ///
    /// The bConst parameter defines if the iterator is a const_iterator
    /// or an iterator.
    ///
    template <typename Value, bool bConst, bool bCacheHashCode>
    struct node_iterator : public node_iterator_base<Value, bCacheHashCode>
    {
    public:
        typedef node_iterator_base<Value, bCacheHashCode>                base_type;
        typedef node_iterator<Value, bConst, bCacheHashCode>             this_type;
        typedef typename base_type::node_type                            node_type;
        typedef Value                                                    value_type;
        typedef typename type_select<bConst, const Value*, Value*>::type pointer;
        typedef typename type_select<bConst, const Value&, Value&>::type reference;
        typedef ptrdiff_t                                                difference_type;
        typedef EASTL_ITC_NS::forward_iterator_tag                       iterator_category;

    public:
        explicit node_iterator(node_type* pNode = NULL)
            : base_type(pNode) { }

        node_iterator(const node_iterator<Value, true, bCacheHashCode>& x)
            : base_type(x.mpNode) { }

        reference operator*() const
            { return base_type::mpNode->mValue; }

        pointer operator->() const
            { return &(base_type::mpNode->mValue); }

        node_iterator& operator++()
            { base_type::increment(); return *this; }

        node_iterator operator++(int)
            { node_iterator temp(*this); base_type::increment(); return temp; }

    }; // node_iterator



    /// hashtable_iterator_base
    ///
    /// A hashtable_iterator iterates the entire hash table and not just
    /// nodes within a single bucket. Users in general will use a hash
    /// table iterator much more often, as it is much like other container
    /// iterators (e.g. vector::iterator).
    ///
    /// We define a base class here because it is shared by both const and
    /// non-const iterators.
    ///
    template <typename Value, bool bCacheHashCode>
    struct hashtable_iterator_base
    {
    public:
        typedef hash_node<Value, bCacheHashCode> node_type;

    public:
        // We use public here because it allows the hashtable class to access
        // these without a function call, and we are very strongly avoiding
        // function calls in this library, as our primary goal is performance
        // over correctness and some compilers (e.g. GCC) are terrible at
        // inlining and so avoiding function calls is of major importance.
        node_type*  mpNode;      // Current node within current bucket.
        node_type** mpBucket;    // Current bucket.

    public:
        hashtable_iterator_base(node_type* pNode, node_type** pBucket)
            : mpNode(pNode), mpBucket(pBucket) { }

        void increment_bucket()
        {
            ++mpBucket;
            while(*mpBucket == NULL) // We store an extra bucket with some non-NULL value at the end
                ++mpBucket;          // of the bucket array so that finding the end of the bucket
            mpNode = *mpBucket;      // array is quick and simple.
        }

        void increment()
        {
            mpNode = mpNode->mpNext;

            while(mpNode == NULL)
                mpNode = *++mpBucket;
        }

    }; // hashtable_iterator_base




    /// hashtable_iterator
    ///
    /// A hashtable_iterator iterates the entire hash table and not just
    /// nodes within a single bucket. Users in general will use a hash
    /// table iterator much more often, as it is much like other container
    /// iterators (e.g. vector::iterator).
    ///
    /// The bConst parameter defines if the iterator is a const_iterator
    /// or an iterator.
    ///
    template <typename Value, bool bConst, bool bCacheHashCode>
    struct hashtable_iterator : public hashtable_iterator_base<Value, bCacheHashCode>
    {
    public:
        typedef hashtable_iterator_base<Value, bCacheHashCode>           base_type;
        typedef hashtable_iterator<Value, bConst, bCacheHashCode>        this_type;
        typedef hashtable_iterator<Value, false, bCacheHashCode>         this_type_non_const;
        typedef typename base_type::node_type                            node_type;
        typedef Value                                                    value_type;
        typedef typename type_select<bConst, const Value*, Value*>::type pointer;
        typedef typename type_select<bConst, const Value&, Value&>::type reference;
        typedef ptrdiff_t                                                difference_type;
        typedef EASTL_ITC_NS::forward_iterator_tag                       iterator_category;

    public:
        hashtable_iterator(node_type* pNode = NULL, node_type** pBucket = NULL)
            : base_type(pNode, pBucket) { }

        hashtable_iterator(node_type** pBucket)
            : base_type(*pBucket, pBucket) { }

        hashtable_iterator(const this_type_non_const& x)
            : base_type(x.mpNode, x.mpBucket) { }

        reference operator*() const
            { return base_type::mpNode->mValue; }

        pointer operator->() const
            { return &(base_type::mpNode->mValue); }

        hashtable_iterator& operator++()
            { base_type::increment(); return *this; }

        hashtable_iterator operator++(int)
            { hashtable_iterator temp(*this); base_type::increment(); return temp; }

        const node_type* get_node() const
            { return base_type::mpNode; }

    }; // hashtable_iterator




    /// ht_distance
    ///
    /// This function returns the same thing as distance() for
    /// forward iterators but returns zero for input iterators.
    /// The reason why is that input iterators can only be read
    /// once, and calling distance() on an input iterator destroys
    /// the ability to read it. This ht_distance is used only for
    /// optimization and so the code will merely work better with
    /// forward iterators that input iterators.
    ///
    template <typename Iterator>
    inline typename eastl::iterator_traits<Iterator>::difference_type
    distance_fw_impl(Iterator first, Iterator last, EASTL_ITC_NS::input_iterator_tag)
        { return 0; }

    template <typename Iterator>
    inline typename eastl::iterator_traits<Iterator>::difference_type
    distance_fw_impl(Iterator first, Iterator last, EASTL_ITC_NS::forward_iterator_tag)
        { return eastl::distance(first, last); }

    template <typename Iterator>
    inline typename eastl::iterator_traits<Iterator>::difference_type
    ht_distance(Iterator first, Iterator last)
    {
        typedef typename eastl::iterator_traits<Iterator>::iterator_category IC;
        return distance_fw_impl(first, last, IC());
    }




    /// mod_range_hashing
    ///
    /// Implements the algorithm for conversion of a number in the range of
    /// [0, UINT32_MAX) to the range of [0, BucketCount).
    ///
    struct mod_range_hashing
    {
        // Defined as eastl_size_t instead of size_t because the latter
        // wastes memory and is sometimes slower on 64 bit machines.
        uint32_t operator()(uint32_t r, uint32_t n) const
            { return r % n; }
    };


    /// default_ranged_hash
    ///
    /// Default ranged hash function H. In principle it should be a
    /// function object composed from objects of type H1 and H2 such that
    /// h(k, n) = h2(h1(k), n), but that would mean making extra copies of
    /// h1 and h2. So instead we'll just use a tag to tell class template
    /// hashtable to do that composition.
    ///
    struct default_ranged_hash{ };


    /// prime_rehash_policy
    ///
    /// Default value for rehash policy. Bucket size is (usually) the
    /// smallest prime that keeps the load factor small enough.
    ///
    struct EASTL_API prime_rehash_policy
    {
    public:
        float            mfMaxLoadFactor;
        float            mfGrowthFactor;
        mutable uint32_t mnNextResize;

    public:
        prime_rehash_policy(float fMaxLoadFactor = 1.f)
            : mfMaxLoadFactor(fMaxLoadFactor), mfGrowthFactor(2.f), mnNextResize(0) { }

        float GetMaxLoadFactor() const
            { return mfMaxLoadFactor; }

        /// Return a bucket count no greater than nBucketCountHint,
        /// Don't update member variables while at it.
        static uint32_t GetPrevBucketCountOnly(uint32_t nBucketCountHint);

        /// Return a bucket count no greater than nBucketCountHint.
        /// This function has a side effect of updating mnNextResize.
        uint32_t GetPrevBucketCount(uint32_t nBucketCountHint) const;

        /// Return a bucket count no smaller than nBucketCountHint.
        /// This function has a side effect of updating mnNextResize.
        uint32_t GetNextBucketCount(uint32_t nBucketCountHint) const;

        /// Return a bucket count appropriate for nElementCount elements.
        /// This function has a side effect of updating mnNextResize.
        uint32_t GetBucketCount(uint32_t nElementCount) const;

        /// nBucketCount is current bucket count, nElementCount is current element count,
        /// and nElementAdd is number of elements to be inserted. Do we need
        /// to increase bucket count? If so, return pair(true, n), where
        /// n is the new bucket count. If not, return pair(false, 0).
        eastl::pair<bool, uint32_t>
        GetRehashRequired(uint32_t nBucketCount, uint32_t nElementCount, uint32_t nElementAdd) const;
    };





    ///////////////////////////////////////////////////////////////////////
    // Base classes for hashtable. We define these base classes because
    // in some cases we want to do different things depending on the
    // value of a policy class. In some cases the policy class affects
    // which member functions and nested typedefs are defined; we handle that
    // by specializing base class templates. Several of the base class templates
    // need to access other members of class template hashtable, so we use
    // the "curiously recurring template pattern" (parent class is templated
    // on type of child class) for them.
    ///////////////////////////////////////////////////////////////////////


    /// rehash_base
    ///
    /// Give hashtable the get_max_load_factor functions if the rehash
    /// policy is prime_rehash_policy.
    ///
    template <typename RehashPolicy, typename Hashtable>
    struct rehash_base { };

    template <typename Hashtable>
    struct rehash_base<prime_rehash_policy, Hashtable>
    {
        // Returns the max load factor, which is the load factor beyond
        // which we rebuild the container with a new bucket count.
        float get_max_load_factor() const
        {
            const Hashtable* const pThis = static_cast<const Hashtable*>(this);
            return pThis->rehash_policy().GetMaxLoadFactor();
        }

        // If you want to make the hashtable never rehash (resize),
        // set the max load factor to be a very high number (e.g. 100000.f).
        void set_max_load_factor(float fMaxLoadFactor)
        {
            Hashtable* const pThis = static_cast<Hashtable*>(this);
            pThis->rehash_policy(prime_rehash_policy(fMaxLoadFactor));
        }
    };




    /// hash_code_base
    ///
    /// Encapsulates two policy issues that aren't quite orthogonal.
    ///   (1) The difference between using a ranged hash function and using
    ///       the combination of a hash function and a range-hashing function.
    ///       In the former case we don't have such things as hash codes, so
    ///       we have a dummy type as placeholder.
    ///   (2) Whether or not we cache hash codes. Caching hash codes is
    ///       meaningless if we have a ranged hash function. This is because
    ///       a ranged hash function converts an object directly to its
    ///       bucket index without ostensibly using a hash code.
    /// We also put the key extraction and equality comparison function
    /// objects here, for convenience.
    ///
    template <typename Key, typename Value, typename ExtractKey, typename Equal,
              typename H1, typename H2, typename H, bool bCacheHashCode>
    struct hash_code_base;


    /// hash_code_base
    ///
    /// Specialization: ranged hash function, no caching hash codes.
    /// H1 and H2 are provided but ignored. We define a dummy hash code type.
    ///
    template <typename Key, typename Value, typename ExtractKey, typename Equal, typename H1, typename H2, typename H>
    struct hash_code_base<Key, Value, ExtractKey, Equal, H1, H2, H, false>
    {
    protected:
        ExtractKey  mExtractKey;    // To do: Make this member go away entirely, as it never has any data.
        Equal       mEqual;         // To do: Make this instance use zero space when it is zero size.
        H           mRangedHash;    // To do: Make this instance use zero space when it is zero size

    public:
        H1 hash_function() const
            { return H1(); }

        Equal equal_function() const // Deprecated. Use key_eq() instead, as key_eq is what the new C++ standard
            { return mEqual; }       // has specified in its hashtable (unordered_*) proposal.

        const Equal& key_eq() const
            { return mEqual; }

        Equal& key_eq()
            { return mEqual; }

    protected:
        typedef void*    hash_code_t;
        typedef uint32_t bucket_index_t;

        hash_code_base(const ExtractKey& extractKey, const Equal& eq, const H1&, const H2&, const H& h)
            : mExtractKey(extractKey), mEqual(eq), mRangedHash(h) { }

        hash_code_t get_hash_code(const Key& key) const
            { return NULL; }

        bucket_index_t bucket_index(hash_code_t, uint32_t) const
            { return (bucket_index_t)0; }

        bucket_index_t bucket_index(const Key& key, hash_code_t, uint32_t nBucketCount) const
            { return (bucket_index_t)mRangedHash(key, nBucketCount); }

        bucket_index_t bucket_index(const hash_node<Value, false>* pNode, uint32_t nBucketCount) const
            { return (bucket_index_t)mRangedHash(mExtractKey(pNode->mValue), nBucketCount); }

        bool compare(const Key& key, hash_code_t, hash_node<Value, false>* pNode) const
            { return mEqual(key, mExtractKey(pNode->mValue)); }

        void copy_code(hash_node<Value, false>*, const hash_node<Value, false>*) const
            { } // Nothing to do.

        void set_code(hash_node<Value, false>* pDest, hash_code_t c) const
            { } // Nothing to do.

        void base_swap(hash_code_base& x)
        {
            eastl::swap(mExtractKey, x.mExtractKey);
            eastl::swap(mEqual,      x.mEqual);
            eastl::swap(mRangedHash, x.mRangedHash);
        }

    }; // hash_code_base



    // No specialization for ranged hash function while caching hash codes.
    // That combination is meaningless, and trying to do it is an error.


    /// hash_code_base
    ///
    /// Specialization: ranged hash function, cache hash codes.
    /// This combination is meaningless, so we provide only a declaration
    /// and no definition.
    ///
    template <typename Key, typename Value, typename ExtractKey, typename Equal, typename H1, typename H2, typename H>
    struct hash_code_base<Key, Value, ExtractKey, Equal, H1, H2, H, true>;



    /// hash_code_base
    ///
    /// Specialization: hash function and range-hashing function,
    /// no caching of hash codes. H is provided but ignored.
    /// Provides typedef and accessor required by TR1.
    ///
    template <typename Key, typename Value, typename ExtractKey, typename Equal, typename H1, typename H2>
    struct hash_code_base<Key, Value, ExtractKey, Equal, H1, H2, default_ranged_hash, false>
    {
    protected:
        ExtractKey  mExtractKey;
        Equal       mEqual;
        H1          m_h1;
        H2          m_h2;

    public:
        typedef H1 hasher;

        H1 hash_function() const
            { return m_h1; }

        Equal equal_function() const // Deprecated. Use key_eq() instead, as key_eq is what the new C++ standard
            { return mEqual; }       // has specified in its hashtable (unordered_*) proposal.

        const Equal& key_eq() const
            { return mEqual; }

        Equal& key_eq()
            { return mEqual; }

    protected:
        typedef uint32_t hash_code_t;
        typedef uint32_t bucket_index_t;
        typedef hash_node<Value, false> node_type;

        hash_code_base(const ExtractKey& ex, const Equal& eq, const H1& h1, const H2& h2, const default_ranged_hash&)
            : mExtractKey(ex), mEqual(eq), m_h1(h1), m_h2(h2) { }

        hash_code_t get_hash_code(const Key& key) const
            { return (hash_code_t)m_h1(key); }

        bucket_index_t bucket_index(hash_code_t c, uint32_t nBucketCount) const
            { return (bucket_index_t)m_h2(c, nBucketCount); }

        bucket_index_t bucket_index(const Key&, hash_code_t c, uint32_t nBucketCount) const
            { return (bucket_index_t)m_h2(c, nBucketCount); }

        bucket_index_t bucket_index(const node_type* pNode, uint32_t nBucketCount) const
            { return (bucket_index_t)m_h2((hash_code_t)m_h1(mExtractKey(pNode->mValue)), nBucketCount); }

        bool compare(const Key& key, hash_code_t, node_type* pNode) const
            { return mEqual(key, mExtractKey(pNode->mValue)); }

        void copy_code(node_type*, const node_type*) const
            { } // Nothing to do.

        void set_code(node_type*, hash_code_t) const
            { } // Nothing to do.

        void base_swap(hash_code_base& x)
        {
            eastl::swap(mExtractKey, x.mExtractKey);
            eastl::swap(mEqual,      x.mEqual);
            eastl::swap(m_h1,        x.m_h1);
            eastl::swap(m_h2,        x.m_h2);
        }

    }; // hash_code_base



    /// hash_code_base
    ///
    /// Specialization: hash function and range-hashing function,
    /// caching hash codes. H is provided but ignored.
    /// Provides typedef and accessor required by TR1.
    ///
    template <typename Key, typename Value, typename ExtractKey, typename Equal, typename H1, typename H2>
    struct hash_code_base<Key, Value, ExtractKey, Equal, H1, H2, default_ranged_hash, true>
    {
    protected:
        ExtractKey  mExtractKey;
        Equal       mEqual;
        H1          m_h1;
        H2          m_h2;

    public:
        typedef H1 hasher;

        H1 hash_function() const
            { return m_h1; }

        Equal equal_function() const // Deprecated. Use key_eq() instead, as key_eq is what the new C++ standard
            { return mEqual; }       // has specified in its hashtable (unordered_*) proposal.

        const Equal& key_eq() const
            { return mEqual; }

        Equal& key_eq()
            { return mEqual; }

    protected:
        typedef uint32_t hash_code_t;
        typedef uint32_t bucket_index_t;
        typedef hash_node<Value, true> node_type;

        hash_code_base(const ExtractKey& ex, const Equal& eq, const H1& h1, const H2& h2, const default_ranged_hash&)
            : mExtractKey(ex), mEqual(eq), m_h1(h1), m_h2(h2) { }

        hash_code_t get_hash_code(const Key& key) const
            { return (hash_code_t)m_h1(key); }

        bucket_index_t bucket_index(hash_code_t c, uint32_t nBucketCount) const
            { return (bucket_index_t)m_h2(c, nBucketCount); }

        bucket_index_t bucket_index(const Key&, hash_code_t c, uint32_t nBucketCount) const
            { return (bucket_index_t)m_h2(c, nBucketCount); }

        bucket_index_t bucket_index(const node_type* pNode, uint32_t nBucketCount) const
            { return (bucket_index_t)m_h2((uint32_t)pNode->mnHashCode, nBucketCount); }

        bool compare(const Key& key, hash_code_t c, node_type* pNode) const
            { return (pNode->mnHashCode == c) && mEqual(key, mExtractKey(pNode->mValue)); }

        void copy_code(node_type* pDest, const node_type* pSource) const
            { pDest->mnHashCode = pSource->mnHashCode; }

        void set_code(node_type* pDest, hash_code_t c) const
            { pDest->mnHashCode = c; }

        void base_swap(hash_code_base& x)
        {
            eastl::swap(mExtractKey, x.mExtractKey);
            eastl::swap(mEqual,      x.mEqual);
            eastl::swap(m_h1,        x.m_h1);
            eastl::swap(m_h2,        x.m_h2);
        }

    }; // hash_code_base





    ///////////////////////////////////////////////////////////////////////////
    /// hashtable
    ///
    /// Key and Value: arbitrary CopyConstructible types.
    ///
    /// ExtractKey: function object that takes a object of type Value
    /// and returns a value of type Key.
    ///
    /// Equal: function object that takes two objects of type k and returns
    /// a bool-like value that is true if the two objects are considered equal.
    ///
    /// H1: a hash function. A unary function object with argument type
    /// Key and result type size_t. Return values should be distributed
    /// over the entire range [0, numeric_limits<uint32_t>::max()].
    ///
    /// H2: a range-hashing function (in the terminology of Tavori and
    /// Dreizin). This is a function which takes the output of H1 and
    /// converts it to the range of [0, n]. Usually it merely takes the
    /// output of H1 and mods it to n.
    ///
    /// H: a ranged hash function (Tavori and Dreizin). This is merely
    /// a class that combines the functionality of H1 and H2 together,
    /// possibly in some way that is somehow improved over H1 and H2
    /// It is a binary function whose argument types are Key and size_t
    /// and whose result type is uint32_t. Given arguments k and n, the
    /// return value is in the range [0, n). Default: h(k, n) = h2(h1(k), n).
    /// If H is anything other than the default, H1 and H2 are ignored,
    /// as H is thus overriding H1 and H2.
    ///
    /// RehashPolicy: Policy class with three members, all of which govern
    /// the bucket count. nBucket(n) returns a bucket count no smaller
    /// than n. GetBucketCount(n) returns a bucket count appropriate
    /// for an element count of n. GetRehashRequired(nBucketCount, nElementCount, nElementAdd)
    /// determines whether, if the current bucket count is nBucket and the
    /// current element count is nElementCount, we need to increase the bucket
    /// count. If so, returns pair(true, n), where n is the new
    /// bucket count. If not, returns pair(false, <anything>).
    ///
    /// Currently it is hard-wired that the number of buckets never
    /// shrinks. Should we allow RehashPolicy to change that?
    ///
    /// bCacheHashCode: true if we store the value of the hash
    /// function along with the value. This is a time-space tradeoff.
    /// Storing it may improve lookup speed by reducing the number of
    /// times we need to call the Equal function.
    ///
    /// bMutableIterators: true if hashtable::iterator is a mutable
    /// iterator, false if iterator and const_iterator are both const
    /// iterators. This is true for hash_map and hash_multimap,
    /// false for hash_set and hash_multiset.
    ///
    /// bUniqueKeys: true if the return value of hashtable::count(k)
    /// is always at most one, false if it may be an arbitrary number.
    /// This is true for hash_set and hash_map and is false for
    /// hash_multiset and hash_multimap.
    ///
    ///////////////////////////////////////////////////////////////////////
    /// Note:
    /// If you want to make a hashtable never increase its bucket usage,
    /// call set_max_load_factor with a very high value such as 100000.f.
    ///
    /// find_as
    /// In order to support the ability to have a hashtable of strings but
    /// be able to do efficiently lookups via char pointers (i.e. so they
    /// aren't converted to string objects), we provide the find_as
    /// function. This function allows you to do a find with a key of a
    /// type other than the hashtable key type. See the find_as function
    /// for more documentation on this.
    ///
    /// find_by_hash
    /// In the interest of supporting fast operations wherever possible,
    /// we provide a find_by_hash function which finds a node using its
    /// hash code.  This is useful for cases where the node's hash is
    /// already known, allowing us to avoid a redundant hash operation
    /// in the normal find path.
    ///
    template <typename Key, typename Value, typename Allocator, typename ExtractKey,
              typename Equal, typename H1, typename H2, typename H,
              typename RehashPolicy, bool bCacheHashCode, bool bMutableIterators, bool bUniqueKeys>
    class hashtable
        :   public rehash_base<RehashPolicy, hashtable<Key, Value, Allocator, ExtractKey, Equal, H1, H2, H, RehashPolicy, bCacheHashCode, bMutableIterators, bUniqueKeys> >,
            public hash_code_base<Key, Value, ExtractKey, Equal, H1, H2, H, bCacheHashCode>
    {
    public:
        typedef Key                                                                                 key_type;
        typedef Value                                                                               value_type;
        typedef typename ExtractKey::result_type                                                    mapped_type;
        typedef hash_code_base<Key, Value, ExtractKey, Equal, H1, H2, H, bCacheHashCode>            hash_code_base_type;
        typedef typename hash_code_base_type::hash_code_t                                           hash_code_t;
        typedef Allocator                                                                           allocator_type;
        typedef Equal                                                                               key_equal;
        typedef ptrdiff_t                                                                           difference_type;
        typedef eastl_size_t                                                                        size_type;     // See config.h for the definition of eastl_size_t, which defaults to uint32_t.
        typedef value_type&                                                                         reference;
        typedef const value_type&                                                                   const_reference;
        typedef node_iterator<value_type, !bMutableIterators, bCacheHashCode>                       local_iterator;
        typedef node_iterator<value_type, true,               bCacheHashCode>                       const_local_iterator;
        typedef hashtable_iterator<value_type, !bMutableIterators, bCacheHashCode>                  iterator;
        typedef hashtable_iterator<value_type, true,               bCacheHashCode>                  const_iterator;
        typedef eastl::reverse_iterator<iterator>                                                   reverse_iterator;
        typedef eastl::reverse_iterator<const_iterator>                                             const_reverse_iterator;
        typedef hash_node<value_type, bCacheHashCode>                                               node_type;
        typedef typename type_select<bUniqueKeys, eastl::pair<iterator, bool>, iterator>::type      insert_return_type;
        typedef hashtable<Key, Value, Allocator, ExtractKey, Equal, H1, H2, H,
                            RehashPolicy, bCacheHashCode, bMutableIterators, bUniqueKeys>           this_type;
        typedef RehashPolicy                                                                        rehash_policy_type;
        typedef ExtractKey                                                                          extract_key_type;
        typedef H1                                                                                  h1_type;
        typedef H2                                                                                  h2_type;
        typedef H                                                                                   h_type;

        using hash_code_base_type::key_eq;
        using hash_code_base_type::hash_function;
        using hash_code_base_type::mExtractKey;
        using hash_code_base_type::get_hash_code;
        using hash_code_base_type::bucket_index;
        using hash_code_base_type::compare;
        using hash_code_base_type::set_code;

        static const bool kCacheHashCode = bCacheHashCode;

        enum
        {
            kKeyAlignment         = EASTL_ALIGN_OF(key_type),
            kKeyAlignmentOffset   = 0,                          // To do: Make sure this really is zero for all uses of this template.
            kValueAlignment       = EASTL_ALIGN_OF(value_type),
            kValueAlignmentOffset = 0,                          // To fix: This offset is zero for sets and >0 for maps. Need to fix this.
            kAllocFlagBuckets     = 0x00400000                  // Flag to allocator which indicates that we are allocating buckets and not nodes.
        };

    protected:
        node_type**     mpBucketArray;
        size_type       mnBucketCount;
        size_type       mnElementCount;
        RehashPolicy    mRehashPolicy;  // To do: Use base class optimization to make this go away.
        allocator_type  mAllocator;     // To do: Use base class optimization to make this go away.

    public:
        hashtable(size_type nBucketCount, const H1&, const H2&, const H&, const Equal&, const ExtractKey&,
                  const allocator_type& allocator = EASTL_HASHTABLE_DEFAULT_ALLOCATOR);

        template <typename FowardIterator>
        hashtable(FowardIterator first, FowardIterator last, size_type nBucketCount,
                  const H1&, const H2&, const H&, const Equal&, const ExtractKey&,
                  const allocator_type& allocator = EASTL_HASHTABLE_DEFAULT_ALLOCATOR); // allocator arg removed because VC7.1 fails on the default arg. To do: Make a second version of this function without a default arg.

        hashtable(const hashtable& x);
       ~hashtable();

        allocator_type& get_allocator();
        void            set_allocator(const allocator_type& allocator);

        this_type& operator=(const this_type& x);

        void swap(this_type& x);

    public:
        iterator begin()
        {
            iterator i(mpBucketArray);
            if(!i.mpNode)
                i.increment_bucket();
            return i;
        }

        const_iterator begin() const
        {
            const_iterator i(mpBucketArray);
            if(!i.mpNode)
                i.increment_bucket();
            return i;
        }

        iterator end()
            { return iterator(mpBucketArray + mnBucketCount); }

        const_iterator end() const
            { return const_iterator(mpBucketArray + mnBucketCount); }

        local_iterator begin(size_type n)
            { return local_iterator(mpBucketArray[n]); }

        local_iterator end(size_type)
            { return local_iterator(NULL); }

        const_local_iterator begin(size_type n) const
            { return const_local_iterator(mpBucketArray[n]); }

        const_local_iterator end(size_type) const
            { return const_local_iterator(NULL); }

        bool empty() const
        { return mnElementCount == 0; }

        size_type size() const
        { return mnElementCount; }

        size_type bucket_count() const
        { return mnBucketCount; }

        size_type bucket_size(size_type n) const
        { return (size_type)eastl::distance(begin(n), end(n)); }

        //size_type bucket(const key_type& k) const
        //    { return bucket_index(k, (hash code here), (uint32_t)mnBucketCount); }

    public:
        float load_factor() const
            { return (float)mnElementCount / (float)mnBucketCount; }

        // Inherited from the base class.
        // Returns the max load factor, which is the load factor beyond
        // which we rebuild the container with a new bucket count.
        // get_max_load_factor comes from rehash_base.
        //    float get_max_load_factor() const;

        // Inherited from the base class.
        // If you want to make the hashtable never rehash (resize),
        // set the max load factor to be a very high number (e.g. 100000.f).
        // set_max_load_factor comes from rehash_base.
        //    void set_max_load_factor(float fMaxLoadFactor);

        /// Generalization of get_max_load_factor. This is an extension that's
        /// not present in TR1.
        const rehash_policy_type& rehash_policy() const
            { return mRehashPolicy; }

        /// Generalization of set_max_load_factor. This is an extension that's
        /// not present in TR1.
        void rehash_policy(const rehash_policy_type& rehashPolicy);

    public:

        insert_return_type insert(const value_type& value);
        iterator           insert(const_iterator, const value_type& value);

        template <typename InputIterator>
        void insert(InputIterator first, InputIterator last);

    public:
        iterator         erase(iterator position);
        iterator         erase(iterator first, iterator last);
        reverse_iterator erase(reverse_iterator position);
        reverse_iterator erase(reverse_iterator first, reverse_iterator last);
        size_type        erase(const key_type& k);

        void clear();
        void clear(bool clearBuckets);
        void reset();
        void rehash(size_type nBucketCount);

    public:
        iterator       find(const key_type& key);
        const_iterator find(const key_type& key) const;

        /// Implements a find whereby the user supplies a comparison of a different type
        /// than the hashtable value_type. A useful case of this is one whereby you have
        /// a container of string objects but want to do searches via passing in char pointers.
        /// The problem is that without this kind of find, you need to do the expensive operation
        /// of converting the char pointer to a string so it can be used as the argument to the
        /// find function.
        ///
        /// Example usage (namespaces omitted for brevity):
        ///     hash_set<string> hashSet;
        ///     hashSet.find_as("hello");    // Use default hash and compare.
        ///
        /// Example usage (note that the predicate uses string as first type and char* as second):
        ///     hash_set<string> hashSet;
        ///     hashSet.find_as("hello", hash<char*>(), equal_to_2<string, char*>());
        ///
        template <typename U, typename UHash, typename BinaryPredicate>
        iterator       find_as(const U& u, UHash uhash, BinaryPredicate predicate);

        template <typename U, typename UHash, typename BinaryPredicate>
        const_iterator find_as(const U& u, UHash uhash, BinaryPredicate predicate) const;

        template <typename U>
        iterator       find_as(const U& u);

        template <typename U>
        const_iterator find_as(const U& u) const;

        /// Implements a find whereby the user supplies the node's hash code.
        ///
        iterator       find_by_hash(hash_code_t c);
        const_iterator find_by_hash(hash_code_t c) const;

        size_type      count(const key_type& k) const;

        eastl::pair<iterator, iterator>             equal_range(const key_type& k);
        eastl::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;

    public:
        bool validate() const;
        int  validate_iterator(const_iterator i) const;

    protected:
        node_type*  DoAllocateNode(const value_type& value);
        node_type*  DoAllocateNodeFromKey(const key_type& key);
        void        DoFreeNode(node_type* pNode);
        void        DoFreeNodes(node_type** pBucketArray, size_type);

        node_type** DoAllocateBuckets(size_type n);
        void        DoFreeBuckets(node_type** pBucketArray, size_type n);

        eastl::pair<iterator, bool>        DoInsertValue(const value_type& value, true_type);
        iterator                           DoInsertValue(const value_type& value, false_type);

        eastl::pair<iterator, bool>        DoInsertKey(const key_type& key, true_type);
        iterator                           DoInsertKey(const key_type& key, false_type);

        void       DoRehash(size_type nBucketCount);
        node_type* DoFindNode(node_type* pNode, const key_type& k, hash_code_t c) const;

        template <typename U, typename BinaryPredicate>
        node_type* DoFindNode(node_type* pNode, const U& u, BinaryPredicate predicate) const;

        node_type* DoFindNode(node_type* pNode, hash_code_t c) const;

    }; // class hashtable





    ///////////////////////////////////////////////////////////////////////
    // node_iterator_base
    ///////////////////////////////////////////////////////////////////////

    template <typename Value, bool bCacheHashCode>
    inline bool operator==(const node_iterator_base<Value, bCacheHashCode>& a, const node_iterator_base<Value, bCacheHashCode>& b)
        { return a.mpNode == b.mpNode; }

    template <typename Value, bool bCacheHashCode>
    inline bool operator!=(const node_iterator_base<Value, bCacheHashCode>& a, const node_iterator_base<Value, bCacheHashCode>& b)
        { return a.mpNode != b.mpNode; }




    ///////////////////////////////////////////////////////////////////////
    // hashtable_iterator_base
    ///////////////////////////////////////////////////////////////////////

    template <typename Value, bool bCacheHashCode>
    inline bool operator==(const hashtable_iterator_base<Value, bCacheHashCode>& a, const hashtable_iterator_base<Value, bCacheHashCode>& b)
        { return a.mpNode == b.mpNode; }

    template <typename Value, bool bCacheHashCode>
    inline bool operator!=(const hashtable_iterator_base<Value, bCacheHashCode>& a, const hashtable_iterator_base<Value, bCacheHashCode>& b)
        { return a.mpNode != b.mpNode; }




    ///////////////////////////////////////////////////////////////////////
    // hashtable
    ///////////////////////////////////////////////////////////////////////

    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>
    ::hashtable(size_type nBucketCount, const H1& h1, const H2& h2, const H& h,
                const Eq& eq, const EK& ek, const allocator_type& allocator)
        :   rehash_base<RP, hashtable>(),
            hash_code_base<K, V, EK, Eq, H1, H2, H, bC>(ek, eq, h1, h2, h),
            mnBucketCount(0),
            mnElementCount(0),
            mRehashPolicy(),
            mAllocator(allocator)
    {
        if(nBucketCount < 2)  // If we are starting in an initially empty state, with no memory allocation done.
            reset();
        else // Else we are creating a potentially non-empty hashtable...
        {
            EASTL_ASSERT(nBucketCount < 10000000);
            mnBucketCount = (size_type)mRehashPolicy.GetNextBucketCount((uint32_t)nBucketCount);
            mpBucketArray = DoAllocateBuckets(mnBucketCount); // mnBucketCount will always be at least 2.
        }
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    template <typename FowardIterator>
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::hashtable(FowardIterator first, FowardIterator last, size_type nBucketCount,
                                                                     const H1& h1, const H2& h2, const H& h,
                                                                     const Eq& eq, const EK& ek, const allocator_type& allocator)
        :   rehash_base<rehash_policy_type, hashtable>(),
            hash_code_base<key_type, value_type, extract_key_type, key_equal, h1_type, h2_type, h_type, kCacheHashCode>(ek, eq, h1, h2, h),
          //mnBucketCount(0), // This gets re-assigned below.
            mnElementCount(0),
            mRehashPolicy(),
            mAllocator(allocator)
    {
        if(nBucketCount < 2)
        {
            const size_type nElementCount = (size_type)eastl::ht_distance(first, last);
            mnBucketCount = (size_type)mRehashPolicy.GetBucketCount((uint32_t)nElementCount);
        }
        else
        {
            EASTL_ASSERT(nBucketCount < 10000000);
            mnBucketCount = nBucketCount;
        }

        mpBucketArray = DoAllocateBuckets(mnBucketCount); // mnBucketCount will always be at least 2.

        #if EASTL_EXCEPTIONS_ENABLED
            try
            {
        #endif
                for(; first != last; ++first)
                    insert(*first);
        #if EASTL_EXCEPTIONS_ENABLED
            }
            catch(...)
            {
                clear();
                DoFreeBuckets(mpBucketArray, mnBucketCount);
                throw;
            }
        #endif
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::hashtable(const this_type& x)
        :   rehash_base<RP, hashtable>(x),
            hash_code_base<K, V, EK, Eq, H1, H2, H, bC>(x),
            mnBucketCount(x.mnBucketCount),
            mnElementCount(x.mnElementCount),
            mRehashPolicy(x.mRehashPolicy),
            mAllocator(x.mAllocator)
    {
        if(mnElementCount) // If there is anything to copy...
        {
            mpBucketArray = DoAllocateBuckets(mnBucketCount); // mnBucketCount will be at least 2.

            #if EASTL_EXCEPTIONS_ENABLED
                try
                {
            #endif
                    for(size_type i = 0; i < x.mnBucketCount; ++i)
                    {
                        node_type*  pNodeSource = x.mpBucketArray[i];
                        node_type** ppNodeDest  = mpBucketArray + i;

                        while(pNodeSource)
                        {
                            *ppNodeDest = DoAllocateNode(pNodeSource->mValue);
                            copy_code(*ppNodeDest, pNodeSource);
                            ppNodeDest = &(*ppNodeDest)->mpNext;
                            pNodeSource = pNodeSource->mpNext;
                        }
                    }
            #if EASTL_EXCEPTIONS_ENABLED
                }
                catch(...)
                {
                    clear();
                    DoFreeBuckets(mpBucketArray, mnBucketCount);
                    throw;
                }
            #endif
        }
        else
        {
            // In this case, instead of allocate memory and copy nothing from x,
            // we reset ourselves to a zero allocation state.
            reset();
        }
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::allocator_type&
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::get_allocator()
    {
        return mAllocator;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::set_allocator(const allocator_type& allocator)
    {
        mAllocator = allocator;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::this_type&
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::operator=(const this_type& x)
    {
        if(this != &x)
        {
            clear();

            #if EASTL_ALLOCATOR_COPY_ENABLED
                mAllocator = x.mAllocator;
            #endif

            insert(x.begin(), x.end());
        }
        return *this;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::~hashtable()
    {
        clear();
        DoFreeBuckets(mpBucketArray, mnBucketCount);
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::node_type*
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoAllocateNode(const value_type& value)
    {
        node_type* const pNode = (node_type*)allocate_memory(mAllocator, sizeof(node_type), kValueAlignment, kValueAlignmentOffset);

        #if EASTL_EXCEPTIONS_ENABLED
            try
            {
        #endif
                ::new(&pNode->mValue) value_type(value);
                pNode->mpNext = NULL;
                return pNode;
        #if EASTL_EXCEPTIONS_ENABLED
            }
            catch(...)
            {
                EASTLFree(mAllocator, pNode, sizeof(node_type));
                throw;
            }
        #endif
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::node_type*
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoAllocateNodeFromKey(const key_type& key)
    {
        node_type* const pNode = (node_type*)allocate_memory(mAllocator, sizeof(node_type), kValueAlignment, kValueAlignmentOffset);

        #if EASTL_EXCEPTIONS_ENABLED
            try
            {
        #endif
                ::new(&pNode->mValue) value_type(key);
                pNode->mpNext = NULL;
                return pNode;
        #if EASTL_EXCEPTIONS_ENABLED
            }
            catch(...)
            {
                EASTLFree(mAllocator, pNode, sizeof(node_type));
                throw;
            }
        #endif
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoFreeNode(node_type* pNode)
    {
        pNode->~node_type();
        EASTLFree(mAllocator, pNode, sizeof(node_type));
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoFreeNodes(node_type** pNodeArray, size_type n)
    {
        for(size_type i = 0; i < n; ++i)
        {
            node_type* pNode = pNodeArray[i];
            while(pNode)
            {
                node_type* const pTempNode = pNode;
                pNode = pNode->mpNext;
                DoFreeNode(pTempNode);
            }
            pNodeArray[i] = NULL;
        }
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::node_type**
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoAllocateBuckets(size_type n)
    {
        // We allocate one extra bucket to hold a sentinel, an arbitrary
        // non-null pointer. Iterator increment relies on this.
        EASTL_ASSERT(n > 1); // We reserve an mnBucketCount of 1 for the shared gpEmptyBucketArray.
        EASTL_CT_ASSERT(kAllocFlagBuckets == 0x00400000); // Currently we expect this to be so, because the allocator has a copy of this enum.
        node_type** const pBucketArray = (node_type**)EASTLAllocFlags(mAllocator, (n + 1) * sizeof(node_type*), kAllocFlagBuckets);
        //eastl::fill(pBucketArray, pBucketArray + n, (node_type*)NULL);
        memset(pBucketArray, 0, n * sizeof(node_type*));
        pBucketArray[n] = reinterpret_cast<node_type*>((uintptr_t)~0);
        return pBucketArray;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoFreeBuckets(node_type** pBucketArray, size_type n)
    {
        // If n <= 1, then pBucketArray is from the shared gpEmptyBucketArray. We don't test
        // for pBucketArray == &gpEmptyBucketArray because one library have a different gpEmptyBucketArray
        // than another but pass a hashtable to another. So we go by the size.
        if(n > 1)
            EASTLFree(mAllocator, pBucketArray, (n + 1) * sizeof(node_type*)); // '+1' because DoAllocateBuckets allocates nBucketCount + 1 buckets in order to have a NULL sentinel at the end.
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::swap(this_type& x)
    {
        if(mAllocator == x.mAllocator) // If allocators are equivalent...
        {
            // We leave mAllocator as-is.
            hash_code_base<K, V, EK, Eq, H1, H2, H, bC>::base_swap(x); // hash_code_base has multiple implementations, so we let them handle the swap.
            eastl::swap(mRehashPolicy,  x.mRehashPolicy);
            eastl::swap(mpBucketArray,  x.mpBucketArray);
            eastl::swap(mnBucketCount,  x.mnBucketCount);
            eastl::swap(mnElementCount, x.mnElementCount);
        }
        else
        {
            const this_type temp(*this); // Can't call eastl::swap because that would
            *this = x;                   // itself call this member swap function.
            x     = temp;
        }
    }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::rehash_policy(const rehash_policy_type& rehashPolicy)
    {
        mRehashPolicy = rehashPolicy;

        const size_type nBuckets = rehashPolicy.GetBucketCount((uint32_t)mnElementCount);

        if(nBuckets > mnBucketCount)
            DoRehash(nBuckets);
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::find(const key_type& k)
    {
        const hash_code_t c = get_hash_code(k);
        const size_type   n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount);

        node_type* const pNode = DoFindNode(mpBucketArray[n], k, c);
        return pNode ? iterator(pNode, mpBucketArray + n) : iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end()
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::const_iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::find(const key_type& k) const
    {
        const hash_code_t c = get_hash_code(k);
        const size_type   n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount);

        node_type* const pNode = DoFindNode(mpBucketArray[n], k, c);
        return pNode ? const_iterator(pNode, mpBucketArray + n) : const_iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end()
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    template <typename U, typename UHash, typename BinaryPredicate>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::find_as(const U& other, UHash uhash, BinaryPredicate predicate)
    {
        const hash_code_t c = (hash_code_t)uhash(other);
        const size_type   n = (size_type)(c % mnBucketCount); // This assumes we are using the mod range policy.

        node_type* const pNode = DoFindNode(mpBucketArray[n], other, predicate);
        return pNode ? iterator(pNode, mpBucketArray + n) : iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end()
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    template <typename U, typename UHash, typename BinaryPredicate>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::const_iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::find_as(const U& other, UHash uhash, BinaryPredicate predicate) const
    {
        const hash_code_t c = (hash_code_t)uhash(other);
        const size_type   n = (size_type)(c % mnBucketCount); // This assumes we are using the mod range policy.

        node_type* const pNode = DoFindNode(mpBucketArray[n], other, predicate);
        return pNode ? const_iterator(pNode, mpBucketArray + n) : const_iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end()
    }


    /// hashtable_find
    ///
    /// Helper function that defaults to using hash<U> and equal_to_2<T, U>.
    /// This makes it so that by default you don't need to provide these.
    /// Note that the default hash functions may not be what you want, though.
    ///
    /// Example usage. Instead of this:
    ///     hash_set<string> hashSet;
    ///     hashSet.find("hello", hash<char*>(), equal_to_2<string, char*>());
    ///
    /// You can use this:
    ///     hash_set<string> hashSet;
    ///     hashtable_find(hashSet, "hello");
    ///
    template <typename H, typename U>
    inline typename H::iterator hashtable_find(H& hashTable, U u)
        { return hashTable.find_as(u, eastl::hash<U>(), eastl::equal_to_2<const typename H::key_type, U>()); }

    template <typename H, typename U>
    inline typename H::const_iterator hashtable_find(const H& hashTable, U u)
        { return hashTable.find_as(u, eastl::hash<U>(), eastl::equal_to_2<const typename H::key_type, U>()); }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    template <typename U>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::find_as(const U& other)
        { return eastl::hashtable_find(*this, other); }
        // VC++ doesn't appear to like the following, though it seems correct to me.
        // So we implement the workaround above until we can straighten this out.
        //{ return find_as(other, eastl::hash<U>(), eastl::equal_to_2<const key_type, U>()); }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    template <typename U>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::const_iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::find_as(const U& other) const
        { return eastl::hashtable_find(*this, other); }
        // VC++ doesn't appear to like the following, though it seems correct to me.
        // So we implement the workaround above until we can straighten this out.
        //{ return find_as(other, eastl::hash<U>(), eastl::equal_to_2<const key_type, U>()); }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::find_by_hash(hash_code_t c)
    {
        const size_type n = (size_type)bucket_index(c, (uint32_t)mnBucketCount);

        node_type* const pNode = DoFindNode(mpBucketArray[n], c);
        return pNode ? iterator(pNode, mpBucketArray + n) : iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end()
    }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::const_iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::find_by_hash(hash_code_t c) const
    {
        const size_type n = (size_type)bucket_index(c, (uint32_t)mnBucketCount);

        node_type* const pNode = DoFindNode(mpBucketArray[n], c);
        return pNode ? const_iterator(pNode, mpBucketArray + n) : const_iterator(mpBucketArray + mnBucketCount); // iterator(mpBucketArray + mnBucketCount) == end()
    }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::size_type
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::count(const key_type& k) const
    {
        const hash_code_t c      = get_hash_code(k);
        const size_type   n      = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount);
        size_type         result = 0;

        // To do: Make a specialization for bU (unique keys) == true and take
        // advantage of the fact that the count will always be zero or one in that case.
        for(node_type* pNode = mpBucketArray[n]; pNode; pNode = pNode->mpNext)
        {
            if(compare(k, c, pNode))
                ++result;
        }
        return result;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    eastl::pair<typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator,
                typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator>
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::equal_range(const key_type& k)
    {
        const hash_code_t c = get_hash_code(k);
        const size_type   n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount);

        node_type** head  = mpBucketArray + n;
        node_type*  pNode = DoFindNode(*head, k, c);

        if(pNode)
        {
            node_type* p1 = pNode->mpNext;

            for(; p1; p1 = p1->mpNext)
            {
                if(!compare(k, c, p1))
                    break;
            }

            iterator first(pNode, head);
            iterator last(p1, head);

            if(!p1)
                last.increment_bucket();

            return eastl::pair<iterator, iterator>(first, last);
        }

        return eastl::pair<iterator, iterator>(iterator(mpBucketArray + mnBucketCount),  // iterator(mpBucketArray + mnBucketCount) == end()
                                               iterator(mpBucketArray + mnBucketCount));
    }




    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    eastl::pair<typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::const_iterator,
                typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::const_iterator>
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::equal_range(const key_type& k) const
    {
        const hash_code_t c     = get_hash_code(k);
        const size_type   n     = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount);
        node_type**       head  = mpBucketArray + n;
        node_type*        pNode = DoFindNode(*head, k, c);

        if(pNode)
        {
            node_type* p1 = pNode->mpNext;

            for(; p1; p1 = p1->mpNext)
            {
                if(!compare(k, c, p1))
                    break;
            }

            const_iterator first(pNode, head);
            const_iterator last(p1, head);

            if(!p1)
                last.increment_bucket();

            return eastl::pair<const_iterator, const_iterator>(first, last);
        }

        return eastl::pair<const_iterator, const_iterator>(const_iterator(mpBucketArray + mnBucketCount),  // iterator(mpBucketArray + mnBucketCount) == end()
                                                           const_iterator(mpBucketArray + mnBucketCount));
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::node_type*
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoFindNode(node_type* pNode, const key_type& k, hash_code_t c) const
    {
        for(; pNode; pNode = pNode->mpNext)
        {
            if(compare(k, c, pNode))
                return pNode;
        }
        return NULL;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    template <typename U, typename BinaryPredicate>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::node_type*
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoFindNode(node_type* pNode, const U& other, BinaryPredicate predicate) const
    {
        for(; pNode; pNode = pNode->mpNext)
        {
            if(predicate(mExtractKey(pNode->mValue), other)) // Intentionally compare with key as first arg and other as second arg.
                return pNode;
        }
        return NULL;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::node_type*
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoFindNode(node_type* pNode, hash_code_t c) const
    {
        for(; pNode; pNode = pNode->mpNext)
        {
            if(pNode->mnHashCode == c)
                return pNode;
        }
        return NULL;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    eastl::pair<typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator, bool>
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoInsertValue(const value_type& value, true_type) // true_type means bUniqueKeys is true.
    {
        const key_type&   k     = mExtractKey(value);
        const hash_code_t c     = get_hash_code(k);
        size_type         n     = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount);
        node_type* const  pNode = DoFindNode(mpBucketArray[n], k, c);

        if(pNode == NULL)
        {
            const eastl::pair<bool, uint32_t> bRehash = mRehashPolicy.GetRehashRequired((uint32_t)mnBucketCount, (uint32_t)mnElementCount, (uint32_t)1);

            // Allocate the new node before doing the rehash so that we don't
            // do a rehash if the allocation throws.
            node_type* const pNodeNew = DoAllocateNode(value);
            set_code(pNodeNew, c); // This is a no-op for most hashtables.

            #if EASTL_EXCEPTIONS_ENABLED
                try
                {
            #endif
                    if(bRehash.first)
                    {
                        n = (size_type)bucket_index(k, c, (uint32_t)bRehash.second);
                        DoRehash(bRehash.second);
                    }

                    EASTL_ASSERT((void**)mpBucketArray != &gpEmptyBucketArray[0]);
                    pNodeNew->mpNext = mpBucketArray[n];
                    mpBucketArray[n] = pNodeNew;
                    ++mnElementCount;

                    return eastl::pair<iterator, bool>(iterator(pNodeNew, mpBucketArray + n), true);
            #if EASTL_EXCEPTIONS_ENABLED
                }
                catch(...)
                {
                    DoFreeNode(pNodeNew);
                    throw;
                }
            #endif
        }

        return eastl::pair<iterator, bool>(iterator(pNode, mpBucketArray + n), false);
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoInsertValue(const value_type& value, false_type) // false_type means bUniqueKeys is false.
    {
        const eastl::pair<bool, uint32_t> bRehash = mRehashPolicy.GetRehashRequired((uint32_t)mnBucketCount, (uint32_t)mnElementCount, (uint32_t)1);

        if(bRehash.first)
            DoRehash(bRehash.second);

        const key_type&   k = mExtractKey(value);
        const hash_code_t c = get_hash_code(k);
        const size_type   n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount);

        node_type* const pNodeNew = DoAllocateNode(value);
        set_code(pNodeNew, c); // This is a no-op for most hashtables.

        // To consider: Possibly make this insertion not make equal elements contiguous.
        // As it stands now, we insert equal values contiguously in the hashtable.
        // The benefit is that equal_range can work in a sensible manner and that
        // erase(value) can more quickly find equal values. The downside is that
        // this insertion operation taking some extra time. How important is it to
        // us that equal_range span all equal items?
        node_type* const pNodePrev = DoFindNode(mpBucketArray[n], k, c);

        if(pNodePrev == NULL)
        {
            EASTL_ASSERT((void**)mpBucketArray != &gpEmptyBucketArray[0]);
            pNodeNew->mpNext = mpBucketArray[n];
            mpBucketArray[n] = pNodeNew;
        }
        else
        {
            pNodeNew->mpNext  = pNodePrev->mpNext;
            pNodePrev->mpNext = pNodeNew;
        }

        ++mnElementCount;

        return iterator(pNodeNew, mpBucketArray + n);
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    eastl::pair<typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator, bool>
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoInsertKey(const key_type& key, true_type) // true_type means bUniqueKeys is true.
    {
        const hash_code_t c     = get_hash_code(key);
        size_type         n     = (size_type)bucket_index(key, c, (uint32_t)mnBucketCount);
        node_type* const  pNode = DoFindNode(mpBucketArray[n], key, c);

        if(pNode == NULL)
        {
            const eastl::pair<bool, uint32_t> bRehash = mRehashPolicy.GetRehashRequired((uint32_t)mnBucketCount, (uint32_t)mnElementCount, (uint32_t)1);

            // Allocate the new node before doing the rehash so that we don't
            // do a rehash if the allocation throws.
            node_type* const pNodeNew = DoAllocateNodeFromKey(key);
            set_code(pNodeNew, c); // This is a no-op for most hashtables.

            #if EASTL_EXCEPTIONS_ENABLED
                try
                {
            #endif
                    if(bRehash.first)
                    {
                        n = (size_type)bucket_index(key, c, (uint32_t)bRehash.second);
                        DoRehash(bRehash.second);
                    }

                    EASTL_ASSERT((void**)mpBucketArray != &gpEmptyBucketArray[0]);
                    pNodeNew->mpNext = mpBucketArray[n];
                    mpBucketArray[n] = pNodeNew;
                    ++mnElementCount;

                    return eastl::pair<iterator, bool>(iterator(pNodeNew, mpBucketArray + n), true);
            #if EASTL_EXCEPTIONS_ENABLED
                }
                catch(...)
                {
                    DoFreeNode(pNodeNew);
                    throw;
                }
            #endif
        }

        return eastl::pair<iterator, bool>(iterator(pNode, mpBucketArray + n), false);
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoInsertKey(const key_type& key, false_type) // false_type means bUniqueKeys is false.
    {
        const eastl::pair<bool, uint32_t> bRehash = mRehashPolicy.GetRehashRequired((uint32_t)mnBucketCount, (uint32_t)mnElementCount, (uint32_t)1);

        if(bRehash.first)
            DoRehash(bRehash.second);

        const hash_code_t c = get_hash_code(key);
        const size_type   n = (size_type)bucket_index(key, c, (uint32_t)mnBucketCount);

        node_type* const pNodeNew = DoAllocateNodeFromKey(key);
        set_code(pNodeNew, c); // This is a no-op for most hashtables.

        // To consider: Possibly make this insertion not make equal elements contiguous.
        // As it stands now, we insert equal values contiguously in the hashtable.
        // The benefit is that equal_range can work in a sensible manner and that
        // erase(value) can more quickly find equal values. The downside is that
        // this insertion operation taking some extra time. How important is it to
        // us that equal_range span all equal items?
        node_type* const pNodePrev = DoFindNode(mpBucketArray[n], key, c);

        if(pNodePrev == NULL)
        {
            EASTL_ASSERT((void**)mpBucketArray != &gpEmptyBucketArray[0]);
            pNodeNew->mpNext = mpBucketArray[n];
            mpBucketArray[n] = pNodeNew;
        }
        else
        {
            pNodeNew->mpNext  = pNodePrev->mpNext;
            pNodePrev->mpNext = pNodeNew;
        }

        ++mnElementCount;

        return iterator(pNodeNew, mpBucketArray + n);
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::insert_return_type
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::insert(const value_type& value)
    {
        return DoInsertValue(value, integral_constant<bool, bU>());
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::insert(const_iterator, const value_type& value)
    {
        // We ignore the first argument (hint iterator). It's not likely to be useful for hashtable containers.

        #ifdef __MWERKS__ // The Metrowerks compiler has a bug.
            insert_return_type result = insert(value);
            return result.first; // Note by Paul Pedriana while perusing this code: This code will fail to compile when bU is false (i.e. for multiset, multimap).

        #elif defined(__GNUC__) && (__GNUC__ < 3) // If using old GCC (GCC 2.x has a bug which we work around)
            EASTL_ASSERT(empty()); // This function cannot return the correct return value on GCC 2.x. Unless, that is, the container is empty.
            DoInsertValue(value, integral_constant<bool, bU>());
            return begin(); // This is the wrong answer.
        #else
            insert_return_type result = DoInsertValue(value, integral_constant<bool, bU>());
            return result.first; // Note by Paul Pedriana while perusing this code: This code will fail to compile when bU is false (i.e. for multiset, multimap).
        #endif
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    template <typename InputIterator>
    void
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::insert(InputIterator first, InputIterator last)
    {
        const uint32_t nElementAdd = (uint32_t)eastl::ht_distance(first, last);
        const eastl::pair<bool, uint32_t> bRehash = mRehashPolicy.GetRehashRequired((uint32_t)mnBucketCount, (uint32_t)mnElementCount, nElementAdd);

        if(bRehash.first)
            DoRehash(bRehash.second);

        for(; first != last; ++first)
        {
            #ifdef __MWERKS__ // The Metrowerks compiler has a bug.
                insert(*first);
            #else
                DoInsertValue(*first, integral_constant<bool, bU>());
            #endif
        }
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::erase(iterator i)
    {
        iterator iNext(i);
        ++iNext;

        node_type* pNode        =  i.mpNode;
        node_type* pNodeCurrent = *i.mpBucket;

        if(pNodeCurrent == pNode)
            *i.mpBucket = pNodeCurrent->mpNext;
        else
        {
            // We have a singly-linked list, so we have no choice but to
            // walk down it till we find the node before the node at 'i'.
            node_type* pNodeNext = pNodeCurrent->mpNext;

            while(pNodeNext != pNode)
            {
                pNodeCurrent = pNodeNext;
                pNodeNext    = pNodeCurrent->mpNext;
            }

            pNodeCurrent->mpNext = pNodeNext->mpNext;
        }

        DoFreeNode(pNode);
        --mnElementCount;

        return iNext;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::erase(iterator first, iterator last)
    {
        while(first != last)
            first = erase(first);
        return first;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::reverse_iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::erase(reverse_iterator position)
    {
        return reverse_iterator(erase((++position).base()));
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::reverse_iterator
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::erase(reverse_iterator first, reverse_iterator last)
    {
        // Version which erases in order from first to last.
        // difference_type i(first.base() - last.base());
        // while(i--)
        //     first = erase(first);
        // return first;

        // Version which erases in order from last to first, but is slightly more efficient:
        return reverse_iterator(erase((++last).base(), (++first).base()));
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::size_type
    hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::erase(const key_type& k)
    {
        // To do: Reimplement this function to do a single loop and not try to be
        // smart about element contiguity. The mechanism here is only a benefit if the
        // buckets are heavily overloaded; otherwise this mechanism may be slightly slower.

        const hash_code_t c = get_hash_code(k);
        const size_type   n = (size_type)bucket_index(k, c, (uint32_t)mnBucketCount);
        const size_type   nElementCountSaved = mnElementCount;

        node_type** pBucketArray = mpBucketArray + n;

        while(*pBucketArray && !compare(k, c, *pBucketArray))
            pBucketArray = &(*pBucketArray)->mpNext;

        while(*pBucketArray && compare(k, c, *pBucketArray))
        {
            node_type* const pNode = *pBucketArray;
            *pBucketArray = pNode->mpNext;
            DoFreeNode(pNode);
            --mnElementCount;
        }

        return nElementCountSaved - mnElementCount;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::clear()
    {
        DoFreeNodes(mpBucketArray, mnBucketCount);
        mnElementCount = 0;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::clear(bool clearBuckets)
    {
        DoFreeNodes(mpBucketArray, mnBucketCount);
        if(clearBuckets)
        {
            DoFreeBuckets(mpBucketArray, mnBucketCount);
            reset();
        }
        mnElementCount = 0;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::reset()
    {
        // The reset function is a special extension function which unilaterally
        // resets the container to an empty state without freeing the memory of
        // the contained objects. This is useful for very quickly tearing down a
        // container built into scratch memory.
        mnBucketCount  = 1;

        #ifdef _MSC_VER
            mpBucketArray = (node_type**)&gpEmptyBucketArray[0];
        #else
            void* p = &gpEmptyBucketArray[0];
            memcpy(&mpBucketArray, &p, sizeof(mpBucketArray)); // Other compilers implement strict aliasing and casting is thus unsafe.
        #endif

        mnElementCount = 0;
        mRehashPolicy.mnNextResize = 0;
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::rehash(size_type nBucketCount)
    {
        // Note that we unilaterally use the passed in bucket count; we do not attempt migrate it
        // up to the next prime number. We leave it at the user's discretion to do such a thing.
        DoRehash(nBucketCount);
    }



    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::DoRehash(size_type nNewBucketCount)
    {
        node_type** const pBucketArray = DoAllocateBuckets(nNewBucketCount); // nNewBucketCount should always be >= 2.

        #if EASTL_EXCEPTIONS_ENABLED
            try
            {
        #endif
                node_type* pNode;

                for(size_type i = 0; i < mnBucketCount; ++i)
                {
                    while((pNode = mpBucketArray[i]) != NULL) // Using '!=' disables compiler warnings.
                    {
                        const size_type nNewBucketIndex = (size_type)bucket_index(pNode, (uint32_t)nNewBucketCount);

                        mpBucketArray[i] = pNode->mpNext;
                        pNode->mpNext    = pBucketArray[nNewBucketIndex];
                        pBucketArray[nNewBucketIndex] = pNode;
                    }
                }

                DoFreeBuckets(mpBucketArray, mnBucketCount);
                mnBucketCount = nNewBucketCount;
                mpBucketArray = pBucketArray;
        #if EASTL_EXCEPTIONS_ENABLED
            }
            catch(...)
            {
                // A failure here means that a hash function threw an exception.
                // We can't restore the previous state without calling the hash
                // function again, so the only sensible recovery is to delete everything.
                DoFreeNodes(pBucketArray, nNewBucketCount);
                DoFreeBuckets(pBucketArray, nNewBucketCount);
                DoFreeNodes(mpBucketArray, mnBucketCount);
                mnElementCount = 0;
                throw;
            }
        #endif
    }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline bool hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::validate() const
    {
        // Verify our empty bucket array is unmodified.
        if(gpEmptyBucketArray[0] != NULL)
            return false;

        if(gpEmptyBucketArray[1] != (void*)uintptr_t(~0))
            return false;

        // Verify that we have at least one bucket. Calculations can
        // trigger division by zero exceptions otherwise.
        if(mnBucketCount == 0)
            return false;

        // Verify that gpEmptyBucketArray is used correctly.
        // gpEmptyBucketArray is only used when initially empty.
        if((void**)mpBucketArray == &gpEmptyBucketArray[0])
        {
            if(mnElementCount) // gpEmptyBucketArray is used only for empty hash tables.
                return false;

            if(mnBucketCount != 1) // gpEmptyBucketArray is used exactly an only for mnBucketCount == 1.
                return false;
        }
        else
        {
            if(mnBucketCount < 2) // Small bucket counts *must* use gpEmptyBucketArray.
                return false;
        }

        // Verify that the element count matches mnElementCount.
        size_type nElementCount = 0;

        for(const_iterator temp = begin(), tempEnd = end(); temp != tempEnd; ++temp)
            ++nElementCount;

        if(nElementCount != mnElementCount)
            return false;

        // To do: Verify that individual elements are in the expected buckets.

        return true;
    }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    int hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::validate_iterator(const_iterator i) const
    {
        // To do: Come up with a more efficient mechanism of doing this.

        for(const_iterator temp = begin(), tempEnd = end(); temp != tempEnd; ++temp)
        {
            if(temp == i)
                return (isf_valid | isf_current | isf_can_dereference);
        }

        if(i == end())
            return (isf_valid | isf_current);

        return isf_none;
    }



    ///////////////////////////////////////////////////////////////////////
    // global operators
    ///////////////////////////////////////////////////////////////////////

    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline bool operator==(const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& a,
                           const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& b)
    {
        return (a.size() == b.size()) && eastl::equal(a.begin(), a.end(), b.begin());
    }


    // Comparing hash tables for less-ness is an odd thing to do. We provide it for
    // completeness, though the user is advised to be wary of how they use this.
    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline bool operator<(const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& a,
                          const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& b)
    {
        // This requires hash table elements to support operator<. Since the hash table
        // doesn't compare elements via less (it does so via equals), we must use the
        // globally defined operator less for the elements.
        return eastl::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
    }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline bool operator!=(const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& a,
                           const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& b)
    {
        return !(a == b);
    }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline bool operator>(const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& a,
                          const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& b)
    {
        return b < a;
    }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline bool operator<=(const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& a,
                           const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& b)
    {
        return !(b < a);
    }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline bool operator>=(const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& a,
                           const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& b)
    {
        return !(a < b);
    }


    template <typename K, typename V, typename A, typename EK, typename Eq,
              typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
    inline void swap(const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& a,
                     const hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>& b)
    {
        a.swap(b);
    }


} // namespace eastl


#ifdef _MSC_VER
    #pragma warning(pop)
#endif

#endif // Header include guard
