mipsel-buildroot-linux-uclibc/include/c++/4.9.1/profile/unordered_map - toolchains/bruno - Git at Google

 // Profiling unordered_map/unordered_multimap implementation -*- C++ -*-

 // Copyright (C) 2009-2014 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
 // <http://www.gnu.org/licenses/>.

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

 #ifndef _GLIBCXX_PROFILE_UNORDERED_MAP
 #define _GLIBCXX_PROFILE_UNORDERED_MAP 1

 #if __cplusplus < 201103L
 # include <bits/c++0x_warning.h>
 #else
 # include <unordered_map>

 #include <profile/base.h>
 #include <profile/unordered_base.h>

 #define _GLIBCXX_BASE unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
 #define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE

 namespace std _GLIBCXX_VISIBILITY(default)
 {
 namespace __profile
 {
   /// Class std::unordered_map wrapper with performance instrumentation.
   template<typename _Key, typename _Tp,
 	   typename _Hash = std::hash<_Key>,
 	   typename _Pred = std::equal_to<_Key>,
 	   typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
     class unordered_map
     : public _GLIBCXX_STD_BASE,
       public _Unordered_profile<unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>,
 				true>
     {
       typedef typename _GLIBCXX_STD_BASE _Base;

       _Base&
       _M_base() noexcept       { return *this; }

       const _Base&
       _M_base() const noexcept { return *this; }

     public:
       typedef typename _Base::size_type       size_type;
       typedef typename _Base::hasher          hasher;
       typedef typename _Base::key_equal       key_equal;
       typedef typename _Base::allocator_type  allocator_type;
       typedef typename _Base::key_type        key_type;
       typedef typename _Base::value_type      value_type;
       typedef typename _Base::difference_type difference_type;
       typedef typename _Base::reference       reference;
       typedef typename _Base::const_reference const_reference;
       typedef typename _Base::mapped_type      mapped_type;

       typedef typename _Base::iterator iterator;
       typedef typename _Base::const_iterator const_iterator;

       explicit
       unordered_map(size_type __n = 10,
 		    const hasher& __hf = hasher(),
 		    const key_equal& __eql = key_equal(),
 		    const allocator_type& __a = allocator_type())
 	: _Base(__n, __hf, __eql, __a)
       { }

       template<typename _InputIterator>
         unordered_map(_InputIterator __f, _InputIterator __l,
 		      size_type __n = 0,
 		      const hasher& __hf = hasher(),
 		      const key_equal& __eql = key_equal(),
 		      const allocator_type& __a = allocator_type())
 	  : _Base(__f, __l, __n, __hf, __eql, __a)
         { }

       unordered_map(const unordered_map&) = default;

       unordered_map(const _Base& __x)
 	: _Base(__x)
       { }

       unordered_map(unordered_map&&) = default;

       explicit
       unordered_map(const allocator_type& __a)
 	: _Base(__a)
       { }

       unordered_map(const unordered_map& __umap,
 		    const allocator_type& __a)
 	: _Base(__umap, __a)
       { }

       unordered_map(unordered_map&& __umap,
 		    const allocator_type& __a)
 	: _Base(std::move(__umap._M_base()), __a)
       { }

       unordered_map(initializer_list<value_type> __l,
 		    size_type __n = 0,
 		    const hasher& __hf = hasher(),
 		    const key_equal& __eql = key_equal(),
 		    const allocator_type& __a = allocator_type())
 	: _Base(__l, __n, __hf, __eql, __a)
       { }

       unordered_map&
       operator=(const unordered_map&) = default;

       unordered_map&
       operator=(unordered_map&&) = default;

       unordered_map&
       operator=(initializer_list<value_type> __l)
       {
 	_M_base() = __l;
 	return *this;
       }

       void
       clear() noexcept
       {
         __profcxx_hashtable_destruct(this, _Base::bucket_count(),
 				     _Base::size());
         this->_M_profile_destruct();
 	_Base::clear();
       }

       template<typename... _Args>
 	std::pair<iterator, bool>
 	emplace(_Args&&... __args)
 	{
 	  size_type __old_size = _Base::bucket_count();
 	  std::pair<iterator, bool> __res
 	    = _Base::emplace(std::forward<_Args>(__args)...);
 	  _M_profile_resize(__old_size);
 	  return __res;
 	}

       template<typename... _Args>
 	iterator
 	emplace_hint(const_iterator __it, _Args&&... __args)
 	{
 	  size_type __old_size = _Base::bucket_count();
 	  iterator __res
 	    = _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
 	  _M_profile_resize(__old_size);
 	  return __res;
 	}

       void
       insert(std::initializer_list<value_type> __l)
       {
         size_type __old_size = _Base::bucket_count();
         _Base::insert(__l);
         _M_profile_resize(__old_size);
       }

       std::pair<iterator, bool>
       insert(const value_type& __obj)
       {
         size_type __old_size = _Base::bucket_count();
         std::pair<iterator, bool> __res = _Base::insert(__obj);
         _M_profile_resize(__old_size);
         return __res;
       }

       iterator
       insert(const_iterator __iter, const value_type& __v)
       {
         size_type __old_size = _Base::bucket_count();
         iterator __res = _Base::insert(__iter, __v);
         _M_profile_resize(__old_size);
         return __res;
       }

       template<typename _Pair, typename = typename
 	       std::enable_if<std::is_constructible<value_type,
 						    _Pair&&>::value>::type>
         std::pair<iterator, bool>
         insert(_Pair&& __obj)
         {
 	  size_type __old_size = _Base::bucket_count();
 	  std::pair<iterator, bool> __res
 	    = _Base::insert(std::forward<_Pair>(__obj));
 	  _M_profile_resize(__old_size);
 	  return __res;
 	}

       template<typename _Pair, typename = typename
 	       std::enable_if<std::is_constructible<value_type,
 						    _Pair&&>::value>::type>
         iterator
         insert(const_iterator __iter, _Pair&& __v)
         {
 	  size_type __old_size = _Base::bucket_count();
 	  iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v));
 	  _M_profile_resize(__old_size);
 	  return __res;
 	}

       template<typename _InputIter>
         void
         insert(_InputIter __first, _InputIter __last)
         {
 	  size_type __old_size = _Base::bucket_count();
 	  _Base::insert(__first, __last);
 	  _M_profile_resize(__old_size);
 	}

       // operator[]
       mapped_type&
       operator[](const _Key& __k)
       {
         size_type __old_size = _Base::bucket_count();
         mapped_type& __res = _M_base()[__k];
         _M_profile_resize(__old_size);
         return __res;
       }

       mapped_type&
       operator[](_Key&& __k)
       {
         size_type __old_size = _Base::bucket_count();
         mapped_type& __res = _M_base()[std::move(__k)];
         _M_profile_resize(__old_size);
         return __res;
       }

       void
       swap(unordered_map& __x)
       noexcept( noexcept(__x._M_base().swap(__x)) )
       { _Base::swap(__x._M_base()); }

       void rehash(size_type __n)
       {
 	size_type __old_size = _Base::bucket_count();
 	_Base::rehash(__n);
 	_M_profile_resize(__old_size);
       }

     private:
       void
       _M_profile_resize(size_type __old_size)
       {
 	size_type __new_size = _Base::bucket_count();
 	if (__old_size != __new_size)
 	  __profcxx_hashtable_resize(this, __old_size, __new_size);
       }
   };

   template<typename _Key, typename _Tp, typename _Hash,
 	   typename _Pred, typename _Alloc>
     inline void
     swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 	 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
     { __x.swap(__y); }

   template<typename _Key, typename _Tp, typename _Hash,
 	   typename _Pred, typename _Alloc>
     inline bool
     operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 	       const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
     { return static_cast<const _GLIBCXX_STD_BASE&>(__x) == __y; }

   template<typename _Key, typename _Tp, typename _Hash,
 	   typename _Pred, typename _Alloc>
     inline bool
     operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 	       const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
     { return !(__x == __y); }

 #undef _GLIBCXX_BASE
 #undef _GLIBCXX_STD_BASE
 #define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
 #define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE

   /// Class std::unordered_multimap wrapper with performance instrumentation.
   template<typename _Key, typename _Tp,
 	   typename _Hash = std::hash<_Key>,
 	   typename _Pred = std::equal_to<_Key>,
 	   typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
     class unordered_multimap
     : public _GLIBCXX_STD_BASE,
       public _Unordered_profile<unordered_multimap<_Key, _Tp,
 						   _Hash, _Pred, _Alloc>,
 				false>
     {
       typedef typename _GLIBCXX_STD_BASE _Base;

       _Base&
       _M_base() noexcept       { return *this; }

       const _Base&
       _M_base() const noexcept { return *this; }

     public:
       typedef typename _Base::size_type       size_type;
       typedef typename _Base::hasher          hasher;
       typedef typename _Base::key_equal       key_equal;
       typedef typename _Base::allocator_type  allocator_type;
       typedef typename _Base::key_type        key_type;
       typedef typename _Base::value_type      value_type;
       typedef typename _Base::difference_type difference_type;
       typedef typename _Base::reference       reference;
       typedef typename _Base::const_reference const_reference;

       typedef typename _Base::iterator iterator;
       typedef typename _Base::const_iterator const_iterator;

       explicit
       unordered_multimap(size_type __n = 10,
 			 const hasher& __hf = hasher(),
 			 const key_equal& __eql = key_equal(),
 			 const allocator_type& __a = allocator_type())
 	: _Base(__n, __hf, __eql, __a)
       { }

       template<typename _InputIterator>
         unordered_multimap(_InputIterator __f, _InputIterator __l,
 			   size_type __n = 0,
 			   const hasher& __hf = hasher(),
 			   const key_equal& __eql = key_equal(),
 			   const allocator_type& __a = allocator_type())
 	  : _Base(__f, __l, __n, __hf, __eql, __a)
       { }

       unordered_multimap(const unordered_multimap&) = default;

       unordered_multimap(const _Base& __x)
 	: _Base(__x)
       { }

       unordered_multimap(unordered_multimap&&) = default;

       explicit
       unordered_multimap(const allocator_type& __a)
 	: _Base(__a)
       { }

       unordered_multimap(const unordered_multimap& __ummap,
 			 const allocator_type& __a)
 	: _Base(__ummap._M_base(), __a)
       { }

       unordered_multimap(unordered_multimap&& __ummap,
 			 const allocator_type& __a)
 	: _Base(std::move(__ummap._M_base()), __a)
       { }

       unordered_multimap(initializer_list<value_type> __l,
 			 size_type __n = 0,
 			 const hasher& __hf = hasher(),
 			 const key_equal& __eql = key_equal(),
 			 const allocator_type& __a = allocator_type())
       : _Base(__l, __n, __hf, __eql, __a)
       { }

       unordered_multimap&
       operator=(const unordered_multimap&) = default;

       unordered_multimap&
       operator=(unordered_multimap&&) = default;

       unordered_multimap&
       operator=(initializer_list<value_type> __l)
       {
 	_M_base() = __l;
 	return *this;
       }

       void
       clear() noexcept
       {
 	__profcxx_hashtable_destruct(this, _Base::bucket_count(),
 				     _Base::size());
 	this->_M_profile_destruct();
 	_Base::clear();
       }

       template<typename... _Args>
 	iterator
 	emplace(_Args&&... __args)
 	{
 	  size_type __old_size = _Base::bucket_count();
 	  iterator __res
 	    = _Base::emplace(std::forward<_Args>(__args)...);
 	  _M_profile_resize(__old_size);
 	  return __res;
 	}

       template<typename... _Args>
 	iterator
 	emplace_hint(const_iterator __it, _Args&&... __args)
 	{
 	  size_type __old_size = _Base::bucket_count();
 	  iterator __res
 	    = _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
 	  _M_profile_resize(__old_size);
 	  return __res;
 	}

       void
       insert(std::initializer_list<value_type> __l)
       {
         size_type __old_size = _Base::bucket_count();
         _Base::insert(__l);
         _M_profile_resize(__old_size);
       }

       iterator
       insert(const value_type& __obj)
       {
         size_type __old_size = _Base::bucket_count();
         iterator __res = _Base::insert(__obj);
         _M_profile_resize(__old_size);
         return __res;
       }

       iterator
       insert(const_iterator __iter, const value_type& __v)
       {
         size_type __old_size = _Base::bucket_count();
         iterator __res = _Base::insert(__iter, __v);
         _M_profile_resize(__old_size);
         return __res;
       }

       template<typename _Pair, typename = typename
 	       std::enable_if<std::is_constructible<value_type,
 						    _Pair&&>::value>::type>
         iterator
         insert(_Pair&& __obj)
         {
 	  size_type __old_size = _Base::bucket_count();
 	  iterator __res = _Base::insert(std::forward<_Pair>(__obj));
 	  _M_profile_resize(__old_size);
 	  return __res;
 	}

       template<typename _Pair, typename = typename
 	       std::enable_if<std::is_constructible<value_type,
 						    _Pair&&>::value>::type>
         iterator
         insert(const_iterator __iter, _Pair&& __v)
         {
 	  size_type __old_size = _Base::bucket_count();
 	  iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v));
 	  _M_profile_resize(__old_size);
 	  return __res;
 	}

       template<typename _InputIter>
         void
         insert(_InputIter __first, _InputIter __last)
         {
 	  size_type __old_size = _Base::bucket_count();
 	  _Base::insert(__first, __last);
 	  _M_profile_resize(__old_size);
 	}

       void
       swap(unordered_multimap& __x)
       noexcept( noexcept(__x._M_base().swap(__x)) )
       { _Base::swap(__x._M_base()); }

       void
       rehash(size_type __n)
       {
         size_type __old_size = _Base::bucket_count();
         _Base::rehash(__n);
         _M_profile_resize(__old_size);
       }

     private:
       void
       _M_profile_resize(size_type __old_size)
       {
 	size_type __new_size = _Base::bucket_count();
         if (__old_size != __new_size)
           __profcxx_hashtable_resize(this, __old_size, __new_size);
       }
   };

   template<typename _Key, typename _Tp, typename _Hash,
 	   typename _Pred, typename _Alloc>
     inline void
     swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 	 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
     { __x.swap(__y); }

   template<typename _Key, typename _Tp, typename _Hash,
 	   typename _Pred, typename _Alloc>
     inline bool
     operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 	       const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
     { return static_cast<const _GLIBCXX_STD_BASE&>(__x) == __y; }

   template<typename _Key, typename _Tp, typename _Hash,
 	   typename _Pred, typename _Alloc>
     inline bool
     operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 	       const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
     { return !(__x == __y); }

 } // namespace __profile
 } // namespace std

 #undef _GLIBCXX_BASE
 #undef _GLIBCXX_STD_BASE

 #endif // C++11

 #endif
	// Profiling unordered_map/unordered_multimap implementation -- C++ --

	// Copyright (C) 2009-2014 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
	// <http://www.gnu.org/licenses/>.

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

	#ifndef _GLIBCXX_PROFILE_UNORDERED_MAP
	#define _GLIBCXX_PROFILE_UNORDERED_MAP 1

	#if __cplusplus < 201103L
	# include <bits/c++0x_warning.h>
	#else
	# include <unordered_map>

	#include <profile/base.h>
	#include <profile/unordered_base.h>

	#define _GLIBCXX_BASE unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
	#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE

	namespace std _GLIBCXX_VISIBILITY(default)
	{
	namespace __profile
	{
	/// Class std::unordered_map wrapper with performance instrumentation.
	template<typename _Key, typename _Tp,
	typename _Hash = std::hash<_Key>,
	typename _Pred = std::equal_to<_Key>,
	typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
	class unordered_map
	: public _GLIBCXX_STD_BASE,
	public _Unordered_profile<unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>,
	true>
	{
	typedef typename _GLIBCXX_STD_BASE _Base;

	_Base&
	_M_base() noexcept { return *this; }

	const _Base&
	_M_base() const noexcept { return *this; }

	public:
	typedef typename _Base::size_type size_type;
	typedef typename _Base::hasher hasher;
	typedef typename _Base::key_equal key_equal;
	typedef typename _Base::allocator_type allocator_type;
	typedef typename _Base::key_type key_type;
	typedef typename _Base::value_type value_type;
	typedef typename _Base::difference_type difference_type;
	typedef typename _Base::reference reference;
	typedef typename _Base::const_reference const_reference;
	typedef typename _Base::mapped_type mapped_type;

	typedef typename _Base::iterator iterator;
	typedef typename _Base::const_iterator const_iterator;

	explicit
	unordered_map(size_type __n = 10,
	const hasher& __hf = hasher(),
	const key_equal& __eql = key_equal(),
	const allocator_type& __a = allocator_type())
	: _Base(__n, __hf, __eql, __a)
	{ }

	template<typename _InputIterator>
	unordered_map(_InputIterator __f, _InputIterator __l,
	size_type __n = 0,
	const hasher& __hf = hasher(),
	const key_equal& __eql = key_equal(),
	const allocator_type& __a = allocator_type())
	: _Base(__f, __l, __n, __hf, __eql, __a)
	{ }

	unordered_map(const unordered_map&) = default;

	unordered_map(const _Base& __x)
	: _Base(__x)
	{ }

	unordered_map(unordered_map&&) = default;

	explicit
	unordered_map(const allocator_type& __a)
	: _Base(__a)
	{ }

	unordered_map(const unordered_map& __umap,
	const allocator_type& __a)
	: _Base(__umap, __a)
	{ }

	unordered_map(unordered_map&& __umap,
	const allocator_type& __a)
	: _Base(std::move(__umap._M_base()), __a)
	{ }

	unordered_map(initializer_list<value_type> __l,
	size_type __n = 0,
	const hasher& __hf = hasher(),
	const key_equal& __eql = key_equal(),
	const allocator_type& __a = allocator_type())
	: _Base(__l, __n, __hf, __eql, __a)
	{ }

	unordered_map&
	operator=(const unordered_map&) = default;

	unordered_map&
	operator=(unordered_map&&) = default;

	unordered_map&
	operator=(initializer_list<value_type> __l)
	{
	_M_base() = __l;
	return *this;
	}

	void
	clear() noexcept
	{
	__profcxx_hashtable_destruct(this, _Base::bucket_count(),
	_Base::size());
	this->_M_profile_destruct();
	_Base::clear();
	}

	template<typename... _Args>
	std::pair<iterator, bool>
	emplace(_Args&&... __args)
	{
	size_type __old_size = _Base::bucket_count();
	std::pair<iterator, bool> __res
	= _Base::emplace(std::forward<_Args>(__args)...);
	_M_profile_resize(__old_size);
	return __res;
	}

	template<typename... _Args>
	iterator
	emplace_hint(const_iterator __it, _Args&&... __args)
	{
	size_type __old_size = _Base::bucket_count();
	iterator __res
	= _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
	_M_profile_resize(__old_size);
	return __res;
	}

	void
	insert(std::initializer_list<value_type> __l)
	{
	size_type __old_size = _Base::bucket_count();
	_Base::insert(__l);
	_M_profile_resize(__old_size);
	}

	std::pair<iterator, bool>
	insert(const value_type& __obj)
	{
	size_type __old_size = _Base::bucket_count();
	std::pair<iterator, bool> __res = _Base::insert(__obj);
	_M_profile_resize(__old_size);
	return __res;
	}

	iterator
	insert(const_iterator __iter, const value_type& __v)
	{
	size_type __old_size = _Base::bucket_count();
	iterator __res = _Base::insert(__iter, __v);
	_M_profile_resize(__old_size);
	return __res;
	}

	template<typename _Pair, typename = typename
	std::enable_if<std::is_constructible<value_type,
	_Pair&&>::value>::type>
	std::pair<iterator, bool>
	insert(_Pair&& __obj)
	{
	size_type __old_size = _Base::bucket_count();
	std::pair<iterator, bool> __res
	= _Base::insert(std::forward<_Pair>(__obj));
	_M_profile_resize(__old_size);
	return __res;
	}

	template<typename _Pair, typename = typename
	std::enable_if<std::is_constructible<value_type,
	_Pair&&>::value>::type>
	iterator
	insert(const_iterator __iter, _Pair&& __v)
	{
	size_type __old_size = _Base::bucket_count();
	iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v));
	_M_profile_resize(__old_size);
	return __res;
	}

	template<typename _InputIter>
	void
	insert(_InputIter __first, _InputIter __last)
	{
	size_type __old_size = _Base::bucket_count();
	_Base::insert(__first, __last);
	_M_profile_resize(__old_size);
	}

	// operator[]
	mapped_type&
	operator[](const _Key& __k)
	{
	size_type __old_size = _Base::bucket_count();
	mapped_type& __res = _M_base()[__k];
	_M_profile_resize(__old_size);
	return __res;
	}

	mapped_type&
	operator[](_Key&& __k)
	{
	size_type __old_size = _Base::bucket_count();
	mapped_type& __res = _M_base()[std::move(__k)];
	_M_profile_resize(__old_size);
	return __res;
	}

	void
	swap(unordered_map& __x)
	noexcept( noexcept(__x._M_base().swap(__x)) )
	{ _Base::swap(__x._M_base()); }

	void rehash(size_type __n)
	{
	size_type __old_size = _Base::bucket_count();
	_Base::rehash(__n);
	_M_profile_resize(__old_size);
	}

	private:
	void
	_M_profile_resize(size_type __old_size)
	{
	size_type __new_size = _Base::bucket_count();
	if (__old_size != __new_size)
	__profcxx_hashtable_resize(this, __old_size, __new_size);
	}
	};

	template<typename _Key, typename _Tp, typename _Hash,
	typename _Pred, typename _Alloc>
	inline void
	swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	{ __x.swap(__y); }

	template<typename _Key, typename _Tp, typename _Hash,
	typename _Pred, typename _Alloc>
	inline bool
	operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	{ return static_cast<const _GLIBCXX_STD_BASE&>(__x) == __y; }

	template<typename _Key, typename _Tp, typename _Hash,
	typename _Pred, typename _Alloc>
	inline bool
	operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	{ return !(__x == __y); }

	#undef _GLIBCXX_BASE
	#undef _GLIBCXX_STD_BASE
	#define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
	#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE

	/// Class std::unordered_multimap wrapper with performance instrumentation.
	template<typename _Key, typename _Tp,
	typename _Hash = std::hash<_Key>,
	typename _Pred = std::equal_to<_Key>,
	typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
	class unordered_multimap
	: public _GLIBCXX_STD_BASE,
	public _Unordered_profile<unordered_multimap<_Key, _Tp,
	_Hash, _Pred, _Alloc>,
	false>
	{
	typedef typename _GLIBCXX_STD_BASE _Base;

	_Base&
	_M_base() noexcept { return *this; }

	const _Base&
	_M_base() const noexcept { return *this; }

	public:
	typedef typename _Base::size_type size_type;
	typedef typename _Base::hasher hasher;
	typedef typename _Base::key_equal key_equal;
	typedef typename _Base::allocator_type allocator_type;
	typedef typename _Base::key_type key_type;
	typedef typename _Base::value_type value_type;
	typedef typename _Base::difference_type difference_type;
	typedef typename _Base::reference reference;
	typedef typename _Base::const_reference const_reference;

	typedef typename _Base::iterator iterator;
	typedef typename _Base::const_iterator const_iterator;

	explicit
	unordered_multimap(size_type __n = 10,
	const hasher& __hf = hasher(),
	const key_equal& __eql = key_equal(),
	const allocator_type& __a = allocator_type())
	: _Base(__n, __hf, __eql, __a)
	{ }

	template<typename _InputIterator>
	unordered_multimap(_InputIterator __f, _InputIterator __l,
	size_type __n = 0,
	const hasher& __hf = hasher(),
	const key_equal& __eql = key_equal(),
	const allocator_type& __a = allocator_type())
	: _Base(__f, __l, __n, __hf, __eql, __a)
	{ }

	unordered_multimap(const unordered_multimap&) = default;

	unordered_multimap(const _Base& __x)
	: _Base(__x)
	{ }

	unordered_multimap(unordered_multimap&&) = default;

	explicit
	unordered_multimap(const allocator_type& __a)
	: _Base(__a)
	{ }

	unordered_multimap(const unordered_multimap& __ummap,
	const allocator_type& __a)
	: _Base(__ummap._M_base(), __a)
	{ }

	unordered_multimap(unordered_multimap&& __ummap,
	const allocator_type& __a)
	: _Base(std::move(__ummap._M_base()), __a)
	{ }

	unordered_multimap(initializer_list<value_type> __l,
	size_type __n = 0,
	const hasher& __hf = hasher(),
	const key_equal& __eql = key_equal(),
	const allocator_type& __a = allocator_type())
	: _Base(__l, __n, __hf, __eql, __a)
	{ }

	unordered_multimap&
	operator=(const unordered_multimap&) = default;

	unordered_multimap&
	operator=(unordered_multimap&&) = default;

	unordered_multimap&
	operator=(initializer_list<value_type> __l)
	{
	_M_base() = __l;
	return *this;
	}

	void
	clear() noexcept
	{
	__profcxx_hashtable_destruct(this, _Base::bucket_count(),
	_Base::size());
	this->_M_profile_destruct();
	_Base::clear();
	}

	template<typename... _Args>
	iterator
	emplace(_Args&&... __args)
	{
	size_type __old_size = _Base::bucket_count();
	iterator __res
	= _Base::emplace(std::forward<_Args>(__args)...);
	_M_profile_resize(__old_size);
	return __res;
	}

	template<typename... _Args>
	iterator
	emplace_hint(const_iterator __it, _Args&&... __args)
	{
	size_type __old_size = _Base::bucket_count();
	iterator __res
	= _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
	_M_profile_resize(__old_size);
	return __res;
	}

	void
	insert(std::initializer_list<value_type> __l)
	{
	size_type __old_size = _Base::bucket_count();
	_Base::insert(__l);
	_M_profile_resize(__old_size);
	}

	iterator
	insert(const value_type& __obj)
	{
	size_type __old_size = _Base::bucket_count();
	iterator __res = _Base::insert(__obj);
	_M_profile_resize(__old_size);
	return __res;
	}

	iterator
	insert(const_iterator __iter, const value_type& __v)
	{
	size_type __old_size = _Base::bucket_count();
	iterator __res = _Base::insert(__iter, __v);
	_M_profile_resize(__old_size);
	return __res;
	}

	template<typename _Pair, typename = typename
	std::enable_if<std::is_constructible<value_type,
	_Pair&&>::value>::type>
	iterator
	insert(_Pair&& __obj)
	{
	size_type __old_size = _Base::bucket_count();
	iterator __res = _Base::insert(std::forward<_Pair>(__obj));
	_M_profile_resize(__old_size);
	return __res;
	}

	template<typename _Pair, typename = typename
	std::enable_if<std::is_constructible<value_type,
	_Pair&&>::value>::type>
	iterator
	insert(const_iterator __iter, _Pair&& __v)
	{
	size_type __old_size = _Base::bucket_count();
	iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v));
	_M_profile_resize(__old_size);
	return __res;
	}

	template<typename _InputIter>
	void
	insert(_InputIter __first, _InputIter __last)
	{
	size_type __old_size = _Base::bucket_count();
	_Base::insert(__first, __last);
	_M_profile_resize(__old_size);
	}

	void
	swap(unordered_multimap& __x)
	noexcept( noexcept(__x._M_base().swap(__x)) )
	{ _Base::swap(__x._M_base()); }

	void
	rehash(size_type __n)
	{
	size_type __old_size = _Base::bucket_count();
	_Base::rehash(__n);
	_M_profile_resize(__old_size);
	}

	private:
	void
	_M_profile_resize(size_type __old_size)
	{
	size_type __new_size = _Base::bucket_count();
	if (__old_size != __new_size)
	__profcxx_hashtable_resize(this, __old_size, __new_size);
	}
	};

	template<typename _Key, typename _Tp, typename _Hash,
	typename _Pred, typename _Alloc>
	inline void
	swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	{ __x.swap(__y); }

	template<typename _Key, typename _Tp, typename _Hash,
	typename _Pred, typename _Alloc>
	inline bool
	operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	{ return static_cast<const _GLIBCXX_STD_BASE&>(__x) == __y; }

	template<typename _Key, typename _Tp, typename _Hash,
	typename _Pred, typename _Alloc>
	inline bool
	operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	{ return !(__x == __y); }

	} // namespace __profile
	} // namespace std

	#undef _GLIBCXX_BASE
	#undef _GLIBCXX_STD_BASE

	#endif // C++11

	#endif