+2014-05-24 François Dumont <fdumont@gcc.gnu.org>
+
+ * include/profile/array: Clean useless white chars.
+ * include/profile/base.h: Likewise.
+ * include/profile/iterator_tracker.h: Likewise.
+ * include/profile/bitset: Code cleanup and remove not instrumented code.
+ * include/profile/deque: Likewise.
+ * include/profile/forward_list: Likewise.
+ * include/profile/list (std::__profile::_List_profile<>): New.
+ (std::__profile::list<>): Inherit from latter and adapt.
+ * include/profile/impl/profiler_map_to_unordered_map.h: Generalize
+ advise to match any ordered to unordered container conversion.
+ * include/profile/ordered_base.h (std::__profile::_Ordered_profile<>):
+ New.
+ * include/Makefile.am: Add latter.
+ * include/Makefile.in: Regenerate.
+ * include/profile/map.h (std::__profile::map<>): Inherit from latter,
+ remove not instrumented code.
+ * include/profile/multimap.h (std::__profile::multimap<>): Likewise.
+ * include/profile/set.h (std::__profile::set<>): Likewise.
+ * include/profile/multiset.h (std::__profile::multiset<>): Likewise.
+ * include/profile/unordered_base.h: Add some line feed.
+ * include/profile/unordered_map: Clean useless white chars and replace
+ spaces with tabs.
+ * include/profile/unordered_set: Likewise.
+ * include/profile/vector (std::__profile::_Vector_profile_pre<>): New.
+ (std::__profile::_Vector_profile_post<>): New.
+ (std::__profile::vector<>): Inherit from latter and adapt.
+
2014-05-23 Jonathan Wakely <jwakely@redhat.com>
PR libstdc++/60793
${profile_srcdir}/map.h \
${profile_srcdir}/multimap.h \
${profile_srcdir}/multiset.h \
+ ${profile_srcdir}/ordered_base.h \
${profile_srcdir}/set \
${profile_srcdir}/set.h \
${profile_srcdir}/iterator_tracker.h
${profile_srcdir}/map.h \
${profile_srcdir}/multimap.h \
${profile_srcdir}/multiset.h \
+ ${profile_srcdir}/ordered_base.h \
${profile_srcdir}/set \
${profile_srcdir}/set.h \
${profile_srcdir}/iterator_tracker.h
end() const noexcept
{ return const_iterator(data() + _Nm); }
- reverse_iterator
+ reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
- const_reverse_iterator
+ const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
- reverse_iterator
+ reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
- const_reverse_iterator
+ const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
cend() const noexcept
{ return const_iterator(data() + _Nm); }
- const_reverse_iterator
+ const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
- const_reverse_iterator
+ const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
// Capacity.
- constexpr size_type
+ constexpr size_type
size() const noexcept { return _Nm; }
- constexpr size_type
+ constexpr size_type
max_size() const noexcept { return _Nm; }
- constexpr bool
+ constexpr bool
empty() const noexcept { return size() == 0; }
// Element access.
_AT_Type::_S_ref(_M_elems, 0));
}
- reference
+ reference
front() noexcept
{ return *begin(); }
- constexpr const_reference
+ constexpr const_reference
front() const noexcept
{ return _AT_Type::_S_ref(_M_elems, 0); }
- reference
+ reference
back() noexcept
{ return _Nm ? *(end() - 1) : *end(); }
- constexpr const_reference
+ constexpr const_reference
back() const noexcept
{
return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
- : _AT_Type::_S_ref(_M_elems, 0);
+ : _AT_Type::_S_ref(_M_elems, 0);
}
pointer
// Array comparisons.
template<typename _Tp, std::size_t _Nm>
- inline bool
+ inline bool
operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return std::equal(__one.begin(), __one.end(), __two.begin()); }
template<typename _Tp, std::size_t _Nm>
inline bool
operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
- {
+ {
return std::lexicographical_compare(__a.begin(), __a.end(),
- __b.begin(), __b.end());
+ __b.begin(), __b.end());
}
template<typename _Tp, std::size_t _Nm>
* @namespace std::__profile
* @brief GNU profile code, replaces standard behavior with profile behavior.
*/
-namespace std _GLIBCXX_VISIBILITY(default)
-{
- namespace __profile { }
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+ namespace __profile { }
}
/**
{
namespace __profile
{
- /// Class std::bitset wrapper with performance instrumentation.
+ /// Class std::bitset wrapper with performance instrumentation, none at the
+ /// moment.
template<size_t _Nb>
class bitset
: public _GLIBCXX_STD_C::bitset<_Nb>
typedef _GLIBCXX_STD_C::bitset<_Nb> _Base;
public:
- // bit reference:
- class reference
- : private _Base::reference
- {
- typedef typename _Base::reference _Base_ref;
-
- friend class bitset;
- reference();
-
- reference(const _Base_ref& __base, bitset* __seq) _GLIBCXX_NOEXCEPT
- : _Base_ref(__base)
- { }
-
- public:
- reference(const reference& __x) _GLIBCXX_NOEXCEPT
- : _Base_ref(__x)
- { }
-
- reference&
- operator=(bool __x) _GLIBCXX_NOEXCEPT
- {
- *static_cast<_Base_ref*>(this) = __x;
- return *this;
- }
-
- reference&
- operator=(const reference& __x) _GLIBCXX_NOEXCEPT
- {
- *static_cast<_Base_ref*>(this) = __x;
- return *this;
- }
-
- bool
- operator~() const _GLIBCXX_NOEXCEPT
- {
- return ~(*static_cast<const _Base_ref*>(this));
- }
-
- operator bool() const _GLIBCXX_NOEXCEPT
- {
- return *static_cast<const _Base_ref*>(this);
- }
-
- reference&
- flip() _GLIBCXX_NOEXCEPT
- {
- _Base_ref::flip();
- return *this;
- }
- };
-
// 23.3.5.1 constructors:
- _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT
+#if __cplusplus < 201103L
+ bitset()
: _Base() { }
+#else
+ constexpr bitset() = default;
+#endif
#if __cplusplus >= 201103L
constexpr bitset(unsigned long long __val) noexcept
: _Base(__val) { }
template<typename _CharT, typename _Traits, typename _Alloc>
- explicit
- bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
+ explicit
+ bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
__pos = 0,
typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
#if __cplusplus >= 201103L
template<typename _CharT>
- explicit
- bitset(const _CharT* __str,
+ explicit
+ bitset(const _CharT* __str,
typename std::basic_string<_CharT>::size_type __n
= std::basic_string<_CharT>::npos,
_CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
return *this;
}
- // element access:
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 11. Bitset minor problems
- reference
- operator[](size_t __pos)
- {
- return reference(_M_base()[__pos], this);
- }
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 11. Bitset minor problems
- _GLIBCXX_CONSTEXPR bool
- operator[](size_t __pos) const
- {
- return _Base::operator[](__pos);
- }
-
- using _Base::to_ulong;
-#if __cplusplus >= 201103L
- using _Base::to_ullong;
-#endif
-
- template <typename _CharT, typename _Traits, typename _Alloc>
- std::basic_string<_CharT, _Traits, _Alloc>
- to_string() const
- { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 396. what are characters zero and one.
- template<class _CharT, class _Traits, class _Alloc>
- std::basic_string<_CharT, _Traits, _Alloc>
- to_string(_CharT __zero, _CharT __one = _CharT('1')) const
- {
- return _M_base().template
- to_string<_CharT, _Traits, _Alloc>(__zero, __one);
- }
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 434. bitset::to_string() hard to use.
- template<typename _CharT, typename _Traits>
- std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
- to_string() const
- { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 853. to_string needs updating with zero and one.
- template<class _CharT, class _Traits>
- std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
- to_string(_CharT __zero, _CharT __one = _CharT('1')) const
- { return to_string<_CharT, _Traits,
- std::allocator<_CharT> >(__zero, __one); }
-
- template<typename _CharT>
- std::basic_string<_CharT, std::char_traits<_CharT>,
- std::allocator<_CharT> >
- to_string() const
- {
- return to_string<_CharT, std::char_traits<_CharT>,
- std::allocator<_CharT> >();
- }
-
- template<class _CharT>
- std::basic_string<_CharT, std::char_traits<_CharT>,
- std::allocator<_CharT> >
- to_string(_CharT __zero, _CharT __one = _CharT('1')) const
- {
- return to_string<_CharT, std::char_traits<_CharT>,
- std::allocator<_CharT> >(__zero, __one);
- }
-
- std::basic_string<char, std::char_traits<char>, std::allocator<char> >
- to_string() const
- {
- return to_string<char,std::char_traits<char>,std::allocator<char> >();
- }
-
- std::basic_string<char, std::char_traits<char>, std::allocator<char> >
- to_string(char __zero, char __one = '1') const
- {
- return to_string<char, std::char_traits<char>,
- std::allocator<char> >(__zero, __one);
- }
-
- using _Base::count;
- using _Base::size;
-
bool
operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
{ return _M_base() == __rhs; }
operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
{ return _M_base() != __rhs; }
- using _Base::test;
- using _Base::all;
- using _Base::any;
- using _Base::none;
-
bitset<_Nb>
operator<<(size_t __pos) const _GLIBCXX_NOEXCEPT
{ return bitset<_Nb>(_M_base() << __pos); }
typedef _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base;
public:
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
-
- typedef typename _Base::iterator iterator;
- typedef typename _Base::const_iterator const_iterator;
- typedef typename _Base::reverse_iterator reverse_iterator;
- typedef typename _Base::const_reverse_iterator const_reverse_iterator;
-
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
-
- typedef _Tp value_type;
- typedef _Allocator allocator_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::value_type value_type;
// 23.2.1.1 construct/copy/destroy:
+#if __cplusplus < 201103L
deque()
: _Base() { }
+ deque(const deque& __x)
+ : _Base(__x) { }
+
+ ~deque() { }
+#else
+ deque() = default;
+ deque(const deque&) = default;
+ deque(deque&&) = default;
+
+ ~deque() = default;
+
+ deque(initializer_list<value_type> __l,
+ const _Allocator& __a = _Allocator())
+ : _Base(__l, __a) { }
+#endif
explicit
deque(const _Allocator& __a)
#else
template<typename _InputIterator>
#endif
- deque(_InputIterator __first, _InputIterator __last,
+ deque(_InputIterator __first, _InputIterator __last,
const _Allocator& __a = _Allocator())
: _Base(__first, __last, __a)
- { }
-
- deque(const deque& __x)
- : _Base(__x) { }
+ { }
deque(const _Base& __x)
: _Base(__x) { }
-#if __cplusplus >= 201103L
- deque(deque&& __x)
- : _Base(std::move(__x))
- { }
-
- deque(initializer_list<value_type> __l,
- const allocator_type& __a = allocator_type())
- : _Base(__l, __a) { }
-#endif
-
- ~deque() _GLIBCXX_NOEXCEPT { }
-
+#if __cplusplus < 201103L
deque&
operator=(const deque& __x)
{
- *static_cast<_Base*>(this) = __x;
+ _M_base() = __x;
return *this;
}
+#else
+ deque&
+ operator=(const deque&) = default;
-#if __cplusplus >= 201103L
deque&
- operator=(deque&& __x) noexcept
- {
- // NB: DR 1204.
- // NB: DR 675.
- this->clear();
- this->swap(__x);
- return *this;
- }
+ operator=(deque&&) = default;
deque&
operator=(initializer_list<value_type> __l)
{
- *static_cast<_Base*>(this) = __l;
+ _M_base() = __l;
return *this;
}
#endif
-#if __cplusplus >= 201103L
- template<typename _InputIterator,
- typename = std::_RequireInputIter<_InputIterator>>
-#else
- template<typename _InputIterator>
-#endif
- void
- assign(_InputIterator __first, _InputIterator __last)
- {
- _Base::assign(__first, __last);
- }
-
- void
- assign(size_type __n, const _Tp& __t)
- {
- _Base::assign(__n, __t);
- }
-
-#if __cplusplus >= 201103L
- void
- assign(initializer_list<value_type> __l)
- {
- _Base::assign(__l);
- }
-#endif
-
- using _Base::get_allocator;
-
- // iterators:
- iterator
- begin() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::begin()); }
-
- const_iterator
- begin() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::begin()); }
-
- iterator
- end() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::end()); }
-
- const_iterator
- end() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::end()); }
-
- reverse_iterator
- rbegin() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(end()); }
-
- const_reverse_iterator
- rbegin() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(end()); }
-
- reverse_iterator
- rend() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(begin()); }
-
- const_reverse_iterator
- rend() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(begin()); }
-
-#if __cplusplus >= 201103L
- const_iterator
- cbegin() const noexcept
- { return const_iterator(_Base::begin()); }
-
- const_iterator
- cend() const noexcept
- { return const_iterator(_Base::end()); }
-
- const_reverse_iterator
- crbegin() const noexcept
- { return const_reverse_iterator(end()); }
-
- const_reverse_iterator
- crend() const noexcept
- { return const_reverse_iterator(begin()); }
-#endif
-
- // 23.2.1.2 capacity:
- using _Base::size;
- using _Base::max_size;
-
-#if __cplusplus >= 201103L
- void
- resize(size_type __sz)
- {
- _Base::resize(__sz);
- }
-
- void
- resize(size_type __sz, const _Tp& __c)
- {
- _Base::resize(__sz, __c);
- }
-#else
void
- resize(size_type __sz, _Tp __c = _Tp())
- {
- _Base::resize(__sz, __c);
- }
-#endif
-
+ swap(deque& __x)
#if __cplusplus >= 201103L
- using _Base::shrink_to_fit;
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
-
- using _Base::empty;
-
- // element access:
- reference
- operator[](size_type __n) _GLIBCXX_NOEXCEPT
- {
- return _M_base()[__n];
- }
-
- const_reference
- operator[](size_type __n) const _GLIBCXX_NOEXCEPT
- {
- return _M_base()[__n];
- }
-
- using _Base::at;
-
- reference
- front() _GLIBCXX_NOEXCEPT
- {
- return _Base::front();
- }
-
- const_reference
- front() const _GLIBCXX_NOEXCEPT
- {
- return _Base::front();
- }
-
- reference
- back() _GLIBCXX_NOEXCEPT
- {
- return _Base::back();
- }
-
- const_reference
- back() const _GLIBCXX_NOEXCEPT
- {
- return _Base::back();
- }
-
- // 23.2.1.3 modifiers:
- void
- push_front(const _Tp& __x)
- {
- _Base::push_front(__x);
- }
-
- void
- push_back(const _Tp& __x)
- {
- _Base::push_back(__x);
- }
-
-#if __cplusplus >= 201103L
- void
- push_front(_Tp&& __x)
- { emplace_front(std::move(__x)); }
-
- void
- push_back(_Tp&& __x)
- { emplace_back(std::move(__x)); }
-
- template<typename... _Args>
- void
- emplace_front(_Args&&... __args)
- {
- _Base::emplace_front(std::forward<_Args>(__args)...);
- }
-
- template<typename... _Args>
- void
- emplace_back(_Args&&... __args)
- {
- _Base::emplace_back(std::forward<_Args>(__args)...);
- }
-
- template<typename... _Args>
- iterator
- emplace(const_iterator __position, _Args&&... __args)
- {
- typename _Base::iterator __res = _Base::emplace(__position,
- std::forward<_Args>(__args)...);
- return iterator(__res);
- }
-#endif
-
- iterator
-#if __cplusplus >= 201103L
- insert(const_iterator __position, const _Tp& __x)
-#else
- insert(iterator __position, const _Tp& __x)
-#endif
- {
- typename _Base::iterator __res = _Base::insert(__position, __x);
- return iterator(__res);
- }
-
-#if __cplusplus >= 201103L
- iterator
- insert(const_iterator __position, _Tp&& __x)
- { return emplace(__position, std::move(__x)); }
-
- iterator
- insert(const_iterator __p, initializer_list<value_type> __l)
- { return _Base::insert(__p, __l); }
-#endif
-
-#if __cplusplus >= 201103L
- iterator
- insert(const_iterator __position, size_type __n, const _Tp& __x)
- { return _Base::insert(__position, __n, __x); }
-#else
- void
- insert(iterator __position, size_type __n, const _Tp& __x)
- { _Base::insert(__position, __n, __x); }
-#endif
-
-#if __cplusplus >= 201103L
- template<typename _InputIterator,
- typename = std::_RequireInputIter<_InputIterator>>
- iterator
- insert(const_iterator __position,
- _InputIterator __first, _InputIterator __last)
- { return _Base::insert(__position, __first, __last); }
-#else
- template<typename _InputIterator>
- void
- insert(iterator __position,
- _InputIterator __first, _InputIterator __last)
- { _Base::insert(__position, __first, __last); }
-#endif
-
- void
- pop_front() _GLIBCXX_NOEXCEPT
- {
- _Base::pop_front();
- }
-
- void
- pop_back() _GLIBCXX_NOEXCEPT
- {
- _Base::pop_back();
- }
-
- iterator
-#if __cplusplus >= 201103L
- erase(const_iterator __position)
-#else
- erase(iterator __position)
-#endif
- {
- return _Base::erase(__position);
- }
-
- iterator
-#if __cplusplus >= 201103L
- erase(const_iterator __first, const_iterator __last)
-#else
- erase(iterator __first, iterator __last)
-#endif
- {
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 151. can't currently clear() empty container
- return _Base::erase(__first, __last);
- }
-
- void
- swap(deque& __x) _GLIBCXX_NOEXCEPT
- {
- _Base::swap(__x);
- }
-
- void
- clear() _GLIBCXX_NOEXCEPT
- {
- _Base::clear();
- }
+ { _Base::swap(__x); }
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
};
template<typename _Tp, typename _Alloc>
{
typedef _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> _Base;
- typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
- rebind<_GLIBCXX_STD_C::_Fwd_list_node<_Tp>>::other _Node_alloc_type;
-
- typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;
-
public:
- typedef typename _Base::size_type size_type;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::const_iterator const_iterator;
// 23.2.3.1 construct/copy/destroy:
explicit
{ }
forward_list(size_type __n, const _Tp& __value,
- const _Alloc& __al = _Alloc())
+ const _Alloc& __al = _Alloc())
: _Base(__n, __value, __al)
{ }
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
- forward_list(_InputIterator __first, _InputIterator __last,
- const _Alloc& __al = _Alloc())
- : _Base(__first, __last, __al)
- { }
-
- forward_list(const forward_list& __list)
- : _Base(__list)
- { }
+ forward_list(_InputIterator __first, _InputIterator __last,
+ const _Alloc& __al = _Alloc())
+ : _Base(__first, __last, __al)
+ { }
- forward_list(forward_list&& __list) noexcept
- : _Base(std::move(__list)) { }
+ forward_list(const forward_list&) = default;
+ forward_list(forward_list&&) = default;
forward_list(std::initializer_list<_Tp> __il,
- const _Alloc& __al = _Alloc())
+ const _Alloc& __al = _Alloc())
: _Base(__il, __al)
{ }
- ~forward_list() noexcept
- { }
+ ~forward_list() = default;
forward_list&
- operator=(const forward_list& __list)
- {
- static_cast<_Base&>(*this) = __list;
- return *this;
- }
+ operator=(const forward_list&) = default;
forward_list&
- operator=(forward_list&& __list)
- noexcept(_Node_alloc_traits::_S_nothrow_move())
- {
- static_cast<_Base&>(*this) = std::move(__list);
- return *this;
- }
+ operator=(forward_list&&) = default;
forward_list&
operator=(std::initializer_list<_Tp> __il)
{
- static_cast<_Base&>(*this) = __il;
- return *this;
+ _M_base() = __il;
+ return *this;
}
+ void
+ swap(forward_list& __fl)
+ noexcept( noexcept(declval<_Base>().swap(__fl)) )
+ { _Base::swap(__fl); }
+
+ void
+ splice_after(const_iterator __pos, forward_list&& __fl)
+ { _Base::splice_after(__pos, std::move(__fl)); }
+
+ void
+ splice_after(const_iterator __pos, forward_list& __list)
+ { _Base::splice_after(__pos, __list); }
+
+ void
+ splice_after(const_iterator __pos, forward_list&& __list,
+ const_iterator __i)
+ { _Base::splice_after(__pos, std::move(__list), __i); }
+
+ void
+ splice_after(const_iterator __pos, forward_list& __list,
+ const_iterator __i)
+ { _Base::splice_after(__pos, __list, __i); }
+
+ void
+ splice_after(const_iterator __pos, forward_list&& __list,
+ const_iterator __before, const_iterator __last)
+ { _Base::splice_after(__pos, std::move(__list), __before, __last); }
+
+ void
+ splice_after(const_iterator __pos, forward_list& __list,
+ const_iterator __before, const_iterator __last)
+ { _Base::splice_after(__pos, __list, __before, __last); }
+
+ void
+ merge(forward_list&& __list)
+ { _Base::merge(std::move(__list)); }
+
+ void
+ merge(forward_list& __list)
+ { _Base::merge(__list); }
+
+ template<typename _Comp>
+ void
+ merge(forward_list&& __list, _Comp __comp)
+ { _Base::merge(std::move(__list), __comp); }
+
+ template<typename _Comp>
+ void
+ merge(forward_list& __list, _Comp __comp)
+ { _Base::merge(__list, __comp); }
+
_Base&
- _M_base() noexcept { return *this; }
+ _M_base() noexcept { return *this; }
const _Base&
- _M_base() const noexcept { return *this; }
+ _M_base() const noexcept { return *this; }
};
template<typename _Tp, typename _Alloc>
inline bool
operator==(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return __lx._M_base() == __ly._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator<(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return __lx._M_base() < __ly._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator!=(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return !(__lx == __ly); }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool
operator>(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return (__ly < __lx); }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool
operator>=(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return !(__lx < __ly); }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool
operator<=(const forward_list<_Tp, _Alloc>& __lx,
- const forward_list<_Tp, _Alloc>& __ly)
+ const forward_list<_Tp, _Alloc>& __ly)
{ return !(__ly < __lx); }
/// See std::forward_list::swap().
__log2(std::size_t __size)
{
for (int __bit_count = sizeof(std::size_t) - 1; __bit_count >= 0;
- -- __bit_count)
+ -- __bit_count)
if ((2 << __bit_count) & __size)
return __bit_count;
return 0;
inline float
__map_insert_cost(std::size_t __size)
- { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value
+ { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value
* static_cast<float>(__log2(__size))); }
inline float
{ return (_GLIBCXX_PROFILE_DATA(__map_find_cost_factor).__value
* static_cast<float>(__log2(__size))); }
- /** @brief A map-to-unordered_map instrumentation line in the
+ /** @brief A map-to-unordered_map instrumentation line in the
object table. */
class __map2umap_info
: public __object_info_base
__map2umap_info()
: _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0),
_M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { }
-
+
__map2umap_info(__stack_t __stack)
- : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0),
+ : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0),
_M_iterate(0), _M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { }
virtual ~__map2umap_info() { }
std::string
__advice() const
- { return "change std::map to std::unordered_map"; }
+ { return "prefer an unordered container"; }
void
__record_insert(std::size_t __size, std::size_t __count)
{
- _M_insert += __count;
- _M_map_cost += __count * __map_insert_cost(__size);
- _M_umap_cost
- += (__count
- * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value);
+ ++_M_insert;
+ if (__count)
+ {
+ _M_map_cost += __count * __map_insert_cost(__size);
+ _M_umap_cost
+ += (__count
+ * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value);
+ }
}
void
__record_erase(std::size_t __size, std::size_t __count)
{
- _M_erase += __count;
- _M_map_cost += __count * __map_erase_cost(__size);
- _M_umap_cost
- += (__count
- * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value);
+ ++_M_erase;
+ if (__count)
+ {
+ _M_map_cost += __count * __map_erase_cost(__size);
+ _M_umap_cost
+ += (__count
+ * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value);
+ }
}
void
__record_find(std::size_t __size)
{
- _M_find += 1;
+ ++_M_find;
_M_map_cost += __map_find_cost(__size);
_M_umap_cost += _GLIBCXX_PROFILE_DATA(__umap_find_cost_factor).__value;
}
};
- /** @brief A map-to-unordered_map instrumentation line in the
+ /** @brief A map-to-unordered_map instrumentation line in the
stack table. */
- class __map2umap_stack_info
+ class __map2umap_stack_info
: public __map2umap_info
{
public:
/** @brief Map-to-unordered_map instrumentation producer. */
class __trace_map2umap
- : public __trace_base<__map2umap_info, __map2umap_stack_info>
+ : public __trace_base<__map2umap_info, __map2umap_stack_info>
{
public:
__trace_map2umap()
: __trace_base<__map2umap_info, __map2umap_stack_info>()
- { __id = "map-to-unordered-map"; }
+ { __id = "ordered-to-unordered"; }
};
inline void
__trace_map_to_unordered_map_report(FILE* __f,
__warning_vector_t& __warnings)
{
- if (_GLIBCXX_PROFILE_DATA(_S_map2umap))
+ if (_GLIBCXX_PROFILE_DATA(_S_map2umap))
{
_GLIBCXX_PROFILE_DATA(_S_map2umap)->__collect_warnings(__warnings);
_GLIBCXX_PROFILE_DATA(_S_map2umap)->__write(__f);
}
inline void
- __trace_map_to_unordered_map_insert(const void* __obj,
+ __trace_map_to_unordered_map_insert(const void* __obj,
std::size_t __size, std::size_t __count)
{
if (!__profcxx_init())
}
inline void
- __trace_map_to_unordered_map_erase(const void* __obj,
+ __trace_map_to_unordered_map_erase(const void* __obj,
std::size_t __size, std::size_t __count)
{
- if (!__profcxx_init())
+ if (!__profcxx_init())
return;
- __map2umap_info* __info
+ __map2umap_info* __info
= _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
if (__info)
__map2umap_info* __info
= _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
-
+
if (__info)
__info->__record_iterate(__count);
}
{
namespace __profile
{
-
template<typename _Iterator, typename _Sequence>
- class __iterator_tracker
+ class __iterator_tracker
{
typedef __iterator_tracker _Self;
typedef std::iterator_traits<_Iterator> _Traits;
public:
- typedef _Iterator _Base_iterator;
- typedef typename _Traits::iterator_category iterator_category;
- typedef typename _Traits::value_type value_type;
- typedef typename _Traits::difference_type difference_type;
- typedef typename _Traits::reference reference;
- typedef typename _Traits::pointer pointer;
+ typedef _Iterator _Base_iterator;
+ typedef typename _Traits::iterator_category iterator_category;
+ typedef typename _Traits::value_type value_type;
+ typedef typename _Traits::difference_type difference_type;
+ typedef typename _Traits::reference reference;
+ typedef typename _Traits::pointer pointer;
__iterator_tracker() _GLIBCXX_NOEXCEPT
: _M_current(), _M_ds(0) { }
: _M_current(__x._M_current), _M_ds(__x._M_ds) { }
template<typename _MutableIterator>
- __iterator_tracker(const __iterator_tracker<_MutableIterator,
+ __iterator_tracker(const __iterator_tracker<_MutableIterator,
typename __gnu_cxx::__enable_if
<(std::__are_same<_MutableIterator, typename
_Sequence::iterator::_Base_iterator>::__value),
_Iterator
base() const _GLIBCXX_NOEXCEPT { return _M_current; }
-
+
/**
* @brief Conversion to underlying non-debug iterator to allow
* better interaction with non-profile containers.
template<typename _Iterator, typename _Sequence>
inline bool
operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
- const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+ const __iterator_tracker<_Iterator, _Sequence>& __rhs)
_GLIBCXX_NOEXCEPT
{ return __lhs.base() != __rhs.base(); }
#define _GLIBCXX_PROFILE_LIST 1
#include <list>
-#include <profile/base.h>
-#include <profile/iterator_tracker.h>
+#include <profile/base.h>
+#include <profile/iterator_tracker.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
+ template<typename _List>
+ class _List_profile
+ {
+ _List&
+ _M_conjure()
+ { return *static_cast<_List*>(this); }
+
+ public:
+ _List_profile() _GLIBCXX_NOEXCEPT
+ {
+ __profcxx_list_construct(&_M_conjure()); // list2slist
+ __profcxx_list_construct2(&_M_conjure()); // list2vector
+ }
+
+#if __cplusplus >= 201103L
+ _List_profile(const _List_profile&) noexcept
+ : _List_profile() { }
+ _List_profile(_List_profile&&) noexcept
+ : _List_profile() { }
+
+ _List_profile&
+ operator=(const _List_profile&) = default;
+ _List_profile&
+ operator=(_List_profile&&) = default;
+#endif
+
+ ~_List_profile()
+ {
+ __profcxx_list_destruct(&_M_conjure());
+ __profcxx_list_destruct2(&_M_conjure());
+ }
+ };
+
/** @brief List wrapper with performance instrumentation. */
-template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
+ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
class list
- : public _GLIBCXX_STD_C::list<_Tp, _Allocator>
+ : public _GLIBCXX_STD_C::list<_Tp, _Allocator>,
+ public _List_profile<list<_Tp, _Allocator> >
{
- typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base;
public:
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
- typedef __iterator_tracker<typename _Base::iterator, list>
- iterator;
- typedef __iterator_tracker<typename _Base::const_iterator, list>
- const_iterator;
+ typedef __iterator_tracker<typename _Base::iterator, list>
+ iterator;
+ typedef __iterator_tracker<typename _Base::const_iterator, list>
+ const_iterator;
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
- typedef _Tp value_type;
- typedef _Allocator allocator_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef _Tp value_type;
+ typedef _Allocator allocator_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// 23.2.2.1 construct/copy/destroy:
- list() _GLIBCXX_NOEXCEPT
- : _Base()
- {
- __profcxx_list_construct(this); // list2slist
- __profcxx_list_construct2(this); // list2vector
- }
+#if __cplusplus < 201103L
+ list() { }
+ list(const list& __x)
+ : _Base(__x) { }
+
+ ~list() { }
+#else
+ list() = default;
+ list(const list&) = default;
+ list(list&&) = default;
+ ~list() = default;
+
+ list(initializer_list<value_type> __l,
+ const allocator_type& __a = allocator_type())
+ : _Base(__l, __a) { }
+#endif
explicit
list(const _Allocator& __a) _GLIBCXX_NOEXCEPT
- : _Base(__a)
- {
- __profcxx_list_construct(this); // list2slist
- __profcxx_list_construct2(this); // list2vector
- }
+ : _Base(__a) { }
#if __cplusplus >= 201103L
explicit
list(size_type __n)
- : _Base(__n)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
+ : _Base(__n) { }
list(size_type __n, const _Tp& __value,
const _Allocator& __a = _Allocator())
- : _Base(__n, __value, __a)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
+ : _Base(__n, __value, __a) { }
#else
explicit
list(size_type __n, const _Tp& __value = _Tp(),
const _Allocator& __a = _Allocator())
- : _Base(__n, __value, __a)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
+ : _Base(__n, __value, __a) { }
#endif
#if __cplusplus >= 201103L
#endif
list(_InputIterator __first, _InputIterator __last,
const _Allocator& __a = _Allocator())
- : _Base(__first, __last, __a)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
-
- list(const list& __x)
- : _Base(__x)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
+ : _Base(__first, __last, __a) { }
list(const _Base& __x)
- : _Base(__x)
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
-
-#if __cplusplus >= 201103L
- list(list&& __x) noexcept
- : _Base(std::move(__x))
- {
- __profcxx_list_construct(this);
- __profcxx_list_construct2(this);
- }
-
- list(initializer_list<value_type> __l,
- const allocator_type& __a = allocator_type())
- : _Base(__l, __a) { }
-#endif
-
- ~list() _GLIBCXX_NOEXCEPT
- {
- __profcxx_list_destruct(this);
- __profcxx_list_destruct2(this);
- }
+ : _Base(__x) { }
+#if __cplusplus < 201103L
list&
operator=(const list& __x)
{
- static_cast<_Base&>(*this) = __x;
+ _M_base() = __x;
return *this;
}
+#else
+ list&
+ operator=(const list&) = default;
-#if __cplusplus >= 201103L
list&
- operator=(list&& __x)
- {
- // NB: DR 1204.
- // NB: DR 675.
- this->clear();
- this->swap(__x);
- return *this;
- }
+ operator=(list&&) = default;
list&
operator=(initializer_list<value_type> __l)
{
- static_cast<_Base&>(*this) = __l;
+ _M_base() = __l;
return *this;
}
-
- void
- assign(initializer_list<value_type> __l)
- { _Base::assign(__l); }
#endif
-#if __cplusplus >= 201103L
- template<typename _InputIterator,
- typename = std::_RequireInputIter<_InputIterator>>
-#else
- template<class _InputIterator>
-#endif
- void
- assign(_InputIterator __first, _InputIterator __last)
- { _Base::assign(__first, __last); }
-
- void
- assign(size_type __n, const _Tp& __t)
- { _Base::assign(__n, __t); }
-
- using _Base::get_allocator;
-
// iterators:
iterator
begin() _GLIBCXX_NOEXCEPT
iterator
end() _GLIBCXX_NOEXCEPT
{
- __profcxx_list_rewind(this);
- return iterator(_Base::end(), this);
+ __profcxx_list_rewind(this);
+ return iterator(_Base::end(), this);
}
const_iterator
end() const _GLIBCXX_NOEXCEPT
{
- __profcxx_list_rewind(this);
- return const_iterator(_Base::end(), this);
+ __profcxx_list_rewind(this);
+ return const_iterator(_Base::end(), this);
}
reverse_iterator
rbegin() _GLIBCXX_NOEXCEPT
{
- __profcxx_list_rewind(this);
- return reverse_iterator(end());
+ __profcxx_list_rewind(this);
+ return reverse_iterator(end());
}
const_reverse_iterator
rbegin() const _GLIBCXX_NOEXCEPT
- {
- __profcxx_list_rewind(this);
- return const_reverse_iterator(end());
+ {
+ __profcxx_list_rewind(this);
+ return const_reverse_iterator(end());
}
reverse_iterator
#if __cplusplus >= 201103L
const_iterator
cbegin() const noexcept
- { return const_iterator(_Base::begin(), this); }
+ { return const_iterator(_Base::cbegin(), this); }
const_iterator
cend() const noexcept
- { return const_iterator(_Base::end(), this); }
+ { return const_iterator(_Base::cend(), this); }
const_reverse_iterator
crbegin() const noexcept
#endif
// 23.2.2.2 capacity:
- using _Base::empty;
- using _Base::size;
- using _Base::max_size;
-
-#if __cplusplus >= 201103L
- void
- resize(size_type __sz)
- { _Base::resize(__sz); }
-
- void
- resize(size_type __sz, const _Tp& __c)
- { _Base::resize(__sz, __c); }
-#else
- void
- resize(size_type __sz, _Tp __c = _Tp())
- { _Base::resize(__sz, __c); }
-#endif
-
- // element access:
- reference
- front() _GLIBCXX_NOEXCEPT
- { return _Base::front(); }
-
- const_reference
- front() const _GLIBCXX_NOEXCEPT
- { return _Base::front(); }
-
reference
back() _GLIBCXX_NOEXCEPT
{
- __profcxx_list_rewind(this);
+ __profcxx_list_rewind(this);
return _Base::back();
}
const_reference
back() const _GLIBCXX_NOEXCEPT
{
- __profcxx_list_rewind(this);
+ __profcxx_list_rewind(this);
return _Base::back();
}
void
push_front(const value_type& __x)
{
- __profcxx_list_invalid_operator(this);
- __profcxx_list_operation(this);
- _Base::push_front(__x);
+ __profcxx_list_invalid_operator(this);
+ __profcxx_list_operation(this);
+ _Base::push_front(__x);
}
-#if __cplusplus >= 201103L
- using _Base::emplace_front;
-#endif
-
void
pop_front() _GLIBCXX_NOEXCEPT
{
- __profcxx_list_operation(this);
+ __profcxx_list_operation(this);
_Base::pop_front();
}
- using _Base::push_back;
-
-#if __cplusplus >= 201103L
- using _Base::emplace_back;
-#endif
-
void
pop_back() _GLIBCXX_NOEXCEPT
{
- iterator __victim = end();
- --__victim;
_Base::pop_back();
- __profcxx_list_rewind(this);
+ __profcxx_list_rewind(this);
}
#if __cplusplus >= 201103L
template<typename... _Args>
- iterator
- emplace(const_iterator __position, _Args&&... __args)
+ iterator
+ emplace(const_iterator __position, _Args&&... __args)
{
return iterator(_Base::emplace(__position.base(),
- std::forward<_Args>(__args)...),
+ std::forward<_Args>(__args)...),
this);
}
#endif
insert(iterator __position, const _Tp& __x)
#endif
{
- _M_profile_insert(this, __position, size());
- return iterator(_Base::insert(__position.base(), __x), this);
+ _M_profile_insert(this, __position, this->size());
+ return iterator(_Base::insert(__position.base(), __x), this);
}
#if __cplusplus >= 201103L
iterator
insert(const_iterator __position, _Tp&& __x)
{
- _M_profile_insert(this, __position, size());
- return iterator(_Base::emplace(__position.base(), std::move(__x)),
- this);
+ _M_profile_insert(this, __position, this->size());
+ return iterator(_Base::emplace(__position.base(), std::move(__x)),
+ this);
}
iterator
insert(const_iterator __position, initializer_list<value_type> __l)
{
- _M_profile_insert(this, __position, size());
- return iterator(_Base::insert(__position.base(), __l), this);
+ _M_profile_insert(this, __position, this->size());
+ return iterator(_Base::insert(__position.base(), __l), this);
}
#endif
iterator
insert(const_iterator __position, size_type __n, const _Tp& __x)
{
- _M_profile_insert(this, __position, size());
+ _M_profile_insert(this, __position, this->size());
return iterator(_Base::insert(__position.base(), __n, __x), this);
}
#else
void
insert(iterator __position, size_type __n, const _Tp& __x)
{
- _M_profile_insert(this, __position, size());
+ _M_profile_insert(this, __position, this->size());
_Base::insert(__position.base(), __n, __x);
}
#endif
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
- insert(const_iterator __position, _InputIterator __first,
+ insert(const_iterator __position, _InputIterator __first,
_InputIterator __last)
{
- _M_profile_insert(this, __position, size());
+ _M_profile_insert(this, __position, this->size());
return iterator(_Base::insert(__position.base(), __first, __last),
this);
}
#else
template<class _InputIterator>
- void
- insert(iterator __position, _InputIterator __first,
+ void
+ insert(iterator __position, _InputIterator __first,
_InputIterator __last)
{
- _M_profile_insert(this, __position, size());
+ _M_profile_insert(this, __position, this->size());
_Base::insert(__position.base(), __first, __last);
}
#endif
void
swap(list& __x)
+#if __cplusplus >= 201103L
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
+#endif
{ _Base::swap(__x); }
- void
- clear() _GLIBCXX_NOEXCEPT
- { _Base::clear(); }
-
// 23.2.2.4 list operations:
void
#if __cplusplus >= 201103L
iterator __last)
#endif
{
- // We used to perform the splice_alloc check: not anymore, redundant
- // after implementing the relevant bits of N1599.
-
_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()),
__first.base(), __last.base());
}
}
template<class _Predicate>
- void
- remove_if(_Predicate __pred)
- {
+ void
+ remove_if(_Predicate __pred)
+ {
for (iterator __x = begin(); __x != end(); )
{
- __profcxx_list_operation(this);
+ __profcxx_list_operation(this);
if (__pred(*__x))
__x = erase(__x);
else
iterator __next = __first;
while (++__next != __last)
{
- __profcxx_list_operation(this);
+ __profcxx_list_operation(this);
if (*__first == *__next)
erase(__next);
else
}
template<class _BinaryPredicate>
- void
- unique(_BinaryPredicate __binary_pred)
- {
+ void
+ unique(_BinaryPredicate __binary_pred)
+ {
iterator __first = begin();
iterator __last = end();
if (__first == __last)
iterator __next = __first;
while (++__next != __last)
{
- __profcxx_list_operation(this);
+ __profcxx_list_operation(this);
if (__binary_pred(*__first, *__next))
erase(__next);
else
#else
merge(list& __x)
#endif
- {
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 300. list::merge() specification incomplete
- if (this != &__x)
- { _Base::merge(_GLIBCXX_MOVE(__x._M_base())); }
- }
+ { _Base::merge(_GLIBCXX_MOVE(__x._M_base())); }
#if __cplusplus >= 201103L
void
#endif
template<class _Compare>
- void
+ void
#if __cplusplus >= 201103L
- merge(list&& __x, _Compare __comp)
+ merge(list&& __x, _Compare __comp)
#else
- merge(list& __x, _Compare __comp)
+ merge(list& __x, _Compare __comp)
#endif
- {
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 300. list::merge() specification incomplete
- if (this != &__x)
- { _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp); }
- }
+ { _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp); }
#if __cplusplus >= 201103L
template<typename _Compare>
- void
- merge(list& __x, _Compare __comp)
- { this->merge(std::move(__x), __comp); }
+ void
+ merge(list& __x, _Compare __comp)
+ { this->merge(std::move(__x), __comp); }
#endif
- void
- sort() { _Base::sort(); }
-
- template<typename _StrictWeakOrdering>
- void
- sort(_StrictWeakOrdering __pred) { _Base::sort(__pred); }
-
- using _Base::reverse;
-
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
void _M_profile_find() const
{ }
- void _M_profile_iterate(int __rewind = 0) const
+ void _M_profile_iterate(int __rewind = 0) const
{
- __profcxx_list_operation(this);
- __profcxx_list_iterate(this);
- if (__rewind)
- __profcxx_list_rewind(this);
+ __profcxx_list_operation(this);
+ __profcxx_list_iterate(this);
+ if (__rewind)
+ __profcxx_list_rewind(this);
}
private:
size_type
_M_profile_insert(void* obj, const_iterator __pos, size_type __size)
{
- size_type __shift = 0;
- typename _Base::const_iterator __it = __pos.base();
- for (; __it != _Base::end(); ++__it)
- __shift++;
- __profcxx_list_rewind(this);
- __profcxx_list_operation(this);
- __profcxx_list_insert(this, __shift, __size);
+ size_type __shift = 0;
+ typename _Base::const_iterator __it = __pos.base();
+ for (; __it != _Base::end(); ++__it)
+ __shift++;
+ __profcxx_list_rewind(this);
+ __profcxx_list_operation(this);
+ __profcxx_list_insert(this, __shift, __size);
}
};
#ifndef _GLIBCXX_PROFILE_MAP_H
#define _GLIBCXX_PROFILE_MAP_H 1
-#include <utility>
#include <profile/base.h>
+#include <profile/ordered_base.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class map
- : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>
+ : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>,
+ public _Ordered_profile<map<_Key, _Tp, _Compare, _Allocator> >
{
typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base;
-#if __cplusplus >= 201103L
- typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
-#endif
-
public:
// types:
- typedef _Key key_type;
- typedef _Tp mapped_type;
- typedef std::pair<const _Key, _Tp> value_type;
- typedef _Compare key_compare;
- typedef _Allocator allocator_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;
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef _Key key_type;
+ typedef _Tp mapped_type;
+ typedef typename _Base::value_type value_type;
+ typedef _Compare key_compare;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
+
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::reverse_iterator reverse_iterator;
+ typedef typename _Base::const_reverse_iterator const_reverse_iterator;
// 23.3.1.1 construct/copy/destroy:
+#if __cplusplus < 201103L
map()
- : _Base()
- { __profcxx_map_to_unordered_map_construct(this); }
+ : _Base() { }
+ map(const map& __x)
+ : _Base(__x) { }
+ ~map()
+ { }
+#else
+ map() = default;
+ map(const map&) = default;
+ map(map&&) = default;
+ ~map() = default;
+#endif
explicit
map(const _Compare& __comp,
const _Allocator& __a = _Allocator())
- : _Base(__comp, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ : _Base(__comp, __a) { }
#if __cplusplus >= 201103L
template<typename _InputIterator,
#else
template<typename _InputIterator>
#endif
- map(_InputIterator __first, _InputIterator __last,
+ map(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
- : _Base(__first, __last, __comp, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
-
- map(const map& __x)
- : _Base(__x)
- { __profcxx_map_to_unordered_map_construct(this); }
+ : _Base(__first, __last, __comp, __a) { }
map(const _Base& __x)
- : _Base(__x)
- { __profcxx_map_to_unordered_map_construct(this); }
+ : _Base(__x) { }
#if __cplusplus >= 201103L
- map(map&& __x)
- noexcept(is_nothrow_copy_constructible<_Compare>::value)
- : _Base(std::move(__x))
- { __profcxx_map_to_unordered_map_construct(this); }
-
map(initializer_list<value_type> __l,
const _Compare& __c = _Compare(),
- const allocator_type& __a = allocator_type())
- : _Base(__l, __c, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ const _Allocator& __a = _Allocator())
+ : _Base(__l, __c, __a) { }
explicit
- map(const allocator_type& __a)
- : _Base(__a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ map(const _Allocator& __a)
+ : _Base(__a) { }
- map(const map& __x, const allocator_type& __a)
- : _Base(__x, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ map(const map& __x, const _Allocator& __a)
+ : _Base(__x, __a) { }
- map(map&& __x, const allocator_type& __a)
- noexcept(is_nothrow_copy_constructible<_Compare>::value
- && _Alloc_traits::_S_always_equal())
- : _Base(std::move(__x), __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ map(map&& __x, const _Allocator& __a)
+ noexcept( noexcept(_Base(std::move(__x), __a)) )
+ : _Base(std::move(__x), __a) { }
- map(initializer_list<value_type> __l, const allocator_type& __a)
- : _Base(__l, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ map(initializer_list<value_type> __l, const _Allocator& __a)
+ : _Base(__l, __a) { }
template<typename _InputIterator>
- map(_InputIterator __first, _InputIterator __last,
- const allocator_type& __a)
- : _Base(__first, __last, __a)
- { __profcxx_map_to_unordered_map_construct(this); }
+ map(_InputIterator __first, _InputIterator __last,
+ const _Allocator& __a)
+ : _Base(__first, __last, __a) { }
#endif
- ~map() _GLIBCXX_NOEXCEPT
- { __profcxx_map_to_unordered_map_destruct(this); }
-
#if __cplusplus < 201103L
map&
operator=(const map& __x)
}
#endif
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 133. map missing get_allocator()
- using _Base::get_allocator;
-
- // iterators:
- iterator
- begin() _GLIBCXX_NOEXCEPT
- { return _Base::begin(); }
-
- const_iterator
- begin() const _GLIBCXX_NOEXCEPT
- { return _Base::begin(); }
-
- iterator
- end() _GLIBCXX_NOEXCEPT
- { return _Base::end(); }
-
- const_iterator
- end() const _GLIBCXX_NOEXCEPT
- { return _Base::end(); }
-
reverse_iterator
rbegin() _GLIBCXX_NOEXCEPT
- {
- __profcxx_map_to_unordered_map_invalidate(this);
- return reverse_iterator(end());
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
}
const_reverse_iterator
rbegin() const _GLIBCXX_NOEXCEPT
{
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_reverse_iterator(end());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
}
reverse_iterator
rend() _GLIBCXX_NOEXCEPT
{
- __profcxx_map_to_unordered_map_invalidate(this);
- return reverse_iterator(begin());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
}
const_reverse_iterator
rend() const _GLIBCXX_NOEXCEPT
{
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_reverse_iterator(begin());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
}
#if __cplusplus >= 201103L
- const_iterator
- cbegin() const noexcept
- { return const_iterator(_Base::begin()); }
-
- const_iterator
- cend() const noexcept
- { return const_iterator(_Base::end()); }
-
const_reverse_iterator
crbegin() const noexcept
{
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_reverse_iterator(end());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crbegin();
}
const_reverse_iterator
crend() const noexcept
{
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_reverse_iterator(begin());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crend();
}
#endif
- // capacity:
- using _Base::empty;
- using _Base::size;
- using _Base::max_size;
-
// 23.3.1.2 element access:
mapped_type&
operator[](const key_type& __k)
{
- __profcxx_map_to_unordered_map_find(this, size());
- return _Base::operator[](__k);
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::operator[](__k);
}
#if __cplusplus >= 201103L
mapped_type&
operator[](key_type&& __k)
{
- __profcxx_map_to_unordered_map_find(this, size());
- return _Base::operator[](std::move(__k));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::operator[](std::move(__k));
}
#endif
mapped_type&
at(const key_type& __k)
{
- __profcxx_map_to_unordered_map_find(this, size());
- return _Base::at(__k);
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::at(__k);
}
const mapped_type&
at(const key_type& __k) const
{
- __profcxx_map_to_unordered_map_find(this, size());
- return _Base::at(__k);
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::at(__k);
}
// modifiers:
std::pair<iterator, bool>
emplace(_Args&&... __args)
{
- __profcxx_map_to_unordered_map_insert(this, size(), 1);
- auto __res = _Base::emplace(std::forward<_Args>(__args)...);
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ // The cost is the same whether or not the element is inserted so we
+ // always report insertion of 1 element.
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::emplace(std::forward<_Args>(__args)...);
}
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
- size_type size_before = size();
- auto __res = _Base::emplace_hint(__pos,
- std::forward<_Args>(__args)...);
+ auto size_before = this->size();
+ auto __res = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...);
__profcxx_map_to_unordered_map_insert(this, size_before,
- size() - size_before);
+ _M_hint_used(__pos, __res) ? 0 : 1);
return __res;
}
#endif
std::pair<iterator, bool>
insert(const value_type& __x)
{
- __profcxx_map_to_unordered_map_insert(this, size(), 1);
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(__x);
}
#if __cplusplus >= 201103L
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- std::pair<iterator, bool>
- insert(_Pair&& __x)
- {
- __profcxx_map_to_unordered_map_insert(this, size(), 1);
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, bool> __res
- = _Base::insert(std::forward<_Pair>(__x));
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ std::pair<iterator, bool>
+ insert(_Pair&& __x)
+ {
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(std::forward<_Pair>(__x));
}
#endif
#if __cplusplus >= 201103L
void
insert(std::initializer_list<value_type> __list)
- {
- size_type size_before = size();
- _Base::insert(__list);
- __profcxx_map_to_unordered_map_insert(this, size_before,
- size() - size_before);
- }
+ { insert(__list.begin(), __list.end()); }
#endif
iterator
#if __cplusplus >= 201103L
- insert(const_iterator __position, const value_type& __x)
+ insert(const_iterator __pos, const value_type& __x)
#else
- insert(iterator __position, const value_type& __x)
+ insert(iterator __pos, const value_type& __x)
#endif
{
- size_type size_before = size();
- iterator __i = iterator(_Base::insert(__position, __x));
- __profcxx_map_to_unordered_map_insert(this, size_before,
- size() - size_before);
- return __i;
+ size_type size_before = this->size();
+ iterator __res = _Base::insert(__pos, __x);
+
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
}
#if __cplusplus >= 201103L
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- iterator
- insert(const_iterator __position, _Pair&& __x)
- {
- size_type size_before = size();
- iterator __i
- = iterator(_Base::insert(__position, std::forward<_Pair>(__x)));
- __profcxx_map_to_unordered_map_insert(this, size_before,
- size() - size_before);
- return __i;
+ iterator
+ insert(const_iterator __pos, _Pair&& __x)
+ {
+ size_type size_before = this->size();
+ auto __res = _Base::insert(__pos, std::forward<_Pair>(__x));
+
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
}
#endif
#else
template<typename _InputIterator>
#endif
- void
- insert(_InputIterator __first, _InputIterator __last)
- {
- size_type size_before = size();
- _Base::insert(__first, __last);
- __profcxx_map_to_unordered_map_insert(this, size_before,
- size() - size_before);
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ {
+ for (; __first != __last; ++__first)
+ insert(*__first);
}
#if __cplusplus >= 201103L
iterator
erase(const_iterator __position)
{
- iterator __i = _Base::erase(__position);
- __profcxx_map_to_unordered_map_erase(this, size(), 1);
- return __i;
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__position);
}
iterator
erase(iterator __position)
- { return erase(const_iterator(__position)); }
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__position);
+ }
#else
void
erase(iterator __position)
{
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
_Base::erase(__position);
- __profcxx_map_to_unordered_map_erase(this, size(), 1);
}
#endif
size_type
erase(const key_type& __x)
{
- iterator __victim = find(__x);
- if (__victim == end())
- return 0;
- else
- {
- _Base::erase(__victim);
- return 1;
- }
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__x);
}
#if __cplusplus >= 201103L
iterator
erase(const_iterator __first, const_iterator __last)
- { return iterator(_Base::erase(__first, __last)); }
+ {
+ if (__first != __last)
+ {
+ iterator __ret;
+ for (; __first != __last;)
+ __ret = erase(__first++);
+ return __ret;
+ }
+ else
+ return _Base::erase(__first, __last);
+ }
#else
void
erase(iterator __first, iterator __last)
- { _Base::erase(__first, __last); }
+ {
+ for (; __first != __last;)
+ erase(__first++);
+ }
#endif
void
swap(map& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{ _Base::swap(__x); }
- void
- clear() _GLIBCXX_NOEXCEPT
- { this->erase(begin(), end()); }
-
- // observers:
- using _Base::key_comp;
- using _Base::value_comp;
-
// 23.3.1.3 map operations:
iterator
find(const key_type& __x)
{
- __profcxx_map_to_unordered_map_find(this, size());
- return iterator(_Base::find(__x));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
}
const_iterator
find(const key_type& __x) const
{
- __profcxx_map_to_unordered_map_find(this, size());
- return const_iterator(_Base::find(__x));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
}
size_type
count(const key_type& __x) const
{
- __profcxx_map_to_unordered_map_find(this, size());
- return _Base::count(__x);
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::count(__x);
}
iterator
lower_bound(const key_type& __x)
- {
- __profcxx_map_to_unordered_map_invalidate(this);
- return iterator(_Base::lower_bound(__x));
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
}
const_iterator
lower_bound(const key_type& __x) const
- {
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_iterator(_Base::lower_bound(__x));
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
}
iterator
upper_bound(const key_type& __x)
- {
- __profcxx_map_to_unordered_map_invalidate(this);
- return iterator(_Base::upper_bound(__x));
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
}
const_iterator
upper_bound(const key_type& __x) const
- {
- __profcxx_map_to_unordered_map_invalidate(this);
- return const_iterator(_Base::upper_bound(__x));
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
}
std::pair<iterator,iterator>
equal_range(const key_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(iterator(__res.first),
- iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
std::pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{
- __profcxx_map_to_unordered_map_find(this, size());
- typedef typename _Base::const_iterator _Base_const_iterator;
- std::pair<_Base_const_iterator, _Base_const_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(const_iterator(__res.first),
- const_iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
- _Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _Base&
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
-
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+ private:
+ /** If hint is used we consider that the map and unordered_map
+ * operations have equivalent insertion cost so we do not update metrics
+ * about it.
+ * Note that to find out if hint has been used is libstdc++
+ * implementation dependant.
+ */
+ bool
+ _M_hint_used(const_iterator __hint, iterator __res)
+ {
+ return (__hint == __res ||
+ (__hint == this->end() && ++__res == this->end()) ||
+ (__hint != this->end() && (++__hint == __res ||
+ ++__res == --__hint)));
+ }
};
template<typename _Key, typename _Tp,
inline bool
operator==(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
- {
+ {
__profcxx_map_to_unordered_map_invalidate(&__lhs);
__profcxx_map_to_unordered_map_invalidate(&__rhs);
- return __lhs._M_base() == __rhs._M_base();
+ return __lhs._M_base() == __rhs._M_base();
}
template<typename _Key, typename _Tp,
inline bool
operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs,
const map<_Key, _Tp, _Compare, _Allocator>& __rhs)
- {
+ {
__profcxx_map_to_unordered_map_invalidate(&__lhs);
__profcxx_map_to_unordered_map_invalidate(&__rhs);
- return __lhs._M_base() != __rhs._M_base();
+ return __lhs._M_base() != __rhs._M_base();
}
template<typename _Key, typename _Tp,
{
__profcxx_map_to_unordered_map_invalidate(&__lhs);
__profcxx_map_to_unordered_map_invalidate(&__rhs);
- return __lhs._M_base() < __rhs._M_base();
+ return __lhs._M_base() < __rhs._M_base();
}
template<typename _Key, typename _Tp,
#ifndef _GLIBCXX_PROFILE_MULTIMAP_H
#define _GLIBCXX_PROFILE_MULTIMAP_H 1
-#include <utility>
+#include <profile/base.h>
+#include <profile/ordered_base.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class multimap
- : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>
+ : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>,
+ public _Ordered_profile<map<_Key, _Tp, _Compare, _Allocator> >
{
typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
-#if __cplusplus >= 201103L
- typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
-#endif
-
public:
// types:
- typedef _Key key_type;
- typedef _Tp mapped_type;
- typedef std::pair<const _Key, _Tp> value_type;
- typedef _Compare key_compare;
- typedef _Allocator allocator_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;
- typedef typename _Base::reverse_iterator reverse_iterator;
- typedef typename _Base::const_reverse_iterator const_reverse_iterator;
-
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
+ typedef _Key key_type;
+ typedef _Tp mapped_type;
+ typedef std::pair<const _Key, _Tp> value_type;
+ typedef _Compare key_compare;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
+
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
+ typedef typename _Base::reverse_iterator reverse_iterator;
+ typedef typename _Base::const_reverse_iterator const_reverse_iterator;
+
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
// 23.3.1.1 construct/copy/destroy:
+#if __cplusplus < 201103L
multimap()
: _Base() { }
+ multimap(const multimap& __x)
+ : _Base(__x) { }
+ ~multimap() { }
+#else
+ multimap() = default;
+ multimap(const multimap&) = default;
+ multimap(multimap&&) = default;
+ ~multimap() = default;
+#endif
explicit multimap(const _Compare& __comp,
const _Allocator& __a = _Allocator())
#else
template<typename _InputIterator>
#endif
- multimap(_InputIterator __first, _InputIterator __last,
- const _Compare& __comp = _Compare(),
- const _Allocator& __a = _Allocator())
- : _Base(__first, __last, __comp, __a) { }
-
-#if __cplusplus < 201103L
- multimap(const multimap& __x)
- : _Base(__x) { }
-#else
- multimap(const multimap&) = default;
- multimap(multimap&&) = default;
+ multimap(_InputIterator __first, _InputIterator __last,
+ const _Compare& __comp = _Compare(),
+ const _Allocator& __a = _Allocator())
+ : _Base(__first, __last, __comp, __a) { }
+#if __cplusplus >= 201103L
multimap(initializer_list<value_type> __l,
const _Compare& __c = _Compare(),
- const allocator_type& __a = allocator_type())
+ const _Allocator& __a = _Allocator())
: _Base(__l, __c, __a) { }
explicit
- multimap(const allocator_type& __a)
- : _Base(__a) { }
+ multimap(const _Allocator& __a)
+ : _Base(__a) { }
- multimap(const multimap& __x, const allocator_type& __a)
+ multimap(const multimap& __x, const _Allocator& __a)
: _Base(__x, __a) { }
- multimap(multimap&& __x, const allocator_type& __a)
- noexcept(is_nothrow_copy_constructible<_Compare>::value
- && _Alloc_traits::_S_always_equal())
+ multimap(multimap&& __x, const _Allocator& __a)
+ noexcept( noexcept(_Base(std::move(__x), __a)) )
: _Base(std::move(__x), __a) { }
- multimap(initializer_list<value_type> __l, const allocator_type& __a)
+ multimap(initializer_list<value_type> __l, const _Allocator& __a)
: _Base(__l, __a) { }
template<typename _InputIterator>
- multimap(_InputIterator __first, _InputIterator __last,
- const allocator_type& __a)
- : _Base(__first, __last, __a) { }
+ multimap(_InputIterator __first, _InputIterator __last,
+ const _Allocator& __a)
+ : _Base(__first, __last, __a) { }
#endif
multimap(const _Base& __x)
: _Base(__x) { }
- ~multimap() _GLIBCXX_NOEXCEPT { }
-
#if __cplusplus < 201103L
multimap&
operator=(const multimap& __x)
}
#endif
- using _Base::get_allocator;
-
- // iterators:
- iterator
- begin() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::begin()); }
-
- const_iterator
- begin() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::begin()); }
-
- iterator
- end() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::end()); }
-
- const_iterator
- end() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::end()); }
-
reverse_iterator
rbegin() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
const_reverse_iterator
rbegin() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
reverse_iterator
rend() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
const_reverse_iterator
rend() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
#if __cplusplus >= 201103L
- const_iterator
- cbegin() const noexcept
- { return const_iterator(_Base::begin()); }
-
- const_iterator
- cend() const noexcept
- { return const_iterator(_Base::end()); }
-
const_reverse_iterator
crbegin() const noexcept
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crbegin();
+ }
const_reverse_iterator
crend() const noexcept
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crend();
+ }
#endif
- // capacity:
- using _Base::empty;
- using _Base::size;
- using _Base::max_size;
-
// modifiers:
#if __cplusplus >= 201103L
template<typename... _Args>
iterator
emplace(_Args&&... __args)
{
- return iterator(_Base::emplace(std::forward<_Args>(__args)...));
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::emplace(std::forward<_Args>(__args)...);
}
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
- return iterator(_Base::emplace_hint(__pos,
- std::forward<_Args>(__args)...));
+ auto size_before = this->size();
+ auto __res
+ = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...);
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
}
#endif
-
+
iterator
insert(const value_type& __x)
- { return iterator(_Base::insert(__x)); }
+ {
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(__x);
+ }
#if __cplusplus >= 201103L
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- iterator
- insert(_Pair&& __x)
- { return iterator(_Base::insert(std::forward<_Pair>(__x))); }
+ iterator
+ insert(_Pair&& __x)
+ {
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(std::forward<_Pair>(__x));
+ }
#endif
#if __cplusplus >= 201103L
void
insert(std::initializer_list<value_type> __list)
- { _Base::insert(__list); }
+ { insert(__list.begin(), __list.end()); }
#endif
iterator
#if __cplusplus >= 201103L
- insert(const_iterator __position, const value_type& __x)
+ insert(const_iterator __pos, const value_type& __x)
#else
- insert(iterator __position, const value_type& __x)
+ insert(iterator __pos, const value_type& __x)
#endif
- { return iterator(_Base::insert(__position, __x)); }
+ {
+ size_type size_before = this->size();
+ iterator __res = _Base::insert(__pos, __x);
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
+ }
#if __cplusplus >= 201103L
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
- iterator
- insert(const_iterator __position, _Pair&& __x)
- { return iterator(_Base::insert(__position,
- std::forward<_Pair>(__x))); }
+ iterator
+ insert(const_iterator __pos, _Pair&& __x)
+ {
+ size_type size_before = this->size();
+ auto __res = _Base::insert(__pos, std::forward<_Pair>(__x));
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
+ }
#endif
#if __cplusplus >= 201103L
#else
template<typename _InputIterator>
#endif
- void
- insert(_InputIterator __first, _InputIterator __last)
- { _Base::insert(__first, __last); }
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ {
+ for (; __first != __last; ++__first)
+ insert(*__first);
+ }
#if __cplusplus >= 201103L
iterator
- erase(const_iterator __position)
- { return iterator(_Base::erase(__position)); }
+ erase(const_iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__pos);
+ }
iterator
- erase(iterator __position)
- { return iterator(_Base::erase(__position)); }
+ erase(iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__pos);
+ }
#else
void
- erase(iterator __position)
- { _Base::erase(__position); }
+ erase(iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ _Base::erase(__pos);
+ }
#endif
size_type
erase(const key_type& __x)
{
- std::pair<iterator, iterator> __victims = this->equal_range(__x);
- size_type __count = 0;
- while (__victims.first != __victims.second)
- {
- iterator __victim = __victims.first++;
- _Base::erase(__victim);
- ++__count;
- }
- return __count;
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__x);
}
#if __cplusplus >= 201103L
iterator
erase(const_iterator __first, const_iterator __last)
- { return iterator(_Base::erase(__first, __last)); }
+ {
+ if (__first != __last)
+ {
+ iterator __ret;
+ for (; __first != __last;)
+ __ret = erase(__first++);
+ return __ret;
+ }
+ else
+ return _Base::erase(__first, __last);
+ }
#else
void
erase(iterator __first, iterator __last)
- { _Base::erase(__first, __last); }
+ {
+ for (; __first != __last;)
+ erase(__first++);
+ }
#endif
void
swap(multimap& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{ _Base::swap(__x); }
- void
- clear() _GLIBCXX_NOEXCEPT
- { this->erase(begin(), end()); }
-
- // observers:
- using _Base::key_comp;
- using _Base::value_comp;
-
// 23.3.1.3 multimap operations:
iterator
find(const key_type& __x)
- { return iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
const_iterator
find(const key_type& __x) const
- { return const_iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
- using _Base::count;
+ size_type
+ count(const key_type& __x) const
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::count(__x);
+ }
iterator
lower_bound(const key_type& __x)
- { return iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
+ }
const_iterator
lower_bound(const key_type& __x) const
- { return const_iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
+ }
iterator
upper_bound(const key_type& __x)
- { return iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
const_iterator
upper_bound(const key_type& __x) const
- { return const_iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
std::pair<iterator,iterator>
equal_range(const key_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(iterator(__res.first),
- iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
std::pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{
- typedef typename _Base::const_iterator _Base_const_iterator;
- std::pair<_Base_const_iterator, _Base_const_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(const_iterator(__res.first),
- const_iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+ private:
+ /** If hint is used we consider that the map and unordered_map
+ * operations have equivalent insertion cost so we do not update metrics
+ * about it.
+ * Note that to find out if hint has been used is libstdc++
+ * implementation dependant.
+ */
+ bool
+ _M_hint_used(const_iterator __hint, iterator __res)
+ {
+ return (__hint == __res ||
+ (__hint == this->end() && ++__res == this->end()) ||
+ (__hint != this->end() && (++__hint == __res ||
+ ++__res == --__hint)));
+ }
};
template<typename _Key, typename _Tp,
#ifndef _GLIBCXX_PROFILE_MULTISET_H
#define _GLIBCXX_PROFILE_MULTISET_H 1
-#include <utility>
+#include <profile/base.h>
+#include <profile/ordered_base.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class multiset
- : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>
+ : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>,
+ public _Ordered_profile<multiset<_Key, _Compare, _Allocator> >
{
typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base;
-#if __cplusplus >= 201103L
- typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
-#endif
-
public:
// types:
- typedef _Key key_type;
- typedef _Key value_type;
- typedef _Compare key_compare;
- typedef _Compare value_compare;
- typedef _Allocator allocator_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;
- typedef typename _Base::reverse_iterator reverse_iterator;
- typedef typename _Base::const_reverse_iterator const_reverse_iterator;
-
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
+ typedef _Key key_type;
+ typedef _Key value_type;
+ typedef _Compare key_compare;
+ typedef _Compare value_compare;
+ typedef _Allocator allocator_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;
+ typedef typename _Base::reverse_iterator reverse_iterator;
+ typedef typename _Base::const_reverse_iterator const_reverse_iterator;
+
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
// 23.3.3.1 construct/copy/destroy:
+#if __cplusplus < 201103L
multiset()
: _Base() { }
+ multiset(const multiset& __x)
+ : _Base(__x) { }
+ ~multiset() { }
+#else
+ multiset() = default;
+ multiset(const multiset&) = default;
+ multiset(multiset&&) = default;
+ ~multiset() = default;
+#endif
explicit multiset(const _Compare& __comp,
const _Allocator& __a = _Allocator())
#else
template<typename _InputIterator>
#endif
- multiset(_InputIterator __first, _InputIterator __last,
+ multiset(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__first, __last, __comp, __a) { }
-#if __cplusplus < 201103L
- multiset(const multiset& __x)
- : _Base(__x) { }
-#else
- multiset(const multiset&) = default;
- multiset(multiset&&) = default;
-
+#if __cplusplus >= 201103L
multiset(initializer_list<value_type> __l,
const _Compare& __comp = _Compare(),
const allocator_type& __a = allocator_type())
explicit
multiset(const allocator_type& __a)
- : _Base(__a) { }
+ : _Base(__a) { }
multiset(const multiset& __x, const allocator_type& __a)
: _Base(__x, __a) { }
multiset(multiset&& __x, const allocator_type& __a)
- noexcept(is_nothrow_copy_constructible<_Compare>::value
- && _Alloc_traits::_S_always_equal())
+ noexcept( noexcept(_Base(std::move(__x), __a)) )
: _Base(std::move(__x), __a) { }
multiset(initializer_list<value_type> __l, const allocator_type& __a)
: _Base(__l, __a) { }
template<typename _InputIterator>
- multiset(_InputIterator __first, _InputIterator __last,
- const allocator_type& __a)
- : _Base(__first, __last, __a) { }
+ multiset(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a)
+ : _Base(__first, __last, __a) { }
#endif
multiset(const _Base& __x)
: _Base(__x) { }
- ~multiset() _GLIBCXX_NOEXCEPT { }
-
#if __cplusplus < 201103L
multiset&
operator=(const multiset& __x)
}
#endif
- using _Base::get_allocator;
-
// iterators:
- iterator
- begin() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::begin()); }
-
- const_iterator
- begin() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::begin()); }
-
- iterator
- end() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::end()); }
-
- const_iterator
- end() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::end()); }
-
reverse_iterator
rbegin() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
const_reverse_iterator
rbegin() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
reverse_iterator
rend() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
const_reverse_iterator
rend() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
#if __cplusplus >= 201103L
- const_iterator
- cbegin() const noexcept
- { return const_iterator(_Base::begin()); }
-
- const_iterator
- cend() const noexcept
- { return const_iterator(_Base::end()); }
-
const_reverse_iterator
crbegin() const noexcept
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crbegin();
+ }
const_reverse_iterator
crend() const noexcept
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crend();
+ }
#endif
- // capacity:
- using _Base::empty;
- using _Base::size;
- using _Base::max_size;
-
// modifiers:
#if __cplusplus >= 201103L
template<typename... _Args>
iterator
emplace(_Args&&... __args)
- { return iterator(_Base::emplace(std::forward<_Args>(__args)...)); }
+ {
+ // The cost is the same whether or not the element is inserted so we
+ // always report insertion of 1 element.
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::emplace(std::forward<_Args>(__args)...);
+ }
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
- return iterator(_Base::emplace_hint(__pos,
- std::forward<_Args>(__args)...));
+ auto size_before = this->size();
+ auto __res = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...);
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
}
#endif
iterator
insert(const value_type& __x)
- { return iterator(_Base::insert(__x)); }
+ {
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(__x);
+ }
#if __cplusplus >= 201103L
iterator
insert(value_type&& __x)
- { return iterator(_Base::insert(std::move(__x))); }
+ {
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(std::move(__x));
+ }
#endif
iterator
- insert(const_iterator __position, const value_type& __x)
- { return iterator(_Base::insert(__position, __x)); }
+ insert(const_iterator __pos, const value_type& __x)
+ {
+ size_type size_before = this->size();
+ iterator __res = _Base::insert(__pos, __x);
+
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
+ }
#if __cplusplus >= 201103L
iterator
- insert(const_iterator __position, value_type&& __x)
- { return iterator(_Base::insert(__position, std::move(__x))); }
+ insert(const_iterator __pos, value_type&& __x)
+ {
+ auto size_before = this->size();
+ auto __res = _Base::insert(__pos, std::move(__x));
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
+ }
#endif
#if __cplusplus >= 201103L
#else
template<typename _InputIterator>
#endif
- void
- insert(_InputIterator __first, _InputIterator __last)
- { _Base::insert(__first, __last); }
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ {
+ for (; __first != __last; ++__first)
+ insert(*__first);
+ }
#if __cplusplus >= 201103L
void
insert(initializer_list<value_type> __l)
- { _Base::insert(__l); }
+ { insert(__l.begin(), __l.end()); }
#endif
#if __cplusplus >= 201103L
iterator
- erase(const_iterator __position)
- { return iterator(_Base::erase(__position)); }
+ erase(const_iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__pos);
+ }
#else
void
- erase(iterator __position)
- { _Base::erase(__position); }
+ erase(iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ _Base::erase(__pos);
+ }
#endif
size_type
erase(const key_type& __x)
{
- std::pair<iterator, iterator> __victims = this->equal_range(__x);
- size_type __count = 0;
- while (__victims.first != __victims.second)
- {
- iterator __victim = __victims.first++;
- _Base::erase(__victim);
- ++__count;
- }
- return __count;
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__x);
}
#if __cplusplus >= 201103L
iterator
erase(const_iterator __first, const_iterator __last)
- { return iterator(_Base::erase(__first, __last)); }
+ {
+ if (__first != __last)
+ {
+ iterator __ret;
+ for (; __first != __last;)
+ __ret = erase(__first++);
+ return __ret;
+ }
+ else
+ return _Base::erase(__first, __last);
+ }
#else
void
erase(iterator __first, iterator __last)
- { _Base::erase(__first, __last); }
+ {
+ for (; __first != __last;)
+ erase(__first++);
+ }
#endif
void
swap(multiset& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{ _Base::swap(__x); }
- void
- clear() _GLIBCXX_NOEXCEPT
- { this->erase(begin(), end()); }
-
- // observers:
- using _Base::key_comp;
- using _Base::value_comp;
-
// multiset operations:
iterator
find(const key_type& __x)
- { return iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
const_iterator
find(const key_type& __x) const
- { return const_iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
- using _Base::count;
+ size_type
+ count(const key_type& __x) const
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::count(__x);
+ }
iterator
lower_bound(const key_type& __x)
- { return iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::lower_bound(__x);
+ }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
const_iterator
lower_bound(const key_type& __x) const
- { return const_iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
+ }
iterator
upper_bound(const key_type& __x)
- { return iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
const_iterator
upper_bound(const key_type& __x) const
- { return const_iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
std::pair<iterator,iterator>
equal_range(const key_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(iterator(__res.first),
- iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
std::pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{
- typedef typename _Base::const_iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(const_iterator(__res.first),
- const_iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
-
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+ private:
+ /** If hint is used we consider that the map and unordered_map
+ * operations have equivalent insertion cost so we do not update metrics
+ * about it.
+ * Note that to find out if hint has been used is libstdc++
+ * implementation dependant.
+ */
+ bool
+ _M_hint_used(const_iterator __hint, iterator __res)
+ {
+ return (__hint == __res ||
+ (__hint == this->end() && ++__res == this->end()) ||
+ (__hint != this->end() && (++__hint == __res ||
+ ++__res == --__hint)));
+ }
};
template<typename _Key, typename _Compare, typename _Allocator>
--- /dev/null
+// Profiling unordered containers implementation details -*- C++ -*-
+
+// Copyright (C) 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/ordered_base.h
+ * This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_ORDERED
+#define _GLIBCXX_PROFILE_ORDERED 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+ template<typename _Cont>
+ class _Ordered_profile
+ {
+ _Cont&
+ _M_conjure()
+ { return *static_cast<_Cont*>(this); }
+
+ public:
+ _Ordered_profile() _GLIBCXX_NOEXCEPT
+ { __profcxx_map_to_unordered_map_construct(&_M_conjure()); }
+
+#if __cplusplus >= 201103L
+ _Ordered_profile(const _Ordered_profile&) noexcept
+ : _Ordered_profile() { }
+ _Ordered_profile(_Ordered_profile&&) noexcept
+ : _Ordered_profile() { }
+
+ _Ordered_profile&
+ operator=(const _Ordered_profile&) = default;
+ _Ordered_profile&
+ operator=(_Ordered_profile&&) = default;
+#endif
+
+ ~_Ordered_profile()
+ { __profcxx_map_to_unordered_map_destruct(&_M_conjure()); }
+ };
+
+} // namespace __profile
+} // namespace std
+
+#endif
#ifndef _GLIBCXX_PROFILE_SET_H
#define _GLIBCXX_PROFILE_SET_H 1
-#include <utility>
+#include <profile/base.h>
+#include <profile/ordered_base.h>
-namespace std _GLIBCXX_VISIBILITY(default)
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class set
- : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>
+ : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>,
+ public _Ordered_profile<set<_Key, _Compare, _Allocator> >
{
typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base;
public:
// types:
- typedef _Key key_type;
- typedef _Key value_type;
- typedef _Compare key_compare;
- typedef _Compare value_compare;
- typedef _Allocator allocator_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;
- typedef typename _Base::reverse_iterator reverse_iterator;
- typedef typename _Base::const_reverse_iterator const_reverse_iterator;
-
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
+ typedef _Key key_type;
+ typedef _Key value_type;
+ typedef _Compare key_compare;
+ typedef _Compare value_compare;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
+
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
+ typedef typename _Base::reverse_iterator reverse_iterator;
+ typedef typename _Base::const_reverse_iterator const_reverse_iterator;
+
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
// 23.3.3.1 construct/copy/destroy:
-
+#if __cplusplus < 201103L
set()
: _Base() { }
+ set(const set& __x)
+ : _Base(__x) { }
+ ~set() { }
+#else
+ set() = default;
+ set(const set&) = default;
+ set(set&&) = default;
+ ~set() = default;
+#endif
explicit set(const _Compare& __comp,
const _Allocator& __a = _Allocator())
#else
template<typename _InputIterator>
#endif
- set(_InputIterator __first, _InputIterator __last,
+ set(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__first, __last, __comp, __a) { }
-#if __cplusplus < 201103L
- set(const set& __x)
- : _Base(__x) { }
-#else
- set(const set&) = default;
- set(set&&) = default;
-
+#if __cplusplus >= 201103L
set(initializer_list<value_type> __l,
const _Compare& __comp = _Compare(),
- const allocator_type& __a = allocator_type())
+ const _Allocator& __a = _Allocator())
: _Base(__l, __comp, __a) { }
explicit
- set(const allocator_type& __a)
- : _Base(__a) { }
+ set(const _Allocator& __a)
+ : _Base(__a) { }
- set(const set& __x, const allocator_type& __a)
+ set(const set& __x, const _Allocator& __a)
: _Base(__x, __a) { }
- set(set&& __x, const allocator_type& __a)
- noexcept(is_nothrow_copy_constructible<_Compare>::value
- && _Alloc_traits::_S_always_equal())
+ set(set&& __x, const _Allocator& __a)
+ noexcept( noexcept(_Base(std::move(__x), __a)) )
: _Base(std::move(__x), __a) { }
- set(initializer_list<value_type> __l, const allocator_type& __a)
+ set(initializer_list<value_type> __l, const _Allocator& __a)
: _Base(__l, __a) { }
template<typename _InputIterator>
- set(_InputIterator __first, _InputIterator __last,
- const allocator_type& __a)
- : _Base(__first, __last, __a) { }
+ set(_InputIterator __first, _InputIterator __last,
+ const _Allocator& __a)
+ : _Base(__first, __last, __a) { }
#endif
set(const _Base& __x)
: _Base(__x) { }
- ~set() _GLIBCXX_NOEXCEPT { }
-
#if __cplusplus < 201103L
set&
operator=(const set& __x)
}
#endif
- using _Base::get_allocator;
-
- // iterators:
- iterator
- begin() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::begin()); }
-
- const_iterator
- begin() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::begin()); }
-
- iterator
- end() _GLIBCXX_NOEXCEPT
- { return iterator(_Base::end()); }
-
- const_iterator
- end() const _GLIBCXX_NOEXCEPT
- { return const_iterator(_Base::end()); }
-
reverse_iterator
rbegin() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
const_reverse_iterator
rbegin() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rbegin();
+ }
reverse_iterator
rend() _GLIBCXX_NOEXCEPT
- { return reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
const_reverse_iterator
rend() const _GLIBCXX_NOEXCEPT
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::rend();
+ }
#if __cplusplus >= 201103L
- const_iterator
- cbegin() const noexcept
- { return const_iterator(_Base::begin()); }
-
- const_iterator
- cend() const noexcept
- { return const_iterator(_Base::end()); }
-
const_reverse_iterator
crbegin() const noexcept
- { return const_reverse_iterator(end()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crbegin();
+ }
const_reverse_iterator
crend() const noexcept
- { return const_reverse_iterator(begin()); }
+ {
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::crend();
+ }
#endif
- // capacity:
- using _Base::empty;
- using _Base::size;
- using _Base::max_size;
-
// modifiers:
#if __cplusplus >= 201103L
template<typename... _Args>
std::pair<iterator, bool>
emplace(_Args&&... __args)
{
- auto __res = _Base::emplace(std::forward<_Args>(__args)...);
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::emplace(std::forward<_Args>(__args)...);
}
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
- return iterator(_Base::emplace_hint(__pos,
- std::forward<_Args>(__args)...));
+ auto size_before = this->size();
+ auto __res
+ = _Base::emplace_hint(__pos, std::forward<_Args>(__args)...);
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
}
#endif
std::pair<iterator, bool>
insert(const value_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(__x);
}
#if __cplusplus >= 201103L
std::pair<iterator, bool>
insert(value_type&& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, bool> __res
- = _Base::insert(std::move(__x));
- return std::pair<iterator, bool>(iterator(__res.first),
- __res.second);
+ __profcxx_map_to_unordered_map_insert(this, this->size(), 1);
+ return _Base::insert(std::move(__x));
}
#endif
iterator
- insert(const_iterator __position, const value_type& __x)
- { return iterator(_Base::insert(__position, __x)); }
+ insert(const_iterator __pos, const value_type& __x)
+ {
+ size_type size_before = this->size();
+ iterator __res = _Base::insert(__pos, __x);
+ __profcxx_map_to_unordered_map_insert(this, size_before,
+ _M_hint_used(__pos, __res) ? 0 : 1);
+ return __res;
+ }
#if __cplusplus >= 201103L
iterator
#else
template<typename _InputIterator>
#endif
- void
- insert(_InputIterator __first, _InputIterator __last)
- { _Base::insert(__first, __last); }
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ {
+ for (; __first != __last; ++__first)
+ insert(*__first);
+ }
#if __cplusplus >= 201103L
void
insert(initializer_list<value_type> __l)
- { _Base::insert(__l); }
+ { insert(__l.begin(), __l.end()); }
#endif
#if __cplusplus >= 201103L
iterator
- erase(const_iterator __position)
- { return iterator(_Base::erase(__position)); }
+ erase(const_iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__pos);
+ }
#else
void
- erase(iterator __position)
- { _Base::erase(__position); }
+ erase(iterator __pos)
+ {
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ _Base::erase(__pos);
+ }
#endif
size_type
erase(const key_type& __x)
{
- iterator __victim = find(__x);
- if (__victim == end())
- return 0;
- else
- {
- _Base::erase(__victim);
- return 1;
- }
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_erase(this, this->size(), 1);
+ return _Base::erase(__x);
}
#if __cplusplus >= 201103L
iterator
erase(const_iterator __first, const_iterator __last)
- { return iterator(_Base::erase(__first, __last)); }
+ {
+ if (__first != __last)
+ {
+ iterator __ret;
+ for (; __first != __last;)
+ __ret = erase(__first++);
+ return __ret;
+ }
+
+ return _Base::erase(__first, __last);
+ }
#else
void
erase(iterator __first, iterator __last)
- { _Base::erase(__first, __last); }
+ {
+ for (; __first != __last;)
+ erase(__first++);
+ }
#endif
void
swap(set& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{ _Base::swap(__x); }
- void
- clear() _GLIBCXX_NOEXCEPT
- { this->erase(begin(), end()); }
-
- // observers:
- using _Base::key_comp;
- using _Base::value_comp;
-
// set operations:
iterator
find(const key_type& __x)
- { return iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 214. set::find() missing const overload
const_iterator
find(const key_type& __x) const
- { return const_iterator(_Base::find(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::find(__x);
+ }
- using _Base::count;
+ size_type
+ count(const key_type& __x) const
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::count(__x);
+ }
iterator
lower_bound(const key_type& __x)
- { return iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
+ }
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 214. set::find() missing const overload
const_iterator
lower_bound(const key_type& __x) const
- { return const_iterator(_Base::lower_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::lower_bound(__x);
+ }
iterator
upper_bound(const key_type& __x)
- { return iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 214. set::find() missing const overload
const_iterator
upper_bound(const key_type& __x) const
- { return const_iterator(_Base::upper_bound(__x)); }
+ {
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ __profcxx_map_to_unordered_map_invalidate(this);
+ return _Base::upper_bound(__x);
+ }
- std::pair<iterator,iterator>
+ std::pair<iterator, iterator>
equal_range(const key_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(iterator(__res.first),
- iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 214. set::find() missing const overload
- std::pair<const_iterator,const_iterator>
+ std::pair<const_iterator, const_iterator>
equal_range(const key_type& __x) const
{
- typedef typename _Base::const_iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
- return std::make_pair(const_iterator(__res.first),
- const_iterator(__res.second));
+ __profcxx_map_to_unordered_map_find(this, this->size());
+ return _Base::equal_range(__x);
}
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
-
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+
+ private:
+ /** If hint is used we consider that the map and unordered_map
+ * operations have equivalent insertion cost so we do not update metrics
+ * about it.
+ * Note that to find out if hint has been used is libstdc++
+ * implementation dependant.
+ */
+ bool
+ _M_hint_used(const_iterator __hint, iterator __res)
+ {
+ return (__hint == __res ||
+ (__hint == this->end() && ++__res == this->end()) ||
+ (__hint != this->end() && (++__hint == __res ||
+ ++__res == --__hint)));
+ }
};
template<typename _Key, typename _Compare, typename _Allocator>
_Unordered_profile()
{
auto& __uc = _M_conjure();
- __profcxx_hashtable_construct(&__uc, __uc.bucket_count());
+ __profcxx_hashtable_construct(&__uc, __uc.bucket_count());
__profcxx_hashtable_construct2(&__uc);
}
_Unordered_profile(const _Unordered_profile&)
~_Unordered_profile() noexcept
{
auto& __uc = _M_conjure();
- __profcxx_hashtable_destruct(&__uc, __uc.bucket_count(), __uc.size());
- _M_profile_destruct();
+ __profcxx_hashtable_destruct(&__uc, __uc.bucket_count(), __uc.size());
+ _M_profile_destruct();
}
_Unordered_profile&
auto __lend = __uc.end(__bkt);
for (++__it, ++__lit; __lit != __lend; ++__it, ++__lit)
++__chain;
+
if (__chain)
{
++__chain;
__pit = __it;
}
}
+
if (__chain)
{
++__chain;
typedef typename _GLIBCXX_STD_BASE _Base;
_Base&
- _M_base() noexcept { return *this; }
+ _M_base() noexcept { return *this; }
const _Base&
- _M_base() const noexcept { return *this; }
+ _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;
+ 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)
- { }
+ : _Base(__n, __hf, __eql, __a) { }
template<typename _InputIterator>
- unordered_map(_InputIterator __f, _InputIterator __l,
+ 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)
- { }
+ : _Base(__f, __l, __n, __hf, __eql, __a) { }
unordered_map(const unordered_map&) = default;
unordered_map(const _Base& __x)
- : _Base(__x)
- { }
+ : _Base(__x) { }
unordered_map(unordered_map&&) = default;
explicit
unordered_map(const allocator_type& __a)
- : _Base(__a)
- { }
+ : _Base(__a) { }
unordered_map(const unordered_map& __umap,
const allocator_type& __a)
- : _Base(__umap, __a)
- { }
+ : _Base(__umap, __a) { }
unordered_map(unordered_map&& __umap,
const allocator_type& __a)
- : _Base(std::move(__umap._M_base()), __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)
- { }
+ : _Base(__l, __n, __hf, __eql, __a) { }
unordered_map&
operator=(const unordered_map&) = default;
void
clear() noexcept
{
- __profcxx_hashtable_destruct(this, _Base::bucket_count(),
+ __profcxx_hashtable_destruct(this, _Base::bucket_count(),
_Base::size());
- this->_M_profile_destruct();
+ this->_M_profile_destruct();
_Base::clear();
}
void
insert(std::initializer_list<value_type> __l)
- {
- size_type __old_size = _Base::bucket_count();
- _Base::insert(__l);
- _M_profile_resize(__old_size);
+ {
+ 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;
+ 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;
+ {
+ 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)
- {
+ 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);
+ _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
+ 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);
+ _M_profile_resize(__old_size);
return __res;
}
template<typename _InputIter>
- void
- insert(_InputIter __first, _InputIter __last)
- {
- size_type __old_size = _Base::bucket_count();
+ void
+ insert(_InputIter __first, _InputIter __last)
+ {
+ size_type __old_size = _Base::bucket_count();
_Base::insert(__first, __last);
- _M_profile_resize(__old_size);
+ _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;
+ 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;
+ size_type __old_size = _Base::bucket_count();
+ mapped_type& __res = _M_base()[std::move(__k)];
+ _M_profile_resize(__old_size);
+ return __res;
}
void
{
size_type __old_size = _Base::bucket_count();
_Base::rehash(__n);
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
}
private:
public _Unordered_profile<unordered_multimap<_Key, _Tp,
_Hash, _Pred, _Alloc>,
false>
- {
+ {
typedef typename _GLIBCXX_STD_BASE _Base;
_Base&
- _M_base() noexcept { return *this; }
+ _M_base() noexcept { return *this; }
const _Base&
- _M_base() const noexcept { return *this; }
+ _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;
+ 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)
- { }
+ : _Base(__n, __hf, __eql, __a) { }
template<typename _InputIterator>
- unordered_multimap(_InputIterator __f, _InputIterator __l,
+ 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)
- { }
+ : _Base(__f, __l, __n, __hf, __eql, __a) { }
unordered_multimap(const unordered_multimap&) = default;
unordered_multimap(const _Base& __x)
- : _Base(__x)
- { }
+ : _Base(__x) { }
unordered_multimap(unordered_multimap&&) = default;
explicit
unordered_multimap(const allocator_type& __a)
- : _Base(__a)
- { }
+ : _Base(__a) { }
unordered_multimap(const unordered_multimap& __ummap,
const allocator_type& __a)
- : _Base(__ummap._M_base(), __a)
- { }
+ : _Base(__ummap._M_base(), __a) { }
unordered_multimap(unordered_multimap&& __ummap,
const allocator_type& __a)
- : _Base(std::move(__ummap._M_base()), __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)
- { }
+ : _Base(__l, __n, __hf, __eql, __a) { }
unordered_multimap&
operator=(const unordered_multimap&) = default;
void
clear() noexcept
{
- __profcxx_hashtable_destruct(this, _Base::bucket_count(),
+ __profcxx_hashtable_destruct(this, _Base::bucket_count(),
_Base::size());
this->_M_profile_destruct();
_Base::clear();
void
insert(std::initializer_list<value_type> __l)
- {
- size_type __old_size = _Base::bucket_count();
- _Base::insert(__l);
- _M_profile_resize(__old_size);
+ {
+ 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;
+ 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;
+ {
+ 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)
- {
+ iterator
+ insert(_Pair&& __obj)
+ {
size_type __old_size = _Base::bucket_count();
iterator __res = _Base::insert(std::forward<_Pair>(__obj));
- _M_profile_resize(__old_size);
+ _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
+ 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);
+ _M_profile_resize(__old_size);
return __res;
}
template<typename _InputIter>
- void
- insert(_InputIter __first, _InputIter __last)
- {
- size_type __old_size = _Base::bucket_count();
+ void
+ insert(_InputIter __first, _InputIter __last)
+ {
+ size_type __old_size = _Base::bucket_count();
_Base::insert(__first, __last);
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
}
void
void
rehash(size_type __n)
{
- size_type __old_size = _Base::bucket_count();
- _Base::rehash(__n);
- _M_profile_resize(__old_size);
+ size_type __old_size = _Base::bucket_count();
+ _Base::rehash(__n);
+ _M_profile_resize(__old_size);
}
private:
_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);
+ if (__old_size != __new_size)
+ __profcxx_hashtable_resize(this, __old_size, __new_size);
}
};
namespace __profile
{
/** @brief Unordered_set wrapper with performance instrumentation. */
- template<typename _Key,
+ template<typename _Key,
typename _Hash = std::hash<_Key>,
typename _Pred = std::equal_to<_Key>,
typename _Alloc = std::allocator<_Key> >
_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;
+ 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_set(size_type __n = 10,
{ }
template<typename _InputIterator>
- unordered_set(_InputIterator __f, _InputIterator __l,
+ unordered_set(_InputIterator __f, _InputIterator __l,
size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
void
clear() noexcept
{
- __profcxx_hashtable_destruct(this, _Base::bucket_count(),
- _Base::size());
- this->_M_profile_destruct();
- _Base::clear();
+ __profcxx_hashtable_destruct(this, _Base::bucket_count(),
+ _Base::size());
+ this->_M_profile_destruct();
+ _Base::clear();
}
template<typename... _Args>
void
insert(std::initializer_list<value_type> __l)
- {
- size_type __old_size = _Base::bucket_count();
- _Base::insert(__l);
- _M_profile_resize(__old_size);
+ {
+ 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;
+ 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;
+ {
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__iter, __v);
+ _M_profile_resize(__old_size);
+ return __res;
}
std::pair<iterator, bool>
insert(value_type&& __obj)
{
- size_type __old_size = _Base::bucket_count();
- std::pair<iterator, bool> __res = _Base::insert(std::move(__obj));
- _M_profile_resize(__old_size);
- return __res;
+ size_type __old_size = _Base::bucket_count();
+ std::pair<iterator, bool> __res = _Base::insert(std::move(__obj));
+ _M_profile_resize(__old_size);
+ return __res;
}
iterator
insert(const_iterator __iter, value_type&& __v)
- {
- size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(__iter, std::move(__v));
- _M_profile_resize(__old_size);
- return __res;
+ {
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__iter, std::move(__v));
+ _M_profile_resize(__old_size);
+ return __res;
}
template<typename _InputIter>
- void
- insert(_InputIter __first, _InputIter __last)
- {
- size_type __old_size = _Base::bucket_count();
+ void
+ insert(_InputIter __first, _InputIter __last)
+ {
+ size_type __old_size = _Base::bucket_count();
_Base::insert(__first, __last);
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
}
void
rehash(size_type __n)
{
- size_type __old_size = _Base::bucket_count();
- _Base::rehash(__n);
- _M_profile_resize(__old_size);
+ size_type __old_size = _Base::bucket_count();
+ _Base::rehash(__n);
+ _M_profile_resize(__old_size);
}
private:
public:
typedef typename _Base::size_type size_type;
- typedef typename _Base::hasher hasher;
+ 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::key_type key_type;
typedef typename _Base::value_type value_type;
typedef typename _Base::difference_type difference_type;
typedef typename _Base::reference reference;
{ }
template<typename _InputIterator>
- unordered_multiset(_InputIterator __f, _InputIterator __l,
+ unordered_multiset(_InputIterator __f, _InputIterator __l,
size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
void
clear() noexcept
{
- __profcxx_hashtable_destruct(this, _Base::bucket_count(),
- _Base::size());
- this->_M_profile_destruct();
- _Base::clear();
+ __profcxx_hashtable_destruct(this, _Base::bucket_count(),
+ _Base::size());
+ this->_M_profile_destruct();
+ _Base::clear();
}
template<typename... _Args>
void
insert(std::initializer_list<value_type> __l)
- {
- size_type __old_size = _Base::bucket_count();
- _Base::insert(__l);
- _M_profile_resize(__old_size);
+ {
+ 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;
+ 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;
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__iter, __v);
+ _M_profile_resize(__old_size);
+ return __res;
}
iterator
insert(value_type&& __obj)
{
size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(std::move(__obj));
- _M_profile_resize(__old_size);
- return __res;
+ iterator __res = _Base::insert(std::move(__obj));
+ _M_profile_resize(__old_size);
+ return __res;
}
iterator
insert(const_iterator __iter, value_type&& __v)
{
- size_type __old_size = _Base::bucket_count();
- iterator __res = _Base::insert(__iter, std::move(__v));
- _M_profile_resize(__old_size);
- return __res;
+ size_type __old_size = _Base::bucket_count();
+ iterator __res = _Base::insert(__iter, std::move(__v));
+ _M_profile_resize(__old_size);
+ return __res;
}
template<typename _InputIter>
- void
- insert(_InputIter __first, _InputIter __last)
- {
- size_type __old_size = _Base::bucket_count();
+ void
+ insert(_InputIter __first, _InputIter __last)
+ {
+ size_type __old_size = _Base::bucket_count();
_Base::insert(__first, __last);
- _M_profile_resize(__old_size);
+ _M_profile_resize(__old_size);
}
void
rehash(size_type __n)
{
- size_type __old_size = _Base::bucket_count();
- _Base::rehash(__n);
- _M_profile_resize(__old_size);
+ size_type __old_size = _Base::bucket_count();
+ _Base::rehash(__n);
+ _M_profile_resize(__old_size);
}
private:
_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);
+ if (__old_size != __new_size)
+ __profcxx_hashtable_resize(this, __old_size, __new_size);
}
};
{
namespace __profile
{
- template<typename _Tp,
- typename _Allocator = std::allocator<_Tp> >
- class vector
- : public _GLIBCXX_STD_C::vector<_Tp, _Allocator>
+ template<typename _Vector>
+ class _Vector_profile_pre
{
- typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base;
+ _Vector&
+ _M_conjure()
+ { return *static_cast<_Vector*>(this); }
+
+ public:
+#if __cplusplus >= 201103L
+ _Vector_profile_pre() = default;
+ _Vector_profile_pre(const _Vector_profile_pre&) = default;
+ _Vector_profile_pre(_Vector_profile_pre&&) = default;
+
+ _Vector_profile_pre&
+ operator=(const _Vector_profile_pre&) = default;
- typedef typename _Base::iterator _Base_iterator;
- typedef typename _Base::const_iterator _Base_const_iterator;
+ _Vector_profile_pre&
+ operator=(_Vector_profile_pre&&) noexcept
+ { _M_profile_destruct(); }
+#endif
+
+ void
+ _M_profile_destruct()
+ {
+ __profcxx_vector_destruct2(&_M_conjure());
+ __profcxx_vector_destruct(&_M_conjure(),
+ _M_conjure().capacity(), _M_conjure().size());
+ }
+ };
+
+ template<typename _Vector>
+ class _Vector_profile_post
+ {
+ _Vector&
+ _M_conjure()
+ { return *static_cast<_Vector*>(this); }
+
+ protected:
+ _Vector_profile_post() _GLIBCXX_NOEXCEPT
+ {
+ __profcxx_vector_construct(&_M_conjure(), _M_conjure().capacity());
+ __profcxx_vector_construct2(&_M_conjure());
+ }
#if __cplusplus >= 201103L
- typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
+ _Vector_profile_post(const _Vector_profile_post&) noexcept
+ : _Vector_profile_post() { }
+ _Vector_profile_post(_Vector_profile_post&&) noexcept
+ : _Vector_profile_post() { }
+
+ _Vector_profile_post&
+ operator=(const _Vector_profile_post&) = default;
+ _Vector_profile_post&
+ operator=(_Vector_profile_post&&) = default;
#endif
+ ~_Vector_profile_post()
+ { _M_conjure()._M_profile_destruct(); }
+ };
+
+ template<typename _Tp,
+ typename _Allocator = std::allocator<_Tp> >
+ class vector
+ : public _Vector_profile_pre<vector<_Tp, _Allocator> >,
+ public _GLIBCXX_STD_C::vector<_Tp, _Allocator>,
+ public _Vector_profile_post<vector<_Tp, _Allocator> >
+ {
+ typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base;
+
+ typedef typename _Base::iterator _Base_iterator;
+ typedef typename _Base::const_iterator _Base_const_iterator;
+
public:
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
typedef __iterator_tracker<_Base_iterator, vector>
- iterator;
+ iterator;
typedef __iterator_tracker<_Base_const_iterator, vector>
- const_iterator;
-
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
-
- typedef _Tp value_type;
- typedef _Allocator allocator_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
+ const_iterator;
+
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
+
+ typedef _Tp value_type;
+ typedef _Allocator allocator_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
_Base&
- _M_base() _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() _GLIBCXX_NOEXCEPT { return *this; }
const _Base&
- _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+ _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
// 23.2.4.1 construct/copy/destroy:
- vector() _GLIBCXX_NOEXCEPT
- : _Base()
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+#if __cplusplus < 201103L
+ vector()
+ { }
+
+ vector(const vector& __x)
+ : _Base(__x) { }
+#else
+ vector() = default;
+ vector(const vector&) = default;
+ vector(vector&&) = default;
+#endif
explicit
vector(const _Allocator& __a) _GLIBCXX_NOEXCEPT
- : _Base(__a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__a) { }
#if __cplusplus >= 201103L
explicit
vector(size_type __n, const _Allocator& __a = _Allocator())
- : _Base(__n, __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__n, __a) { }
vector(size_type __n, const _Tp& __value,
const _Allocator& __a = _Allocator())
- : _Base(__n, __value, __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__n, __value, __a) { }
#else
explicit
vector(size_type __n, const _Tp& __value = _Tp(),
const _Allocator& __a = _Allocator())
- : _Base(__n, __value, __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__n, __value, __a) { }
#endif
#if __cplusplus >= 201103L
#else
template<typename _InputIterator>
#endif
- vector(_InputIterator __first, _InputIterator __last,
+ vector(_InputIterator __first, _InputIterator __last,
const _Allocator& __a = _Allocator())
- : _Base(__first, __last, __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__first, __last, __a) { }
- vector(const vector& __x)
- : _Base(__x)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
-
- /// Construction from a release-mode vector
+ /// Construction from a normal-mode vector
vector(const _Base& __x)
- : _Base(__x)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__x) { }
#if __cplusplus >= 201103L
- vector(vector&& __x) noexcept
- : _Base(std::move(__x))
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
-
vector(const _Base& __x, const _Allocator& __a)
- : _Base(__x, __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(__x, __a) { }
vector(vector&& __x, const _Allocator& __a)
- : _Base(std::move(__x), __a)
- {
- __profcxx_vector_construct(this, this->capacity());
- __profcxx_vector_construct2(this);
- }
+ : _Base(std::move(__x), __a) { }
vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__l, __a) { }
#endif
- ~vector() _GLIBCXX_NOEXCEPT
- {
- __profcxx_vector_destruct(this, this->capacity(), this->size());
- __profcxx_vector_destruct2(this);
- }
-
+#if __cplusplus < 201103L
vector&
operator=(const vector& __x)
{
- static_cast<_Base&>(*this) = __x;
- return *this;
+ _M_base() = __x;
+ return *this;
}
+#else
+ vector&
+ operator=(const vector&) = default;
-#if __cplusplus >= 201103L
vector&
- operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
- {
- __profcxx_vector_destruct(this, this->capacity(), this->size());
- __profcxx_vector_destruct2(this);
- static_cast<_Base&>(*this) = std::move(__x);
- return *this;
- }
+ operator=(vector&&) = default;
vector&
operator=(initializer_list<value_type> __l)
{
- static_cast<_Base&>(*this) = __l;
+ _M_base() = __l;
return *this;
}
#endif
- using _Base::assign;
- using _Base::get_allocator;
-
-
// iterators:
iterator
begin() _GLIBCXX_NOEXCEPT
#endif
// 23.2.4.2 capacity:
- using _Base::size;
- using _Base::max_size;
#if __cplusplus >= 201103L
void
resize(size_type __sz)
{
- __profcxx_vector_invalid_operator(this);
- _M_profile_resize(this, this->capacity(), __sz);
- _Base::resize(__sz);
+ __profcxx_vector_invalid_operator(this);
+ _M_profile_resize(this->capacity(), __sz);
+ _Base::resize(__sz);
}
void
resize(size_type __sz, const _Tp& __c)
{
- __profcxx_vector_invalid_operator(this);
- _M_profile_resize(this, this->capacity(), __sz);
- _Base::resize(__sz, __c);
+ __profcxx_vector_invalid_operator(this);
+ _M_profile_resize(this->capacity(), __sz);
+ _Base::resize(__sz, __c);
}
#else
void
resize(size_type __sz, _Tp __c = _Tp())
{
- __profcxx_vector_invalid_operator(this);
- _M_profile_resize(this, this->capacity(), __sz);
- _Base::resize(__sz, __c);
+ __profcxx_vector_invalid_operator(this);
+ _M_profile_resize(this->capacity(), __sz);
+ _Base::resize(__sz, __c);
}
#endif
-#if __cplusplus >= 201103L
- using _Base::shrink_to_fit;
-#endif
-
- using _Base::empty;
-
// element access:
reference
operator[](size_type __n) _GLIBCXX_NOEXCEPT
{
- __profcxx_vector_invalid_operator(this);
- return _M_base()[__n];
+ __profcxx_vector_invalid_operator(this);
+ return _M_base()[__n];
}
const_reference
operator[](size_type __n) const _GLIBCXX_NOEXCEPT
{
- __profcxx_vector_invalid_operator(this);
- return _M_base()[__n];
- }
-
- using _Base::at;
-
- reference
- front() _GLIBCXX_NOEXCEPT
- {
- return _Base::front();
- }
-
- const_reference
- front() const _GLIBCXX_NOEXCEPT
- {
- return _Base::front();
+ __profcxx_vector_invalid_operator(this);
+ return _M_base()[__n];
}
- reference
- back() _GLIBCXX_NOEXCEPT
- {
- return _Base::back();
- }
-
- const_reference
- back() const _GLIBCXX_NOEXCEPT
- {
- return _Base::back();
- }
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // DR 464. Suggestion for new member functions in standard containers.
- using _Base::data;
-
// 23.2.4.3 modifiers:
void
push_back(const _Tp& __x)
{
- size_type __old_size = this->capacity();
+ size_type __old_size = this->capacity();
_Base::push_back(__x);
- _M_profile_resize(this, __old_size, this->capacity());
+ _M_profile_resize(__old_size, this->capacity());
}
#if __cplusplus >= 201103L
void
push_back(_Tp&& __x)
{
- size_type __old_size = this->capacity();
- _Base::push_back(std::move(__x));
- _M_profile_resize(this, __old_size, this->capacity());
+ size_type __old_size = this->capacity();
+ _Base::push_back(std::move(__x));
+ _M_profile_resize(__old_size, this->capacity());
}
#endif
iterator
#if __cplusplus >= 201103L
- insert(const_iterator __position, const _Tp& __x)
+ insert(const_iterator __pos, const _Tp& __x)
#else
- insert(iterator __position, const _Tp& __x)
+ insert(iterator __pos, const _Tp& __x)
#endif
{
- __profcxx_vector_insert(this, __position.base() - _Base::begin(),
- this->size());
- size_type __old_size = this->capacity();
- _Base_iterator __res = _Base::insert(__position.base(), __x);
- _M_profile_resize(this, __old_size, this->capacity());
+ __profcxx_vector_insert(this, __pos.base() - _Base::begin(),
+ this->size());
+ size_type __old_size = this->capacity();
+ _Base_iterator __res = _Base::insert(__pos.base(), __x);
+ _M_profile_resize(__old_size, this->capacity());
return iterator(__res, this);
}
#if __cplusplus >= 201103L
iterator
- insert(const_iterator __position, _Tp&& __x)
+ insert(const_iterator __pos, _Tp&& __x)
{
- __profcxx_vector_insert(this, __position.base() - _Base::cbegin(),
- this->size());
- size_type __old_size = this->capacity();
- _Base_iterator __res = _Base::insert(__position.base(), __x);
- _M_profile_resize(this, __old_size, this->capacity());
+ __profcxx_vector_insert(this, __pos.base() - _Base::cbegin(),
+ this->size());
+ size_type __old_size = this->capacity();
+ _Base_iterator __res = _Base::insert(__pos.base(), __x);
+ _M_profile_resize(__old_size, this->capacity());
return iterator(__res, this);
}
template<typename... _Args>
- iterator
- emplace(const_iterator __position, _Args&&... __args)
- {
- _Base_iterator __res = _Base::emplace(__position.base(),
+ iterator
+ emplace(const_iterator __pos, _Args&&... __args)
+ {
+ _Base_iterator __res = _Base::emplace(__pos.base(),
std::forward<_Args>(__args)...);
return iterator(__res, this);
}
iterator
- insert(const_iterator __position, initializer_list<value_type> __l)
- { return this->insert(__position, __l.begin(), __l.end()); }
-#endif
-
-#if __cplusplus >= 201103L
- void
- swap(vector&& __x)
- {
- _Base::swap(__x);
- }
+ insert(const_iterator __pos, initializer_list<value_type> __l)
+ { return this->insert(__pos, __l.begin(), __l.end()); }
#endif
void
swap(vector& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
- {
- _Base::swap(__x);
- }
+ { _Base::swap(__x); }
#if __cplusplus >= 201103L
iterator
- insert(const_iterator __position, size_type __n, const _Tp& __x)
+ insert(const_iterator __pos, size_type __n, const _Tp& __x)
{
- __profcxx_vector_insert(this, __position.base() - _Base::cbegin(),
- this->size());
- size_type __old_size = this->capacity();
- _Base_iterator __res = _Base::insert(__position, __n, __x);
- _M_profile_resize(this, __old_size, this->capacity());
+ __profcxx_vector_insert(this, __pos.base() - _Base::cbegin(),
+ this->size());
+ size_type __old_size = this->capacity();
+ _Base_iterator __res = _Base::insert(__pos, __n, __x);
+ _M_profile_resize(__old_size, this->capacity());
return iterator(__res, this);
}
#else
void
- insert(iterator __position, size_type __n, const _Tp& __x)
+ insert(iterator __pos, size_type __n, const _Tp& __x)
{
- __profcxx_vector_insert(this, __position.base() - _Base::begin(),
- this->size());
- size_type __old_size = this->capacity();
- _Base::insert(__position, __n, __x);
- _M_profile_resize(this, __old_size, this->capacity());
+ __profcxx_vector_insert(this, __pos.base() - _Base::begin(),
+ this->size());
+ size_type __old_size = this->capacity();
+ _Base::insert(__pos, __n, __x);
+ _M_profile_resize(__old_size, this->capacity());
}
#endif
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
- insert(const_iterator __position,
+ insert(const_iterator __pos,
_InputIterator __first, _InputIterator __last)
- {
- __profcxx_vector_insert(this, __position.base() - _Base::cbegin(),
+ {
+ __profcxx_vector_insert(this, __pos.base() - _Base::cbegin(),
this->size());
size_type __old_size = this->capacity();
- _Base_iterator __res = _Base::insert(__position, __first, __last);
- _M_profile_resize(this, __old_size, this->capacity());
+ _Base_iterator __res = _Base::insert(__pos, __first, __last);
+ _M_profile_resize(__old_size, this->capacity());
return iterator(__res, this);
}
#else
template<typename _InputIterator>
void
- insert(iterator __position,
+ insert(iterator __pos,
_InputIterator __first, _InputIterator __last)
- {
- __profcxx_vector_insert(this, __position.base() - _Base::begin(),
+ {
+ __profcxx_vector_insert(this, __pos.base() - _Base::begin(),
this->size());
size_type __old_size = this->capacity();
- _Base::insert(__position, __first, __last);
- _M_profile_resize(this, __old_size, this->capacity());
+ _Base::insert(__pos, __first, __last);
+ _M_profile_resize(__old_size, this->capacity());
}
#endif
iterator
#if __cplusplus >= 201103L
- erase(const_iterator __position)
+ erase(const_iterator __pos)
#else
- erase(iterator __position)
+ erase(iterator __pos)
#endif
- {
- _Base_iterator __res = _Base::erase(__position.base());
- return iterator(__res, this);
- }
+ { return iterator(_Base::erase(__pos.base()), this); }
iterator
#if __cplusplus >= 201103L
#else
erase(iterator __first, iterator __last)
#endif
- {
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 151. can't currently clear() empty container
- _Base_iterator __res = _Base::erase(__first.base(), __last.base());
- return iterator(__res, this);
- }
+ { return iterator(_Base::erase(__first.base(), __last.base()), this); }
void
clear() _GLIBCXX_NOEXCEPT
{
- __profcxx_vector_destruct(this, this->capacity(), this->size());
- __profcxx_vector_destruct2(this);
- _Base::clear();
+ this->_M_profile_destruct();
+ _Base::clear();
}
- inline void _M_profile_find() const
- {
- __profcxx_vector_find(this, size());
- }
+ inline void _M_profile_find() const
+ { __profcxx_vector_find(this, this->size()); }
- inline void _M_profile_iterate(int __rewind = 0) const
- {
- __profcxx_vector_iterate(this);
- }
+ inline void _M_profile_iterate(int __rewind = 0) const
+ { __profcxx_vector_iterate(this); }
private:
- void _M_profile_resize(void* obj, size_type __old_size,
- size_type __new_size)
+ void _M_profile_resize(size_type __old_size, size_type __new_size)
{
- if (__old_size < __new_size) {
- __profcxx_vector_resize(this, this->size(), __new_size);
- __profcxx_vector_resize2(this, this->size(), __new_size);
- }
+ if (__old_size < __new_size)
+ {
+ __profcxx_vector_resize(this, this->size(), __new_size);
+ __profcxx_vector_resize2(this, this->size(), __new_size);
+ }
}
};
template<typename _Tp, typename _Alloc>
inline bool
operator==(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() == __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator!=(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() != __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator<(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() < __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator<=(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() <= __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator>=(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() >= __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
operator>(const vector<_Tp, _Alloc>& __lhs,
- const vector<_Tp, _Alloc>& __rhs)
+ const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() > __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
projects / gcc.git / commitdiff