<h2>File Contents: //usr/include/c++/8/profile/unordered_base.h</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='//usr/include/c++/8/profile/unordered_base.h'><textarea name='file_content' rows='10' cols='50'>// Profiling unordered containers implementation details -*- C++ -*-

// Copyright (C) 2013-2018 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
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3.  If not see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file profile/unordered_base.h
 *  This file is a GNU profile extension to the Standard C++ Library.
 */

#ifndef _GLIBCXX_PROFILE_UNORDERED
#define _GLIBCXX_PROFILE_UNORDERED 1

namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
  template&lt;typename _UnorderedCont,
	   typename _Value, bool _Cache_hash_code&gt;
    struct _Bucket_index_helper;

  template&lt;typename _UnorderedCont, typename _Value&gt;
    struct _Bucket_index_helper&lt;_UnorderedCont, _Value, true&gt;
    {
      static std::size_t
      bucket(const _UnorderedCont&amp; __uc,
	     const __detail::_Hash_node&lt;_Value, true&gt;* __node)
      { return __node-&gt;_M_hash_code % __uc.bucket_count(); }
    };

  template&lt;typename _UnorderedCont, typename _Value&gt;
    struct _Bucket_index_helper&lt;_UnorderedCont, _Value, false&gt;
    {
      static std::size_t
      bucket(const _UnorderedCont&amp; __uc,
	     const __detail::_Hash_node&lt;_Value, false&gt;* __node)
      { return __uc.bucket(__node-&gt;_M_v()); }
    };

  template&lt;typename _UnorderedCont, typename _Key, typename _Mapped&gt;
    struct _Bucket_index_helper&lt;_UnorderedCont,
				std::pair&lt;const _Key, _Mapped&gt;, false&gt;
    {
      typedef std::pair&lt;const _Key, _Mapped&gt; _Value;

      static std::size_t
      bucket(const _UnorderedCont&amp; __uc,
	     const __detail::_Hash_node&lt;_Value, false&gt;* __node)
      { return __uc.bucket(__node-&gt;_M_v().first); }
    };

  template&lt;typename _UnorderedCont, typename _Value, bool _Cache_hash_code&gt;
    std::size_t
    __get_bucket_index(const _UnorderedCont&amp; __uc,
		       const __detail::_Hash_node&lt;_Value, _Cache_hash_code&gt;* __node)
    {
      using __bucket_index_helper
	= _Bucket_index_helper&lt;_UnorderedCont, _Value, _Cache_hash_code&gt;;
      return __bucket_index_helper::bucket(__uc, __node);
    }

  template&lt;typename _UnorderedCont,
	   typename _Value, bool _Cache_hash_code&gt;
    struct _Equal_helper;

  template&lt;typename _UnorderedCont, typename _Value&gt;
    struct _Equal_helper&lt;_UnorderedCont, _Value, true&gt;
    {
      static std::size_t
      are_equal(const _UnorderedCont&amp; __uc,
		const __detail::_Hash_node&lt;_Value, true&gt;* __lhs,
		const __detail::_Hash_node&lt;_Value, true&gt;* __rhs)
      {
	return __lhs-&gt;_M_hash_code == __rhs-&gt;_M_hash_code
	  &amp;&amp; __uc.key_eq()(__lhs-&gt;_M_v(), __rhs-&gt;_M_v());
      }
    };

  template&lt;typename _UnorderedCont,
	   typename _Value&gt;
    struct _Equal_helper&lt;_UnorderedCont, _Value, false&gt;
    {
      static std::size_t
      are_equal(const _UnorderedCont&amp; __uc,
		const __detail::_Hash_node&lt;_Value, false&gt;* __lhs,
		const __detail::_Hash_node&lt;_Value, false&gt;* __rhs)
      { return __uc.key_eq()(__lhs-&gt;_M_v(), __rhs-&gt;_M_v()); }
    };

  template&lt;typename _UnorderedCont,
	   typename _Key, typename _Mapped&gt;
    struct _Equal_helper&lt;_UnorderedCont, std::pair&lt;const _Key, _Mapped&gt;, true&gt;
    {
      typedef std::pair&lt;const _Key, _Mapped&gt; _Value;

      static std::size_t
      are_equal(const _UnorderedCont&amp; __uc,
		const __detail::_Hash_node&lt;_Value, true&gt;* __lhs,
		const __detail::_Hash_node&lt;_Value, true&gt;* __rhs)
      {
	return __lhs-&gt;_M_hash_code == __rhs-&gt;_M_hash_code
	  &amp;&amp; __uc.key_eq()(__lhs-&gt;_M_v().first, __rhs-&gt;_M_v().first);
      }
    };

  template&lt;typename _UnorderedCont,
	   typename _Key, typename _Mapped&gt;
    struct _Equal_helper&lt;_UnorderedCont, std::pair&lt;const _Key, _Mapped&gt;, false&gt;
    {
      typedef std::pair&lt;const _Key, _Mapped&gt; _Value;

      static std::size_t
      are_equal(const _UnorderedCont&amp; __uc,
		const __detail::_Hash_node&lt;_Value, false&gt;* __lhs,
		const __detail::_Hash_node&lt;_Value, false&gt;* __rhs)
      { return __uc.key_eq()(__lhs-&gt;_M_v().first, __rhs-&gt;_M_v().first); }
    };

  template&lt;typename _UnorderedCont, typename _Value, bool _Cache_hash_code&gt;
    bool
    __are_equal(const _UnorderedCont&amp; __uc,
		const __detail::_Hash_node&lt;_Value, _Cache_hash_code&gt;* __lhs,
		const __detail::_Hash_node&lt;_Value, _Cache_hash_code&gt;* __rhs)
  {
    using __equal_helper
      = _Equal_helper&lt;_UnorderedCont, _Value, _Cache_hash_code&gt;;
    return __equal_helper::are_equal(__uc, __lhs, __rhs);
  }

  template&lt;typename _UnorderedCont, bool _Unique_keys&gt;
    class _Unordered_profile
    {
      _UnorderedCont&amp;
      _M_conjure()
      { return *(static_cast&lt;_UnorderedCont*&gt;(this)); }

      using __unique_keys = std::integral_constant&lt;bool, _Unique_keys&gt;;

    protected:
      _Unordered_profile() noexcept
      { _M_profile_construct(); }

      _Unordered_profile(const _Unordered_profile&amp;) noexcept
	: _Unordered_profile() { }

      _Unordered_profile(_Unordered_profile&amp;&amp; __other) noexcept
	: _Unordered_profile()
      { _M_swap(__other); }

      ~_Unordered_profile()
      { _M_profile_destruct(); }

      _Unordered_profile&amp;
      operator=(const _Unordered_profile&amp;) noexcept
      {
	// Assignment just reset profiling.
	_M_profile_destruct();
	_M_profile_construct();
      }

      _Unordered_profile&amp;
      operator=(_Unordered_profile&amp;&amp; __other) noexcept
      {
	// Take profiling of the moved instance...
	_M_swap(__other);

	// ...and then reset other instance profiling.
	__other._M_profile_destruct();
	__other._M_profile_construct();
      }

      void
      _M_profile_construct() noexcept
      {
	auto&amp; __uc = _M_conjure();
	_M_size_info = __profcxx_hashtable_size_construct(__uc.bucket_count());
	_M_hashfunc_info = __profcxx_hash_func_construct();
      }

      void
      _M_profile_destruct() noexcept
      {
	auto&amp; __uc = _M_conjure();
	__profcxx_hashtable_size_destruct(_M_size_info,
					  __uc.bucket_count(), __uc.size());
	_M_size_info = 0;

	if (!_M_hashfunc_info)
	  return;

	_M_profile_destruct(__unique_keys());
	_M_hashfunc_info = 0;
      }

      void
      _M_swap(_Unordered_profile&amp; __other) noexcept
      {
	std::swap(_M_size_info, __other._M_size_info);
	std::swap(_M_hashfunc_info, __other._M_hashfunc_info);
      }

      void
      _M_profile_resize(std::size_t __old_size)
      {
	auto __new_size = _M_conjure().bucket_count();
	if (__old_size != __new_size)
	  __profcxx_hashtable_size_resize(_M_size_info, __old_size, __new_size);
      }

      __gnu_profile::__container_size_info* _M_size_info;
      __gnu_profile::__hashfunc_info* _M_hashfunc_info;

    private:
      void
      _M_profile_destruct(std::true_type);

      void
      _M_profile_destruct(std::false_type);
    };

  template&lt;typename _UnorderedCont, bool _Unique_keys&gt;
    void
    _Unordered_profile&lt;_UnorderedCont, _Unique_keys&gt;::
    _M_profile_destruct(std::true_type)
    {
      auto&amp; __uc = _M_conjure();
      std::size_t __hops = 0, __lc = 0, __chain = 0;
      auto __it = __uc.begin();
      while (__it != __uc.end())
	{
	  auto __bkt = __get_bucket_index(__uc, __it._M_cur);
	  auto __lit = __uc.begin(__bkt);
	  auto __lend = __uc.end(__bkt);
	  for (++__it, ++__lit; __lit != __lend; ++__it, ++__lit)
	    ++__chain;

	  if (__chain)
	    {
	      ++__chain;
	      __lc = __lc &gt; __chain ? __lc : __chain;
	      __hops += __chain * (__chain - 1) / 2;
	      __chain = 0;
	    }
	}

      __profcxx_hash_func_destruct(_M_hashfunc_info,
				   __lc, __uc.size(), __hops);
    }

  template&lt;typename _UnorderedCont, bool _Unique_keys&gt;
    void
    _Unordered_profile&lt;_UnorderedCont, _Unique_keys&gt;::
    _M_profile_destruct(std::false_type)
    {
      auto&amp; __uc = _M_conjure();
      std::size_t __hops = 0, __lc = 0, __chain = 0, __unique_size = 0;
      auto __it = __uc.begin();
      while (__it != __uc.end())
	{
	  auto __bkt = __get_bucket_index(__uc, __it._M_cur);
	  auto __lit = __uc.begin(__bkt);
	  auto __lend = __uc.end(__bkt);
	  auto __pit = __it;
	  ++__unique_size;
	  for (++__it, ++__lit; __lit != __lend; ++__it, ++__lit)
	    {
	      if (!__are_equal(__uc, __pit._M_cur, __it._M_cur))
		{
		  ++__chain;
		  ++__unique_size;
		  __pit = __it;
		}
	    }

	  if (__chain)
	    {
	      ++__chain;
	      __lc = __lc &gt; __chain ? __lc : __chain;
	      __hops += __chain * (__chain - 1) / 2;
	      __chain = 0;
	    }
	}

      __profcxx_hash_func_destruct(_M_hashfunc_info,
				   __lc, __unique_size, __hops);
    }

} // namespace __profile
} // namespace std

#endif
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2F%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fprofile'>⬅ Back to Directory</a>