aboutsummaryrefslogtreecommitdiff
path: root/libstdc++-v3/include/profile/map.h
diff options
context:
space:
mode:
Diffstat (limited to 'libstdc++-v3/include/profile/map.h')
-rw-r--r--libstdc++-v3/include/profile/map.h412
1 files changed, 180 insertions, 232 deletions
diff --git a/libstdc++-v3/include/profile/map.h b/libstdc++-v3/include/profile/map.h
index 6a3160b8e6b..cc0f5bb05dc 100644
--- a/libstdc++-v3/include/profile/map.h
+++ b/libstdc++-v3/include/profile/map.h
@@ -28,8 +28,8 @@
#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)
{
@@ -39,44 +39,47 @@ namespace __profile
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,
@@ -84,61 +87,40 @@ namespace __profile
#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)
@@ -161,113 +143,79 @@ namespace __profile
}
#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:
@@ -276,21 +224,20 @@ namespace __profile
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
@@ -298,67 +245,56 @@ namespace __profile
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
@@ -368,151 +304,163 @@ namespace __profile
#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 dependent.
+ */
+ 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,
@@ -520,10 +468,10 @@ namespace __profile
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,
@@ -531,10 +479,10 @@ namespace __profile
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,
@@ -545,7 +493,7 @@ namespace __profile
{
__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,
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-16 19:29:07 +0000