// Internal policy header for unordered_set and unordered_map -*- C++ -*-
-// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
+// Copyright (C) 2010, 2011, 2012 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#ifndef _HASHTABLE_POLICY_H
#define _HASHTABLE_POLICY_H 1
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std _GLIBCXX_VISIBILITY(default)
+{
namespace __detail
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// Helper function: return distance(first, last) for forward
// iterators, or 0 for input iterators.
template<class _Iterator>
return __distance_fw(__first, __last, _Tag());
}
+ // Helper type used to detect when the hash functor is noexcept qualified or
+ // not
+ template <typename _Key, typename _Hash>
+ struct __is_noexcept_hash : std::integral_constant<bool,
+ noexcept(declval<const _Hash&>()(declval<const _Key&>()))>
+ {};
+
// Auxiliary types used for all instantiations of _Hashtable: nodes
// and iterators.
// template parameter of class template _Hashtable controls whether
// nodes also store a hash code. In some cases (e.g. strings) this
// may be a performance win.
+ struct _Hash_node_base
+ {
+ _Hash_node_base* _M_nxt;
+
+ _Hash_node_base()
+ : _M_nxt() { }
+ _Hash_node_base(_Hash_node_base* __next)
+ : _M_nxt(__next) { }
+ };
+
template<typename _Value, bool __cache_hash_code>
struct _Hash_node;
template<typename _Value>
- struct _Hash_node<_Value, true>
+ struct _Hash_node<_Value, true> : _Hash_node_base
{
_Value _M_v;
std::size_t _M_hash_code;
- _Hash_node* _M_next;
template<typename... _Args>
_Hash_node(_Args&&... __args)
- : _M_v(std::forward<_Args>(__args)...),
- _M_hash_code(), _M_next() { }
+ : _M_v(std::forward<_Args>(__args)...), _M_hash_code() { }
+
+ _Hash_node* _M_next() const
+ { return static_cast<_Hash_node*>(_M_nxt); }
};
template<typename _Value>
- struct _Hash_node<_Value, false>
+ struct _Hash_node<_Value, false> : _Hash_node_base
{
_Value _M_v;
- _Hash_node* _M_next;
template<typename... _Args>
_Hash_node(_Args&&... __args)
- : _M_v(std::forward<_Args>(__args)...),
- _M_next() { }
+ : _M_v(std::forward<_Args>(__args)...) { }
+
+ _Hash_node* _M_next() const
+ { return static_cast<_Hash_node*>(_M_nxt); }
};
- // Local iterators, used to iterate within a bucket but not between
- // buckets.
+ // Node iterators, used to iterate through all the hashtable.
template<typename _Value, bool __cache>
struct _Node_iterator_base
{
void
_M_incr()
- { _M_cur = _M_cur->_M_next; }
+ { _M_cur = _M_cur->_M_next(); }
_Hash_node<_Value, __cache>* _M_cur;
};
}
};
- template<typename _Value, bool __cache>
- struct _Hashtable_iterator_base
- {
- _Hashtable_iterator_base(_Hash_node<_Value, __cache>* __node,
- _Hash_node<_Value, __cache>** __bucket)
- : _M_cur_node(__node), _M_cur_bucket(__bucket) { }
-
- void
- _M_incr()
- {
- _M_cur_node = _M_cur_node->_M_next;
- if (!_M_cur_node)
- _M_incr_bucket();
- }
-
- void
- _M_incr_bucket();
-
- _Hash_node<_Value, __cache>* _M_cur_node;
- _Hash_node<_Value, __cache>** _M_cur_bucket;
- };
-
- // Global iterators, used for arbitrary iteration within a hash
- // table. Larger and more expensive than local iterators.
- template<typename _Value, bool __cache>
- void
- _Hashtable_iterator_base<_Value, __cache>::
- _M_incr_bucket()
- {
- ++_M_cur_bucket;
-
- // This loop requires the bucket array to have a non-null sentinel.
- while (!*_M_cur_bucket)
- ++_M_cur_bucket;
- _M_cur_node = *_M_cur_bucket;
- }
-
- template<typename _Value, bool __cache>
- inline bool
- operator==(const _Hashtable_iterator_base<_Value, __cache>& __x,
- const _Hashtable_iterator_base<_Value, __cache>& __y)
- { return __x._M_cur_node == __y._M_cur_node; }
-
- template<typename _Value, bool __cache>
- inline bool
- operator!=(const _Hashtable_iterator_base<_Value, __cache>& __x,
- const _Hashtable_iterator_base<_Value, __cache>& __y)
- { return __x._M_cur_node != __y._M_cur_node; }
-
- template<typename _Value, bool __constant_iterators, bool __cache>
- struct _Hashtable_iterator
- : public _Hashtable_iterator_base<_Value, __cache>
- {
- typedef _Value value_type;
- typedef typename std::conditional<__constant_iterators,
- const _Value*, _Value*>::type
- pointer;
- typedef typename std::conditional<__constant_iterators,
- const _Value&, _Value&>::type
- reference;
- typedef std::ptrdiff_t difference_type;
- typedef std::forward_iterator_tag iterator_category;
-
- _Hashtable_iterator()
- : _Hashtable_iterator_base<_Value, __cache>(0, 0) { }
-
- _Hashtable_iterator(_Hash_node<_Value, __cache>* __p,
- _Hash_node<_Value, __cache>** __b)
- : _Hashtable_iterator_base<_Value, __cache>(__p, __b) { }
-
- explicit
- _Hashtable_iterator(_Hash_node<_Value, __cache>** __b)
- : _Hashtable_iterator_base<_Value, __cache>(*__b, __b) { }
-
- reference
- operator*() const
- { return this->_M_cur_node->_M_v; }
-
- pointer
- operator->() const
- { return std::__addressof(this->_M_cur_node->_M_v); }
-
- _Hashtable_iterator&
- operator++()
- {
- this->_M_incr();
- return *this;
- }
-
- _Hashtable_iterator
- operator++(int)
- {
- _Hashtable_iterator __tmp(*this);
- this->_M_incr();
- return __tmp;
- }
- };
-
- template<typename _Value, bool __constant_iterators, bool __cache>
- struct _Hashtable_const_iterator
- : public _Hashtable_iterator_base<_Value, __cache>
- {
- typedef _Value value_type;
- typedef const _Value* pointer;
- typedef const _Value& reference;
- typedef std::ptrdiff_t difference_type;
- typedef std::forward_iterator_tag iterator_category;
-
- _Hashtable_const_iterator()
- : _Hashtable_iterator_base<_Value, __cache>(0, 0) { }
-
- _Hashtable_const_iterator(_Hash_node<_Value, __cache>* __p,
- _Hash_node<_Value, __cache>** __b)
- : _Hashtable_iterator_base<_Value, __cache>(__p, __b) { }
-
- explicit
- _Hashtable_const_iterator(_Hash_node<_Value, __cache>** __b)
- : _Hashtable_iterator_base<_Value, __cache>(*__b, __b) { }
-
- _Hashtable_const_iterator(const _Hashtable_iterator<_Value,
- __constant_iterators, __cache>& __x)
- : _Hashtable_iterator_base<_Value, __cache>(__x._M_cur_node,
- __x._M_cur_bucket) { }
-
- reference
- operator*() const
- { return this->_M_cur_node->_M_v; }
-
- pointer
- operator->() const
- { return std::__addressof(this->_M_cur_node->_M_v); }
-
- _Hashtable_const_iterator&
- operator++()
- {
- this->_M_incr();
- return *this;
- }
-
- _Hashtable_const_iterator
- operator++(int)
- {
- _Hashtable_const_iterator __tmp(*this);
- this->_M_incr();
- return __tmp;
- }
- };
-
-
// Many of class template _Hashtable's template parameters are policy
// classes. These are defaults for the policies.
struct _Prime_rehash_policy
{
_Prime_rehash_policy(float __z = 1.0)
- : _M_max_load_factor(__z), _M_growth_factor(2.f), _M_next_resize(0) { }
+ : _M_max_load_factor(__z), _M_prev_resize(0), _M_next_resize(0) { }
float
- max_load_factor() const
+ max_load_factor() const noexcept
{ return _M_max_load_factor; }
// Return a bucket size no smaller than n.
_M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
std::size_t __n_ins) const;
+ typedef std::pair<std::size_t, std::size_t> _State;
+
+ _State
+ _M_state() const
+ { return std::make_pair(_M_prev_resize, _M_next_resize); }
+
+ void
+ _M_reset(const _State& __state)
+ {
+ _M_prev_resize = __state.first;
+ _M_next_resize = __state.second;
+ }
+
enum { _S_n_primes = sizeof(unsigned long) != 8 ? 256 : 256 + 48 };
float _M_max_load_factor;
- float _M_growth_factor;
+ mutable std::size_t _M_prev_resize;
mutable std::size_t _M_next_resize;
};
_Prime_rehash_policy::
_M_next_bkt(std::size_t __n) const
{
- const unsigned long* __p = std::lower_bound(__prime_list, __prime_list
- + _S_n_primes, __n);
- _M_next_resize =
- static_cast<std::size_t>(__builtin_ceil(*__p * _M_max_load_factor));
+ // Optimize lookups involving the first elements of __prime_list.
+ // (useful to speed-up, eg, constructors)
+ static const unsigned char __fast_bkt[12]
+ = { 2, 2, 2, 3, 5, 5, 7, 7, 11, 11, 11, 11 };
+
+ if (__n <= 11)
+ {
+ _M_prev_resize = 0;
+ _M_next_resize
+ = __builtin_ceil(__fast_bkt[__n] * (long double)_M_max_load_factor);
+ return __fast_bkt[__n];
+ }
+
+ const unsigned long* __p
+ = std::lower_bound(__prime_list + 5, __prime_list + _S_n_primes, __n);
+
+ // Shrink will take place only if the number of elements is small enough
+ // so that the prime number 2 steps before __p is large enough to still
+ // conform to the max load factor:
+ _M_prev_resize
+ = __builtin_floor(*(__p - 2) * (long double)_M_max_load_factor);
+
+ // Let's guaranty that a minimal grow step of 11 is used
+ if (*__p - __n < 11)
+ __p = std::lower_bound(__p, __prime_list + _S_n_primes, __n + 11);
+ _M_next_resize = __builtin_ceil(*__p * (long double)_M_max_load_factor);
return *__p;
}
inline std::size_t
_Prime_rehash_policy::
_M_bkt_for_elements(std::size_t __n) const
- {
- const float __min_bkts = __n / _M_max_load_factor;
- const unsigned long* __p = std::lower_bound(__prime_list, __prime_list
- + _S_n_primes, __min_bkts);
- _M_next_resize =
- static_cast<std::size_t>(__builtin_ceil(*__p * _M_max_load_factor));
- return *__p;
- }
+ { return _M_next_bkt(__builtin_ceil(__n / (long double)_M_max_load_factor)); }
// Finds the smallest prime p such that alpha p > __n_elt + __n_ins.
// If p > __n_bkt, return make_pair(true, p); otherwise return
_M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
std::size_t __n_ins) const
{
- if (__n_elt + __n_ins > _M_next_resize)
+ if (__n_elt + __n_ins >= _M_next_resize)
{
- float __min_bkts = ((float(__n_ins) + float(__n_elt))
- / _M_max_load_factor);
- if (__min_bkts > __n_bkt)
- {
- __min_bkts = std::max(__min_bkts, _M_growth_factor * __n_bkt);
- const unsigned long* __p =
- std::lower_bound(__prime_list, __prime_list + _S_n_primes,
- __min_bkts);
- _M_next_resize = static_cast<std::size_t>
- (__builtin_ceil(*__p * _M_max_load_factor));
- return std::make_pair(true, *__p);
- }
+ long double __min_bkts = (__n_elt + __n_ins)
+ / (long double)_M_max_load_factor;
+ if (__min_bkts >= __n_bkt)
+ return std::make_pair(true,
+ _M_next_bkt(__builtin_floor(__min_bkts) + 1));
else
{
- _M_next_resize = static_cast<std::size_t>
- (__builtin_ceil(__n_bkt * _M_max_load_factor));
+ _M_next_resize
+ = __builtin_floor(__n_bkt * (long double)_M_max_load_factor);
return std::make_pair(false, 0);
}
}
+ else if (__n_elt + __n_ins < _M_prev_resize)
+ {
+ long double __min_bkts = (__n_elt + __n_ins)
+ / (long double)_M_max_load_factor;
+ return std::make_pair(true,
+ _M_next_bkt(__builtin_floor(__min_bkts) + 1));
+ }
else
return std::make_pair(false, 0);
}
{
_Hashtable* __h = static_cast<_Hashtable*>(this);
typename _Hashtable::_Hash_code_type __code = __h->_M_hash_code(__k);
- std::size_t __n = __h->_M_bucket_index(__k, __code,
- __h->_M_bucket_count);
+ std::size_t __n = __h->_M_bucket_index(__k, __code);
- typename _Hashtable::_Node* __p =
- __h->_M_find_node(__h->_M_buckets[__n], __k, __code);
+ typename _Hashtable::_Node* __p = __h->_M_find_node(__n, __k, __code);
if (!__p)
return __h->_M_insert_bucket(std::make_pair(__k, mapped_type()),
__n, __code)->second;
{
_Hashtable* __h = static_cast<_Hashtable*>(this);
typename _Hashtable::_Hash_code_type __code = __h->_M_hash_code(__k);
- std::size_t __n = __h->_M_bucket_index(__k, __code,
- __h->_M_bucket_count);
+ std::size_t __n = __h->_M_bucket_index(__k, __code);
- typename _Hashtable::_Node* __p =
- __h->_M_find_node(__h->_M_buckets[__n], __k, __code);
+ typename _Hashtable::_Node* __p = __h->_M_find_node(__n, __k, __code);
if (!__p)
return __h->_M_insert_bucket(std::make_pair(std::move(__k),
mapped_type()),
{
_Hashtable* __h = static_cast<_Hashtable*>(this);
typename _Hashtable::_Hash_code_type __code = __h->_M_hash_code(__k);
- std::size_t __n = __h->_M_bucket_index(__k, __code,
- __h->_M_bucket_count);
+ std::size_t __n = __h->_M_bucket_index(__k, __code);
- typename _Hashtable::_Node* __p =
- __h->_M_find_node(__h->_M_buckets[__n], __k, __code);
+ typename _Hashtable::_Node* __p = __h->_M_find_node(__n, __k, __code);
if (!__p)
__throw_out_of_range(__N("_Map_base::at"));
return (__p->_M_v).second;
{
const _Hashtable* __h = static_cast<const _Hashtable*>(this);
typename _Hashtable::_Hash_code_type __code = __h->_M_hash_code(__k);
- std::size_t __n = __h->_M_bucket_index(__k, __code,
- __h->_M_bucket_count);
+ std::size_t __n = __h->_M_bucket_index(__k, __code);
- typename _Hashtable::_Node* __p =
- __h->_M_find_node(__h->_M_buckets[__n], __k, __code);
+ typename _Hashtable::_Node* __p = __h->_M_find_node(__n, __k, __code);
if (!__p)
__throw_out_of_range(__N("_Map_base::at"));
return (__p->_M_v).second;
struct _Rehash_base<_Prime_rehash_policy, _Hashtable>
{
float
- max_load_factor() const
+ max_load_factor() const noexcept
{
const _Hashtable* __this = static_cast<const _Hashtable*>(this);
return __this->__rehash_policy().max_load_factor();
}
};
+ // Helper class using EBO when it is not forbidden, type is not final,
+ // and when it worth it, type is empty.
+ template<int _Nm, typename _Tp,
+ bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
+ struct _Hashtable_ebo_helper;
+
+ // Specialization using EBO.
+ template<int _Nm, typename _Tp>
+ struct _Hashtable_ebo_helper<_Nm, _Tp, true>
+ // See PR53067.
+ : public _Tp
+ {
+ _Hashtable_ebo_helper() = default;
+ _Hashtable_ebo_helper(const _Tp& __tp) : _Tp(__tp)
+ { }
+
+ static const _Tp&
+ _S_cget(const _Hashtable_ebo_helper& __eboh)
+ { return static_cast<const _Tp&>(__eboh); }
+
+ static _Tp&
+ _S_get(_Hashtable_ebo_helper& __eboh)
+ { return static_cast<_Tp&>(__eboh); }
+ };
+
+ // Specialization not using EBO.
+ template<int _Nm, typename _Tp>
+ struct _Hashtable_ebo_helper<_Nm, _Tp, false>
+ {
+ _Hashtable_ebo_helper() = default;
+ _Hashtable_ebo_helper(const _Tp& __tp) : _M_tp(__tp)
+ { }
+
+ static const _Tp&
+ _S_cget(const _Hashtable_ebo_helper& __eboh)
+ { return __eboh._M_tp; }
+
+ static _Tp&
+ _S_get(_Hashtable_ebo_helper& __eboh)
+ { return __eboh._M_tp; }
+
+ private:
+ _Tp _M_tp;
+ };
+
// Class template _Hash_code_base. Encapsulates two policy issues that
// aren't quite orthogonal.
// (1) the difference between using a ranged hash function and using
// 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.
- // We also put the key extraction and equality comparison function
- // objects here, for convenience.
+ // We also put the key extraction objects here, for convenience.
+ //
+ // Each specialization derives from one or more of the template parameters to
+ // benefit from Ebo. This is important as this type is inherited in some cases
+ // by the _Local_iterator_base type used to implement local_iterator and
+ // const_local_iterator. As with any iterator type we prefer to make it as
+ // small as possible.
// Primary template: unused except as a hook for specializations.
- template<typename _Key, typename _Value,
- typename _ExtractKey, typename _Equal,
+ template<typename _Key, typename _Value, typename _ExtractKey,
typename _H1, typename _H2, typename _Hash,
bool __cache_hash_code>
struct _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,
+ template<typename _Key, typename _Value, typename _ExtractKey,
typename _H1, typename _H2, typename _Hash>
- struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
- _Hash, false>
+ struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false>
+ // See PR53067.
+ : public _Hashtable_ebo_helper<0, _ExtractKey>,
+ public _Hashtable_ebo_helper<1, _Hash>
{
+ private:
+ typedef _Hashtable_ebo_helper<0, _ExtractKey> _EboExtractKey;
+ typedef _Hashtable_ebo_helper<1, _Hash> _EboHash;
+
protected:
- _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
+ // We need the default constructor for the local iterators.
+ _Hash_code_base() = default;
+ _Hash_code_base(const _ExtractKey& __ex,
const _H1&, const _H2&, const _Hash& __h)
- : _M_extract(__ex), _M_eq(__eq), _M_ranged_hash(__h) { }
+ : _EboExtractKey(__ex), _EboHash(__h) { }
typedef void* _Hash_code_type;
std::size_t
_M_bucket_index(const _Key& __k, _Hash_code_type,
std::size_t __n) const
- { return _M_ranged_hash(__k, __n); }
+ { return _M_ranged_hash()(__k, __n); }
std::size_t
_M_bucket_index(const _Hash_node<_Value, false>* __p,
std::size_t __n) const
- { return _M_ranged_hash(_M_extract(__p->_M_v), __n); }
-
- bool
- _M_compare(const _Key& __k, _Hash_code_type,
- _Hash_node<_Value, false>* __n) const
- { return _M_eq(__k, _M_extract(__n->_M_v)); }
+ { return _M_ranged_hash()(_M_extract()(__p->_M_v), __n); }
void
_M_store_code(_Hash_node<_Value, false>*, _Hash_code_type) const
void
_M_swap(_Hash_code_base& __x)
{
- std::swap(_M_extract, __x._M_extract);
- std::swap(_M_eq, __x._M_eq);
- std::swap(_M_ranged_hash, __x._M_ranged_hash);
+ std::swap(_M_extract(), __x._M_extract());
+ std::swap(_M_ranged_hash(), __x._M_ranged_hash());
}
protected:
- _ExtractKey _M_extract;
- _Equal _M_eq;
- _Hash _M_ranged_hash;
+ const _ExtractKey&
+ _M_extract() const { return _EboExtractKey::_S_cget(*this); }
+ _ExtractKey&
+ _M_extract() { return _EboExtractKey::_S_get(*this); }
+ const _Hash&
+ _M_ranged_hash() const { return _EboHash::_S_cget(*this); }
+ _Hash&
+ _M_ranged_hash() { return _EboHash::_S_get(*this); }
};
-
// No specialization for ranged hash function while caching hash codes.
// That combination is meaningless, and trying to do it is an error.
-
// 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,
+ template<typename _Key, typename _Value, typename _ExtractKey,
typename _H1, typename _H2, typename _Hash>
- struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
- _Hash, true>;
+ struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true>;
// 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,
+ // caching of hash codes.
+ // Provides typedef and accessor required by TR1.
+ template<typename _Key, typename _Value, typename _ExtractKey,
typename _H1, typename _H2>
- struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
+ struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
_Default_ranged_hash, false>
+ // See PR53067.
+ : public _Hashtable_ebo_helper<0, _ExtractKey>,
+ public _Hashtable_ebo_helper<1, _H1>,
+ public _Hashtable_ebo_helper<2, _H2>
{
+ private:
+ typedef _Hashtable_ebo_helper<0, _ExtractKey> _EboExtractKey;
+ typedef _Hashtable_ebo_helper<1, _H1> _EboH1;
+ typedef _Hashtable_ebo_helper<2, _H2> _EboH2;
+
+ public:
typedef _H1 hasher;
hasher
hash_function() const
- { return _M_h1; }
+ { return _M_h1(); }
protected:
- _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
+ // We need the default constructor for the local iterators.
+ _Hash_code_base() = default;
+ _Hash_code_base(const _ExtractKey& __ex,
const _H1& __h1, const _H2& __h2,
const _Default_ranged_hash&)
- : _M_extract(__ex), _M_eq(__eq), _M_h1(__h1), _M_h2(__h2) { }
+ : _EboExtractKey(__ex), _EboH1(__h1), _EboH2(__h2) { }
typedef std::size_t _Hash_code_type;
_Hash_code_type
_M_hash_code(const _Key& __k) const
- { return _M_h1(__k); }
+ { return _M_h1()(__k); }
std::size_t
_M_bucket_index(const _Key&, _Hash_code_type __c,
std::size_t __n) const
- { return _M_h2(__c, __n); }
+ { return _M_h2()(__c, __n); }
std::size_t
_M_bucket_index(const _Hash_node<_Value, false>* __p,
std::size_t __n) const
- { return _M_h2(_M_h1(_M_extract(__p->_M_v)), __n); }
-
- bool
- _M_compare(const _Key& __k, _Hash_code_type,
- _Hash_node<_Value, false>* __n) const
- { return _M_eq(__k, _M_extract(__n->_M_v)); }
+ { return _M_h2()(_M_h1()(_M_extract()(__p->_M_v)), __n); }
void
_M_store_code(_Hash_node<_Value, false>*, _Hash_code_type) const
void
_M_swap(_Hash_code_base& __x)
{
- std::swap(_M_extract, __x._M_extract);
- std::swap(_M_eq, __x._M_eq);
- std::swap(_M_h1, __x._M_h1);
- std::swap(_M_h2, __x._M_h2);
+ std::swap(_M_extract(), __x._M_extract());
+ std::swap(_M_h1(), __x._M_h1());
+ std::swap(_M_h2(), __x._M_h2());
}
protected:
- _ExtractKey _M_extract;
- _Equal _M_eq;
- _H1 _M_h1;
- _H2 _M_h2;
+ const _ExtractKey&
+ _M_extract() const { return _EboExtractKey::_S_cget(*this); }
+ _ExtractKey&
+ _M_extract() { return _EboExtractKey::_S_get(*this); }
+ const _H1&
+ _M_h1() const { return _EboH1::_S_cget(*this); }
+ _H1&
+ _M_h1() { return _EboH1::_S_get(*this); }
+ const _H2&
+ _M_h2() const { return _EboH2::_S_cget(*this); }
+ _H2&
+ _M_h2() { return _EboH2::_S_get(*this); }
};
// 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,
+ template<typename _Key, typename _Value, typename _ExtractKey,
typename _H1, typename _H2>
- struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2,
+ struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
_Default_ranged_hash, true>
+ // See PR53067.
+ : public _Hashtable_ebo_helper<0, _ExtractKey>,
+ public _Hashtable_ebo_helper<1, _H1>,
+ public _Hashtable_ebo_helper<2, _H2>
{
+ private:
+ typedef _Hashtable_ebo_helper<0, _ExtractKey> _EboExtractKey;
+ typedef _Hashtable_ebo_helper<1, _H1> _EboH1;
+ typedef _Hashtable_ebo_helper<2, _H2> _EboH2;
+
+ public:
typedef _H1 hasher;
hasher
hash_function() const
- { return _M_h1; }
+ { return _M_h1(); }
protected:
- _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq,
+ _Hash_code_base(const _ExtractKey& __ex,
const _H1& __h1, const _H2& __h2,
const _Default_ranged_hash&)
- : _M_extract(__ex), _M_eq(__eq), _M_h1(__h1), _M_h2(__h2) { }
+ : _EboExtractKey(__ex), _EboH1(__h1), _EboH2(__h2) { }
typedef std::size_t _Hash_code_type;
_Hash_code_type
_M_hash_code(const _Key& __k) const
- { return _M_h1(__k); }
+ { return _M_h1()(__k); }
std::size_t
_M_bucket_index(const _Key&, _Hash_code_type __c,
std::size_t __n) const
- { return _M_h2(__c, __n); }
+ { return _M_h2()(__c, __n); }
std::size_t
_M_bucket_index(const _Hash_node<_Value, true>* __p,
std::size_t __n) const
- { return _M_h2(__p->_M_hash_code, __n); }
-
- bool
- _M_compare(const _Key& __k, _Hash_code_type __c,
- _Hash_node<_Value, true>* __n) const
- { return __c == __n->_M_hash_code && _M_eq(__k, _M_extract(__n->_M_v)); }
+ { return _M_h2()(__p->_M_hash_code, __n); }
void
_M_store_code(_Hash_node<_Value, true>* __n, _Hash_code_type __c) const
void
_M_swap(_Hash_code_base& __x)
{
- std::swap(_M_extract, __x._M_extract);
- std::swap(_M_eq, __x._M_eq);
- std::swap(_M_h1, __x._M_h1);
- std::swap(_M_h2, __x._M_h2);
+ std::swap(_M_extract(), __x._M_extract());
+ std::swap(_M_h1(), __x._M_h1());
+ std::swap(_M_h2(), __x._M_h2());
}
protected:
- _ExtractKey _M_extract;
- _Equal _M_eq;
- _H1 _M_h1;
- _H2 _M_h2;
+ const _ExtractKey&
+ _M_extract() const { return _EboExtractKey::_S_cget(*this); }
+ _ExtractKey&
+ _M_extract() { return _EboExtractKey::_S_get(*this); }
+ const _H1&
+ _M_h1() const { return _EboH1::_S_cget(*this); }
+ _H1&
+ _M_h1() { return _EboH1::_S_get(*this); }
+ const _H2&
+ _M_h2() const { return _EboH2::_S_cget(*this); }
+ _H2&
+ _M_h2() { return _EboH2::_S_get(*this); }
+ };
+
+ template <typename _Key, typename _Value, typename _ExtractKey,
+ typename _Equal, typename _HashCodeType,
+ bool __cache_hash_code>
+ struct _Equal_helper;
+
+ template<typename _Key, typename _Value, typename _ExtractKey,
+ typename _Equal, typename _HashCodeType>
+ struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, true>
+ {
+ static bool
+ _S_equals(const _Equal& __eq, const _ExtractKey& __extract,
+ const _Key& __k, _HashCodeType __c,
+ _Hash_node<_Value, true>* __n)
+ { return __c == __n->_M_hash_code
+ && __eq(__k, __extract(__n->_M_v)); }
+ };
+
+ template<typename _Key, typename _Value, typename _ExtractKey,
+ typename _Equal, typename _HashCodeType>
+ struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, false>
+ {
+ static bool
+ _S_equals(const _Equal& __eq, const _ExtractKey& __extract,
+ const _Key& __k, _HashCodeType,
+ _Hash_node<_Value, false>* __n)
+ { return __eq(__k, __extract(__n->_M_v)); }
+ };
+
+ // Helper class adding management of _Equal functor to _Hash_code_base
+ // type.
+ template<typename _Key, typename _Value,
+ typename _ExtractKey, typename _Equal,
+ typename _H1, typename _H2, typename _Hash,
+ bool __cache_hash_code>
+ struct _Hashtable_base
+ // See PR53067.
+ : public _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash,
+ __cache_hash_code>,
+ public _Hashtable_ebo_helper<0, _Equal>
+ {
+ private:
+ typedef _Hashtable_ebo_helper<0, _Equal> _EboEqual;
+
+ protected:
+ typedef _Hash_code_base<_Key, _Value, _ExtractKey,
+ _H1, _H2, _Hash, __cache_hash_code> _HCBase;
+ typedef typename _HCBase::_Hash_code_type _Hash_code_type;
+
+ _Hashtable_base(const _ExtractKey& __ex,
+ const _H1& __h1, const _H2& __h2,
+ const _Hash& __hash, const _Equal& __eq)
+ : _HCBase(__ex, __h1, __h2, __hash), _EboEqual(__eq) { }
+
+ bool
+ _M_equals(const _Key& __k, _Hash_code_type __c,
+ _Hash_node<_Value, __cache_hash_code>* __n) const
+ {
+ typedef _Equal_helper<_Key, _Value, _ExtractKey,
+ _Equal, _Hash_code_type,
+ __cache_hash_code> _EqualHelper;
+ return _EqualHelper::_S_equals(_M_eq(), this->_M_extract(),
+ __k, __c, __n);
+ }
+
+ void
+ _M_swap(_Hashtable_base& __x)
+ {
+ _HCBase::_M_swap(__x);
+ std::swap(_M_eq(), __x._M_eq());
+ }
+
+ protected:
+ const _Equal&
+ _M_eq() const { return _EboEqual::_S_cget(*this); }
+ _Equal&
+ _M_eq() { return _EboEqual::_S_get(*this); }
+ };
+
+ // Local iterators, used to iterate within a bucket but not between
+ // buckets.
+ template<typename _Key, typename _Value, typename _ExtractKey,
+ typename _H1, typename _H2, typename _Hash,
+ bool __cache_hash_code>
+ struct _Local_iterator_base;
+
+ template<typename _Key, typename _Value, typename _ExtractKey,
+ typename _H1, typename _H2, typename _Hash>
+ struct _Local_iterator_base<_Key, _Value, _ExtractKey,
+ _H1, _H2, _Hash, true>
+ // See PR53067.
+ : public _H2
+ {
+ _Local_iterator_base() = default;
+ _Local_iterator_base(_Hash_node<_Value, true>* __p,
+ std::size_t __bkt, std::size_t __bkt_count)
+ : _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { }
+
+ void
+ _M_incr()
+ {
+ _M_cur = _M_cur->_M_next();
+ if (_M_cur)
+ {
+ std::size_t __bkt = _M_h2()(_M_cur->_M_hash_code, _M_bucket_count);
+ if (__bkt != _M_bucket)
+ _M_cur = nullptr;
+ }
+ }
+
+ const _H2& _M_h2() const
+ { return *this; }
+
+ _Hash_node<_Value, true>* _M_cur;
+ std::size_t _M_bucket;
+ std::size_t _M_bucket_count;
+ };
+
+ template<typename _Key, typename _Value, typename _ExtractKey,
+ typename _H1, typename _H2, typename _Hash>
+ struct _Local_iterator_base<_Key, _Value, _ExtractKey,
+ _H1, _H2, _Hash, false>
+ // See PR53067.
+ : public _Hash_code_base<_Key, _Value, _ExtractKey,
+ _H1, _H2, _Hash, false>
+ {
+ _Local_iterator_base() = default;
+ _Local_iterator_base(_Hash_node<_Value, false>* __p,
+ std::size_t __bkt, std::size_t __bkt_count)
+ : _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { }
+
+ void
+ _M_incr()
+ {
+ _M_cur = _M_cur->_M_next();
+ if (_M_cur)
+ {
+ std::size_t __bkt = this->_M_bucket_index(_M_cur, _M_bucket_count);
+ if (__bkt != _M_bucket)
+ _M_cur = nullptr;
+ }
+ }
+
+ _Hash_node<_Value, false>* _M_cur;
+ std::size_t _M_bucket;
+ std::size_t _M_bucket_count;
+ };
+
+ template<typename _Key, typename _Value, typename _ExtractKey,
+ typename _H1, typename _H2, typename _Hash, bool __cache>
+ inline bool
+ operator==(const _Local_iterator_base<_Key, _Value, _ExtractKey,
+ _H1, _H2, _Hash, __cache>& __x,
+ const _Local_iterator_base<_Key, _Value, _ExtractKey,
+ _H1, _H2, _Hash, __cache>& __y)
+ { return __x._M_cur == __y._M_cur; }
+
+ template<typename _Key, typename _Value, typename _ExtractKey,
+ typename _H1, typename _H2, typename _Hash, bool __cache>
+ inline bool
+ operator!=(const _Local_iterator_base<_Key, _Value, _ExtractKey,
+ _H1, _H2, _Hash, __cache>& __x,
+ const _Local_iterator_base<_Key, _Value, _ExtractKey,
+ _H1, _H2, _Hash, __cache>& __y)
+ { return __x._M_cur != __y._M_cur; }
+
+ template<typename _Key, typename _Value, typename _ExtractKey,
+ typename _H1, typename _H2, typename _Hash,
+ bool __constant_iterators, bool __cache>
+ struct _Local_iterator
+ : public _Local_iterator_base<_Key, _Value, _ExtractKey,
+ _H1, _H2, _Hash, __cache>
+ {
+ typedef _Value value_type;
+ typedef typename std::conditional<__constant_iterators,
+ const _Value*, _Value*>::type
+ pointer;
+ typedef typename std::conditional<__constant_iterators,
+ const _Value&, _Value&>::type
+ reference;
+ typedef std::ptrdiff_t difference_type;
+ typedef std::forward_iterator_tag iterator_category;
+
+ _Local_iterator() = default;
+
+ explicit
+ _Local_iterator(_Hash_node<_Value, __cache>* __p,
+ std::size_t __bkt, std::size_t __bkt_count)
+ : _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash,
+ __cache>(__p, __bkt, __bkt_count)
+ { }
+
+ reference
+ operator*() const
+ { return this->_M_cur->_M_v; }
+
+ pointer
+ operator->() const
+ { return std::__addressof(this->_M_cur->_M_v); }
+
+ _Local_iterator&
+ operator++()
+ {
+ this->_M_incr();
+ return *this;
+ }
+
+ _Local_iterator
+ operator++(int)
+ {
+ _Local_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+ }
+ };
+
+ template<typename _Key, typename _Value, typename _ExtractKey,
+ typename _H1, typename _H2, typename _Hash,
+ bool __constant_iterators, bool __cache>
+ struct _Local_const_iterator
+ : public _Local_iterator_base<_Key, _Value, _ExtractKey,
+ _H1, _H2, _Hash, __cache>
+ {
+ typedef _Value value_type;
+ typedef const _Value* pointer;
+ typedef const _Value& reference;
+ typedef std::ptrdiff_t difference_type;
+ typedef std::forward_iterator_tag iterator_category;
+
+ _Local_const_iterator() = default;
+
+ explicit
+ _Local_const_iterator(_Hash_node<_Value, __cache>* __p,
+ std::size_t __bkt, std::size_t __bkt_count)
+ : _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash,
+ __cache>(__p, __bkt, __bkt_count)
+ { }
+
+ _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey,
+ _H1, _H2, _Hash,
+ __constant_iterators,
+ __cache>& __x)
+ : _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash,
+ __cache>(__x._M_cur, __x._M_bucket,
+ __x._M_bucket_count)
+ { }
+
+ reference
+ operator*() const
+ { return this->_M_cur->_M_v; }
+
+ pointer
+ operator->() const
+ { return std::__addressof(this->_M_cur->_M_v); }
+
+ _Local_const_iterator&
+ operator++()
+ {
+ this->_M_incr();
+ return *this;
+ }
+
+ _Local_const_iterator
+ operator++(int)
+ {
+ _Local_const_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+ }
};
for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx)
{
const auto __ity = __other.find(_ExtractKey()(*__itx));
- if (__ity == __other.end() || *__ity != *__itx)
+ if (__ity == __other.end() || !bool(*__ity == *__itx))
return false;
}
return true;
for (_Uiterator __it1 = __first1; __it1 != __last1; ++__it1)
{
_Uiterator __tmp = __first1;
- while (__tmp != __it1 && !(*__tmp == *__it1))
+ while (__tmp != __it1 && !bool(*__tmp == *__it1))
++__tmp;
// We've seen this one before.
}
return true;
}
-} // namespace __detail
-_GLIBCXX_END_NAMESPACE // namespace std
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+} // namespace std
#endif // _HASHTABLE_POLICY_H
OSDN Git Service
