// Debugging map implementation -*- C++ -*-
-// Copyright (C) 2003-2015 Free Software Foundation, Inc.
+// Copyright (C) 2003-2020 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
typedef typename _Base::iterator _Base_iterator;
typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
+ template<typename _ItT, typename _SeqT, typename _CatT>
+ friend class ::__gnu_debug::_Safe_iterator;
+
public:
// types:
typedef _Key key_type;
: _Base(__m, __a) { }
map(map&& __m, const allocator_type& __a)
+ noexcept( noexcept(_Base(std::move(__m._M_base()), __a)) )
: _Safe(std::move(__m._M_safe()), __a),
_Base(std::move(__m._M_base()), __a) { }
template<typename _InputIterator>
map(_InputIterator __first, _InputIterator __last,
const allocator_type& __a)
- : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
- __last)),
+ : _Base(__gnu_debug::__base(
+ __glibcxx_check_valid_constructor_range(__first, __last)),
__gnu_debug::__base(__last), __a)
{ }
map(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
- : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
- __last)),
+ : _Base(__gnu_debug::__base(
+ __glibcxx_check_valid_constructor_range(__first, __last)),
__gnu_debug::__base(__last),
__comp, __a) { }
emplace(_Args&&... __args)
{
auto __res = _Base::emplace(std::forward<_Args>(__args)...);
- return std::pair<iterator, bool>(iterator(__res.first, this),
- __res.second);
+ return { { __res.first, this }, __res.second };
}
template<typename... _Args>
emplace_hint(const_iterator __pos, _Args&&... __args)
{
__glibcxx_check_insert(__pos);
- return iterator(_Base::emplace_hint(__pos.base(),
- std::forward<_Args>(__args)...),
- this);
+ return
+ {
+ _Base::emplace_hint(__pos.base(), std::forward<_Args>(__args)...),
+ this
+ };
}
#endif
}
#if __cplusplus >= 201103L
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 2354. Unnecessary copying when inserting into maps with braced-init
+ std::pair<iterator, bool>
+ insert(value_type&& __x)
+ {
+ auto __res = _Base::insert(std::move(__x));
+ return { { __res.first, this }, __res.second };
+ }
+
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
std::pair<iterator, bool>
insert(_Pair&& __x)
{
- std::pair<_Base_iterator, bool> __res
- = _Base::insert(std::forward<_Pair>(__x));
- return std::pair<iterator, bool>(iterator(__res.first, this),
- __res.second);
+ auto __res = _Base::insert(std::forward<_Pair>(__x));
+ return { { __res.first, this }, __res.second };
}
#endif
}
#if __cplusplus >= 201103L
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 2354. Unnecessary copying when inserting into maps with braced-init
+ iterator
+ insert(const_iterator __position, value_type&& __x)
+ {
+ __glibcxx_check_insert(__position);
+ return { _Base::insert(__position.base(), std::move(__x)), this };
+ }
+
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible<value_type,
_Pair&&>::value>::type>
insert(const_iterator __position, _Pair&& __x)
{
__glibcxx_check_insert(__position);
- return iterator(_Base::insert(__position.base(),
- std::forward<_Pair>(__x)), this);
+ return
+ {
+ _Base::insert(__position.base(), std::forward<_Pair>(__x)),
+ this
+ };
}
#endif
_Base::insert(__first, __last);
}
+
+#if __cplusplus > 201402L
+ template <typename... _Args>
+ pair<iterator, bool>
+ try_emplace(const key_type& __k, _Args&&... __args)
+ {
+ auto __res = _Base::try_emplace(__k,
+ std::forward<_Args>(__args)...);
+ return { { __res.first, this }, __res.second };
+ }
+
+ template <typename... _Args>
+ pair<iterator, bool>
+ try_emplace(key_type&& __k, _Args&&... __args)
+ {
+ auto __res = _Base::try_emplace(std::move(__k),
+ std::forward<_Args>(__args)...);
+ return { { __res.first, this }, __res.second };
+ }
+
+ template <typename... _Args>
+ iterator
+ try_emplace(const_iterator __hint, const key_type& __k,
+ _Args&&... __args)
+ {
+ __glibcxx_check_insert(__hint);
+ return
+ {
+ _Base::try_emplace(__hint.base(), __k,
+ std::forward<_Args>(__args)...),
+ this
+ };
+ }
+
+ template <typename... _Args>
+ iterator
+ try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
+ {
+ __glibcxx_check_insert(__hint);
+ return
+ {
+ _Base::try_emplace(__hint.base(), std::move(__k),
+ std::forward<_Args>(__args)...),
+ this
+ };
+ }
+
+ template <typename _Obj>
+ std::pair<iterator, bool>
+ insert_or_assign(const key_type& __k, _Obj&& __obj)
+ {
+ auto __res = _Base::insert_or_assign(__k,
+ std::forward<_Obj>(__obj));
+ return { { __res.first, this }, __res.second };
+ }
+
+ template <typename _Obj>
+ std::pair<iterator, bool>
+ insert_or_assign(key_type&& __k, _Obj&& __obj)
+ {
+ auto __res = _Base::insert_or_assign(std::move(__k),
+ std::forward<_Obj>(__obj));
+ return { { __res.first, this }, __res.second };
+ }
+
+ template <typename _Obj>
+ iterator
+ insert_or_assign(const_iterator __hint,
+ const key_type& __k, _Obj&& __obj)
+ {
+ __glibcxx_check_insert(__hint);
+ return
+ {
+ _Base::insert_or_assign(__hint.base(), __k,
+ std::forward<_Obj>(__obj)),
+ this
+ };
+ }
+
+ template <typename _Obj>
+ iterator
+ insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj)
+ {
+ __glibcxx_check_insert(__hint);
+ return
+ {
+ _Base::insert_or_assign(__hint.base(), std::move(__k),
+ std::forward<_Obj>(__obj)),
+ this
+ };
+ }
+#endif // C++17
+
+#if __cplusplus > 201402L
+ using node_type = typename _Base::node_type;
+ using insert_return_type = _Node_insert_return<iterator, node_type>;
+
+ node_type
+ extract(const_iterator __position)
+ {
+ __glibcxx_check_erase(__position);
+ this->_M_invalidate_if(_Equal(__position.base()));
+ return _Base::extract(__position.base());
+ }
+
+ node_type
+ extract(const key_type& __key)
+ {
+ const auto __position = find(__key);
+ if (__position != end())
+ return extract(__position);
+ return {};
+ }
+
+ insert_return_type
+ insert(node_type&& __nh)
+ {
+ auto __ret = _Base::insert(std::move(__nh));
+ return
+ { { __ret.position, this }, __ret.inserted, std::move(__ret.node) };
+ }
+
+ iterator
+ insert(const_iterator __hint, node_type&& __nh)
+ {
+ __glibcxx_check_insert(__hint);
+ return { _Base::insert(__hint.base(), std::move(__nh)), this };
+ }
+
+ using _Base::merge;
+#endif // C++17
+
#if __cplusplus >= 201103L
iterator
erase(const_iterator __position)
{
__glibcxx_check_erase(__position);
this->_M_invalidate_if(_Equal(__position.base()));
- return iterator(_Base::erase(__position.base()), this);
+ return { _Base::erase(__position.base()), this };
}
+ _GLIBCXX_ABI_TAG_CXX11
iterator
erase(iterator __position)
{ return erase(const_iterator(__position)); }
for (_Base_const_iterator __victim = __first.base();
__victim != __last.base(); ++__victim)
{
- _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+ _GLIBCXX_DEBUG_VERIFY(__victim != _Base::cend(),
_M_message(__gnu_debug::__msg_valid_range)
._M_iterator(__first, "first")
._M_iterator(__last, "last"));
this->_M_invalidate_if(_Equal(__victim));
}
- return iterator(_Base::erase(__first.base(), __last.base()), this);
+
+ return { _Base::erase(__first.base(), __last.base()), this };
}
#else
void
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
};
+#if __cpp_deduction_guides >= 201606
+
+ template<typename _InputIterator,
+ typename _Compare = less<__iter_key_t<_InputIterator>>,
+ typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireNotAllocator<_Compare>,
+ typename = _RequireAllocator<_Allocator>>
+ map(_InputIterator, _InputIterator,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+ _Compare, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
+ typename _Allocator = allocator<pair<const _Key, _Tp>>,
+ typename = _RequireNotAllocator<_Compare>,
+ typename = _RequireAllocator<_Allocator>>
+ map(initializer_list<pair<_Key, _Tp>>,
+ _Compare = _Compare(), _Allocator = _Allocator())
+ -> map<_Key, _Tp, _Compare, _Allocator>;
+
+ template <typename _InputIterator, typename _Allocator,
+ typename = _RequireInputIter<_InputIterator>,
+ typename = _RequireAllocator<_Allocator>>
+ map(_InputIterator, _InputIterator, _Allocator)
+ -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+ less<__iter_key_t<_InputIterator>>, _Allocator>;
+
+ template<typename _Key, typename _Tp, typename _Allocator,
+ typename = _RequireAllocator<_Allocator>>
+ map(initializer_list<pair<_Key, _Tp>>, _Allocator)
+ -> map<_Key, _Tp, less<_Key>, _Allocator>;
+
+#endif
+
template<typename _Key, typename _Tp,
typename _Compare, typename _Allocator>
inline bool