git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

array: Clean useless white chars. 

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.

From-SVN: r210900
This commit is contained in:
François Dumont 2014-05-24 20:59:00 +00:00
parent 1ebfdcab6b
commit f3de79d43a
20 changed files with 1577 additions and 1950 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,32 @@
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

1
libstdc++-v3/include/Makefile.am
View File

@ -816,6 +816,7 @@ profile_headers = \
${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

1
libstdc++-v3/include/Makefile.in
View File

@ -1079,6 +1079,7 @@ profile_headers = \
${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

151
libstdc++-v3/include/profile/bitset
View File

@ -35,7 +35,8 @@ namespace std _GLIBCXX_VISIBILITY(default)
{
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>
@ -43,60 +44,13 @@ namespace __profile
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
@ -221,92 +175,6 @@ namespace __profile
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; }
@ -315,11 +183,6 @@ namespace __profile
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); }

353
libstdc++-v3/include/profile/deque
View File

@ -43,26 +43,29 @@ namespace __profile
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::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)
@ -94,335 +97,37 @@ namespace __profile
: _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;
}
#if __cplusplus >= 201103L
#else
deque&
operator=(deque&& __x) noexcept
{
// NB: DR 1204.
// NB: DR 675.
this->clear();
this->swap(__x);
return *this;
}
operator=(const deque&) = default;
deque&
operator=(deque&&) = default;
deque&
operator=(initializer_list<value_type> __l)
{
*static_cast<_Base*>(this) = __l;
_M_base() = __l;
return *this;
}
#endif
void
swap(deque& __x)
#if __cplusplus >= 201103L
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
#else
template<typename _InputIterator>
noexcept( noexcept(declval<_Base>().swap(__x)) )
#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
#if __cplusplus >= 201103L
using _Base::shrink_to_fit;
#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; }

83
libstdc++-v3/include/profile/forward_list
View File

@ -46,13 +46,9 @@ namespace __profile
{
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::const_iterator const_iterator;
// 23.2.3.1 construct/copy/destroy:
explicit
@ -84,43 +80,80 @@ namespace __profile
: _Base(__first, __last, __al)
{ }
forward_list(const forward_list& __list)
: _Base(__list)
{ }
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())
: _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;
_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; }

16
libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h
View File

@ -108,32 +108,38 @@ namespace __gnu_profile
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_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_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;
}
@ -182,7 +188,7 @@ namespace __gnu_profile
public:
__trace_map2umap()
: __trace_base<__map2umap_info, __map2umap_stack_info>()
{ __id = "map-to-unordered-map"; }
{ __id = "ordered-to-unordered"; }
};
inline void

1
libstdc++-v3/include/profile/iterator_tracker.h
View File

@ -35,7 +35,6 @@ namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
template<typename _Iterator, typename _Sequence>
class __iterator_tracker
{

246
libstdc++-v3/include/profile/list
View File

@ -37,10 +37,44 @@ 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> >
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;
@ -65,46 +99,40 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
// 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
@ -115,91 +143,33 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
#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;
}
#if __cplusplus >= 201103L
#else
list&
operator=(list&& __x)
{
// NB: DR 1204.
// NB: DR 675.
this->clear();
this->swap(__x);
return *this;
}
operator=(const list&) = default;
list&
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
@ -248,11 +218,11 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
#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
@ -264,33 +234,6 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
#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
{
@ -314,10 +257,6 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
_Base::push_front(__x);
}
#if __cplusplus >= 201103L
using _Base::emplace_front;
#endif
void
pop_front() _GLIBCXX_NOEXCEPT
{
@ -325,17 +264,9 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
_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);
}
@ -358,7 +289,7 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
insert(iterator __position, const _Tp& __x)
#endif
{
_M_profile_insert(this, __position, size());
_M_profile_insert(this, __position, this->size());
return iterator(_Base::insert(__position.base(), __x), this);
}
@ -366,7 +297,7 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
iterator
insert(const_iterator __position, _Tp&& __x)
{
_M_profile_insert(this, __position, size());
_M_profile_insert(this, __position, this->size());
return iterator(_Base::emplace(__position.base(), std::move(__x)),
this);
}
@ -374,7 +305,7 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
iterator
insert(const_iterator __position, initializer_list<value_type> __l)
{
_M_profile_insert(this, __position, size());
_M_profile_insert(this, __position, this->size());
return iterator(_Base::insert(__position.base(), __l), this);
}
#endif
@ -383,14 +314,14 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
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
@ -402,7 +333,7 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
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);
}
@ -412,7 +343,7 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
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
@ -439,12 +370,11 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
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
@ -488,9 +418,6 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
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());
}
@ -573,12 +500,7 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
#else
merge(list& __x)
#endif
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 300. list::merge() specification incomplete
if (this != &__x)
{ _Base::merge(_GLIBCXX_MOVE(__x._M_base())); }
}
#if __cplusplus >= 201103L
void
@ -593,12 +515,7 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
#else
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); }
}
#if __cplusplus >= 201103L
template<typename _Compare>
@ -607,15 +524,6 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
{ 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; }

310
libstdc++-v3/include/profile/map.h
View File

@ -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,21 +39,17 @@ 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 typename _Base::value_type value_type;
typedef _Compare key_compare;
typedef _Allocator allocator_type;
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
@ -61,22 +57,29 @@ namespace __profile
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 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,
@ -87,58 +90,37 @@ namespace __profile
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); }
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,89 +143,55 @@ 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());
return _Base::rbegin();
}
const_reverse_iterator
rbegin() const _GLIBCXX_NOEXCEPT
{
__profcxx_map_to_unordered_map_invalidate(this);
return const_reverse_iterator(end());
return _Base::rbegin();
}
reverse_iterator
rend() _GLIBCXX_NOEXCEPT
{
__profcxx_map_to_unordered_map_invalidate(this);
return reverse_iterator(begin());
return _Base::rend();
}
const_reverse_iterator
rend() const _GLIBCXX_NOEXCEPT
{
__profcxx_map_to_unordered_map_invalidate(this);
return const_reverse_iterator(begin());
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());
return _Base::crbegin();
}
const_reverse_iterator
crend() const noexcept
{
__profcxx_map_to_unordered_map_invalidate(this);
return const_reverse_iterator(begin());
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());
__profcxx_map_to_unordered_map_find(this, this->size());
return _Base::operator[](__k);
}
@ -251,7 +199,7 @@ namespace __profile
mapped_type&
operator[](key_type&& __k)
{
__profcxx_map_to_unordered_map_find(this, size());
__profcxx_map_to_unordered_map_find(this, this->size());
return _Base::operator[](std::move(__k));
}
#endif
@ -259,14 +207,14 @@ namespace __profile
mapped_type&
at(const key_type& __k)
{
__profcxx_map_to_unordered_map_find(this, size());
__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());
__profcxx_map_to_unordered_map_find(this, this->size());
return _Base::at(__k);
}
@ -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,11 +245,8 @@ 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
@ -312,38 +256,30 @@ namespace __profile
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);
__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));
size_type size_before = this->size();
iterator __res = _Base::insert(__pos, __x);
__profcxx_map_to_unordered_map_insert(this, size_before,
size() - size_before);
return __i;
_M_hint_used(__pos, __res) ? 0 : 1);
return __res;
}
#if __cplusplus >= 201103L
@ -351,14 +287,14 @@ namespace __profile
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
iterator
insert(const_iterator __position, _Pair&& __x)
insert(const_iterator __pos, _Pair&& __x)
{
size_type size_before = size();
iterator __i
= iterator(_Base::insert(__position, std::forward<_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,
size() - size_before);
return __i;
_M_hint_used(__pos, __res) ? 0 : 1);
return __res;
}
#endif
@ -371,140 +307,137 @@ namespace __profile
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);
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());
__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_find(this, this->size());
__profcxx_map_to_unordered_map_invalidate(this);
return iterator(_Base::lower_bound(__x));
return _Base::lower_bound(__x);
}
const_iterator
lower_bound(const key_type& __x) const
{
__profcxx_map_to_unordered_map_find(this, this->size());
__profcxx_map_to_unordered_map_invalidate(this);
return const_iterator(_Base::lower_bound(__x));
return _Base::lower_bound(__x);
}
iterator
upper_bound(const key_type& __x)
{
__profcxx_map_to_unordered_map_find(this, this->size());
__profcxx_map_to_unordered_map_invalidate(this);
return iterator(_Base::upper_bound(__x));
return _Base::upper_bound(__x);
}
const_iterator
upper_bound(const key_type& __x) const
{
__profcxx_map_to_unordered_map_find(this, this->size());
__profcxx_map_to_unordered_map_invalidate(this);
return const_iterator(_Base::upper_bound(__x));
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&
@ -513,6 +446,21 @@ namespace __profile
const _Base&
_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,

290
libstdc++-v3/include/profile/multimap.h
View File

@ -29,7 +29,8 @@
#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)
{
@ -39,21 +40,17 @@ namespace __profile
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;
@ -69,8 +66,18 @@ namespace __profile
// 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())
@ -87,44 +94,35 @@ namespace __profile
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;
#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)
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)
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)
@ -147,85 +145,79 @@ namespace __profile
}
#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
@ -233,31 +225,45 @@ namespace __profile
_Pair&&>::value>::type>
iterator
insert(_Pair&& __x)
{ return iterator(_Base::insert(std::forward<_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))); }
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
@ -268,106 +274,138 @@ namespace __profile
#endif
void
insert(_InputIterator __first, _InputIterator __last)
{ _Base::insert(__first, __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&
@ -375,6 +413,22 @@ namespace __profile
const _Base&
_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,

268
libstdc++-v3/include/profile/multiset.h
View File

@ -29,7 +29,8 @@
#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)
{
@ -39,14 +40,11 @@ namespace __profile
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;
@ -69,8 +67,18 @@ namespace __profile
// 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())
@ -87,13 +95,7 @@ namespace __profile
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())
@ -107,8 +109,7 @@ namespace __profile
: _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)
@ -123,8 +124,6 @@ namespace __profile
multiset(const _Base& __x)
: _Base(__x) { }
~multiset() _GLIBCXX_NOEXCEPT { }
#if __cplusplus < 201103L
multiset&
operator=(const multiset& __x)
@ -147,98 +146,112 @@ namespace __profile
}
#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
@ -249,104 +262,135 @@ namespace __profile
#endif
void
insert(_InputIterator __first, _InputIterator __last)
{ _Base::insert(__first, __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
@ -354,11 +398,8 @@ namespace __profile
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&
@ -367,6 +408,21 @@ namespace __profile
const _Base&
_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>

65
libstdc++-v3/include/profile/ordered_base.h Normal file
View File

@ -0,0 +1,65 @@
// 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

278
libstdc++-v3/include/profile/set.h
View File

@ -29,7 +29,8 @@
#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)
{
@ -39,7 +40,8 @@ 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;
@ -53,7 +55,6 @@ namespace __profile
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;
@ -68,9 +69,18 @@ namespace __profile
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())
@ -87,44 +97,35 @@ namespace __profile
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)
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)
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)
@ -147,108 +148,98 @@ namespace __profile
}
#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
@ -264,115 +255,137 @@ namespace __profile
#endif
void
insert(_InputIterator __first, _InputIterator __last)
{ _Base::insert(__first, __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>
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>
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&
@ -381,6 +394,21 @@ namespace __profile
const _Base&
_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>

2
libstdc++-v3/include/profile/unordered_base.h
View File

@ -210,6 +210,7 @@ namespace __profile
auto __lend = __uc.end(__bkt);
for (++__it, ++__lit; __lit != __lend; ++__it, ++__lit)
++__chain;
if (__chain)
{
++__chain;
@ -245,6 +246,7 @@ namespace __profile
__pit = __it;
}
}
if (__chain)
{
++__chain;

42
libstdc++-v3/include/profile/unordered_map
View File

@ -81,8 +81,7 @@ namespace __profile
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,
@ -90,39 +89,33 @@ namespace __profile
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;
@ -333,8 +326,7 @@ namespace __profile
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,
@ -342,39 +334,33 @@ namespace __profile
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;

331
libstdc++-v3/include/profile/vector
View File

@ -37,20 +37,78 @@ namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
template<typename _Vector>
class _Vector_profile_pre
{
_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;
_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
_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 _GLIBCXX_STD_C::vector<_Tp, _Allocator>
: 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;
#if __cplusplus >= 201103L
typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
#endif
public:
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
@ -78,46 +136,35 @@ namespace __profile
// 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
@ -128,89 +175,46 @@ namespace __profile
#endif
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;
_M_base() = __x;
return *this;
}
#if __cplusplus >= 201103L
#else
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=(const vector&) = default;
vector&
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
@ -263,15 +267,13 @@ namespace __profile
#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);
_M_profile_resize(this->capacity(), __sz);
_Base::resize(__sz);
}
@ -279,7 +281,7 @@ namespace __profile
resize(size_type __sz, const _Tp& __c)
{
__profcxx_vector_invalid_operator(this);
_M_profile_resize(this, this->capacity(), __sz);
_M_profile_resize(this->capacity(), __sz);
_Base::resize(__sz, __c);
}
#else
@ -287,17 +289,11 @@ namespace __profile
resize(size_type __sz, _Tp __c = _Tp())
{
__profcxx_vector_invalid_operator(this);
_M_profile_resize(this, this->capacity(), __sz);
_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
@ -312,43 +308,13 @@ namespace __profile
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();
}
// _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();
_Base::push_back(__x);
_M_profile_resize(this, __old_size, this->capacity());
_M_profile_resize(__old_size, this->capacity());
}
#if __cplusplus >= 201103L
@ -357,89 +323,79 @@ namespace __profile
{
size_type __old_size = this->capacity();
_Base::push_back(std::move(__x));
_M_profile_resize(this, __old_size, this->capacity());
_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(),
__profcxx_vector_insert(this, __pos.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());
_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(),
__profcxx_vector_insert(this, __pos.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());
_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)
emplace(const_iterator __pos, _Args&&... __args)
{
_Base_iterator __res = _Base::emplace(__position.base(),
_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(),
__profcxx_vector_insert(this, __pos.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());
_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(),
__profcxx_vector_insert(this, __pos.base() - _Base::begin(),
this->size());
size_type __old_size = this->capacity();
_Base::insert(__position, __n, __x);
_M_profile_resize(this, __old_size, this->capacity());
_Base::insert(__pos, __n, __x);
_M_profile_resize(__old_size, this->capacity());
}
#endif
@ -447,40 +403,37 @@ namespace __profile
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
@ -488,36 +441,26 @@ namespace __profile
#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);
this->_M_profile_destruct();
_Base::clear();
}
inline void _M_profile_find() const
{
__profcxx_vector_find(this, size());
}
{ __profcxx_vector_find(this, this->size()); }
inline void _M_profile_iterate(int __rewind = 0) const
{
__profcxx_vector_iterate(this);
}
{ __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)
{
if (__old_size < __new_size) {
__profcxx_vector_resize(this, this->size(), __new_size);
__profcxx_vector_resize2(this, this->size(), __new_size);
}