[thirdparty/gcc.git] / libstdc++-v3 / include / debug / set.h

// Debugging set implementation -*- C++ -*-

// Copyright (C) 2003-2025 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 and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file debug/set.h
 *  This file is a GNU debug extension to the Standard C++ Library.
 */

#ifndef _GLIBCXX_DEBUG_SET_H
#define _GLIBCXX_DEBUG_SET_H 1

#include <debug/safe_sequence.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
#include <bits/stl_pair.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
  /// Class std::set with safety/checking/debug instrumentation.
  template<typename _Key, typename _Compare = std::less<_Key>,
	   typename _Allocator = std::allocator<_Key> >
    class set
    : public __gnu_debug::_Safe_container<
	set<_Key, _Compare, _Allocator>, _Allocator,
	__gnu_debug::_Safe_node_sequence>,
      public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>
    {
      typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator>	_Base;
      typedef __gnu_debug::_Safe_container<
	set, _Allocator, __gnu_debug::_Safe_node_sequence>	_Safe;

      typedef typename _Base::const_iterator	_Base_const_iterator;
      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;

      // Reference wrapper for base class. Disambiguates set(const _Base&)
      // from copy constructor by requiring a user-defined conversion.
      // See PR libstdc++/90102.
      struct _Base_ref
      {
	_Base_ref(const _Base& __r) : _M_ref(__r) { }

	const _Base& _M_ref;
      };

    public:
      // types:
      typedef _Key					key_type;
      typedef _Key					value_type;
      typedef _Compare					key_compare;
      typedef _Compare					value_compare;
      typedef _Allocator				allocator_type;
      typedef typename _Base::reference			reference;
      typedef typename _Base::const_reference		const_reference;

      typedef __gnu_debug::_Safe_iterator<_Base_iterator, set>
							iterator;
      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, set>
							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;

      // 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(initializer_list<value_type> __l,
	  const _Compare& __comp = _Compare(),
	  const allocator_type& __a = allocator_type())
      : _Base(__l, __comp, __a) { }

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

      set(const set& __x, const __type_identity_t<allocator_type>& __a)
      : _Base(__x, __a) { }

      set(set&& __x, const __type_identity_t<allocator_type>& __a)
      noexcept( noexcept(_Base(std::move(__x), __a)) )
      : _Safe(std::move(__x), __a),
	_Base(std::move(__x), __a) { }

      set(initializer_list<value_type> __l, const allocator_type& __a)
      : _Base(__l, __a) { }

      template<typename _InputIterator>
	set(_InputIterator __first, _InputIterator __last,
	    const allocator_type& __a)
	: _Base(__gnu_debug::__base(
		  __glibcxx_check_valid_constructor_range(__first, __last)),
		__gnu_debug::__base(__last), __a) { }

#if __glibcxx_containers_ranges // C++ >= 23
      /**
       * @brief Construct a set from a range.
       * @since C++23
       */
      template<std::__detail::__container_compatible_range<_Key> _Rg>
	set(std::from_range_t __t, _Rg&& __rg,
	    const _Compare& __c,
	    const allocator_type& __a = allocator_type())
	: _Base(__t, std::forward<_Rg>(__rg), __c, __a)
	{ }

      template<std::__detail::__container_compatible_range<_Key> _Rg>
	set(std::from_range_t __t, _Rg&& __rg,
	    const allocator_type& __a = allocator_type())
	: _Base(__t, std::forward<_Rg>(__rg), __a)
	{ }
#endif

	  ~set() = default;
#endif

      explicit set(const _Compare& __comp,
		   const _Allocator& __a = _Allocator())
      : _Base(__comp, __a) { }

      template<typename _InputIterator>
	set(_InputIterator __first, _InputIterator __last,
	    const _Compare& __comp = _Compare(),
	    const _Allocator& __a = _Allocator())
	: _Base(__gnu_debug::__base(
		  __glibcxx_check_valid_constructor_range(__first, __last)),
		__gnu_debug::__base(__last),
		__comp, __a) { }

      set(_Base_ref __x)
      : _Base(__x._M_ref) { }

#if __cplusplus >= 201103L
      set&
      operator=(const set&) = default;

      set&
      operator=(set&&) = default;

      set&
      operator=(initializer_list<value_type> __l)
      {
	_Base::operator=(__l);
	this->_M_invalidate_all();
	return *this;
      }
#endif

      using _Base::get_allocator;

      // iterators:
      iterator
      begin() _GLIBCXX_NOEXCEPT
      { return iterator(_Base::begin(), this); }

      const_iterator
      begin() const _GLIBCXX_NOEXCEPT
      { return const_iterator(_Base::begin(), this); }

      iterator
      end() _GLIBCXX_NOEXCEPT
      { return iterator(_Base::end(), this); }

      const_iterator
      end() const _GLIBCXX_NOEXCEPT
      { return const_iterator(_Base::end(), this); }

      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(), this); }

      const_iterator
      cend() const noexcept
      { return const_iterator(_Base::end(), this); }

      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }

      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }
#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 { { __res.first, this }, __res.second };
	}

      template<typename... _Args>
	iterator
	emplace_hint(const_iterator __pos, _Args&&... __args)
	{
	  __glibcxx_check_insert(__pos);
	  return
	    {
	      _Base::emplace_hint(__pos.base(), std::forward<_Args>(__args)...),
	      this
	    };
	}
#endif

      std::pair<iterator, bool>
      insert(const value_type& __x)
      {
	std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
	return std::pair<iterator, bool>(iterator(__res.first, this),
					 __res.second);
      }

#if __cplusplus >= 201103L
      std::pair<iterator, bool>
      insert(value_type&& __x)
      {
	auto __res = _Base::insert(std::move(__x));
	return { { __res.first, this }, __res.second };
      }
#endif

      iterator
      insert(const_iterator __position, const value_type& __x)
      {
	__glibcxx_check_insert(__position);
	return iterator(_Base::insert(__position.base(), __x), this);
      }

#if __cplusplus >= 201103L
      iterator
      insert(const_iterator __position, value_type&& __x)
      {
	__glibcxx_check_insert(__position);
	return { _Base::insert(__position.base(), std::move(__x)), this };
      }
#endif

      template <typename _InputIterator>
	void
	insert(_InputIterator __first, _InputIterator __last)
	{
	  typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
	  __glibcxx_check_valid_range2(__first, __last, __dist);

	  if (__dist.second >= __gnu_debug::__dp_sign)
	    _Base::insert(__gnu_debug::__unsafe(__first),
			  __gnu_debug::__unsafe(__last));
	  else
	    _Base::insert(__first, __last);
	}

#if __cplusplus >= 201103L
      void
      insert(initializer_list<value_type> __l)
      { _Base::insert(__l); }
#endif

#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));
	iterator __pos = iterator(__ret.position, this);
	return { __pos, __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
      _GLIBCXX_ABI_TAG_CXX11
      iterator
      erase(const_iterator __position)
      {
	__glibcxx_check_erase(__position);
	return { erase(__position.base()), this };
      }

      _Base_iterator
      erase(_Base_const_iterator __position)
      {
	__glibcxx_check_erase2(__position);
	this->_M_invalidate_if(_Equal(__position));
	return _Base::erase(__position);
      }
#else
      void
      erase(iterator __position)
      {
	__glibcxx_check_erase(__position);
	this->_M_invalidate_if(_Equal(__position.base()));
	_Base::erase(__position.base());
      }
#endif

      size_type
      erase(const key_type& __x)
      {
	_Base_iterator __victim = _Base::find(__x);
	if (__victim == _Base::end())
	  return 0;
	else
	  {
	    this->_M_invalidate_if(_Equal(__victim));
	    _Base::erase(__victim);
	    return 1;
	  }
      }

#if __cplusplus >= 201103L
      _GLIBCXX_ABI_TAG_CXX11
      iterator
      erase(const_iterator __first, const_iterator __last)
      {
	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	// 151. can't currently clear() empty container
	__glibcxx_check_erase_range(__first, __last);
	for (_Base_const_iterator __victim = __first.base();
	     __victim != __last.base(); ++__victim)
	  {
	    _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 { _Base::erase(__first.base(), __last.base()), this };
      }
#else
      void
      erase(iterator __first, iterator __last)
      {
	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	// 151. can't currently clear() empty container
	__glibcxx_check_erase_range(__first, __last);
	for (_Base_iterator __victim = __first.base();
	     __victim != __last.base(); ++__victim)
	  {
	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
				  _M_message(__gnu_debug::__msg_valid_range)
				  ._M_iterator(__first, "first")
				  ._M_iterator(__last, "last"));
	    this->_M_invalidate_if(_Equal(__victim));
	  }
	_Base::erase(__first.base(), __last.base());
      }
#endif

      void
      swap(set& __x)
      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
      {
	_Safe::_M_swap(__x);
	_Base::swap(__x);
      }

      void
      clear() _GLIBCXX_NOEXCEPT
      {
	this->_M_invalidate_all();
	_Base::clear();
      }

      // observers:
      using _Base::key_comp;
      using _Base::value_comp;

      // set operations:
      iterator
      find(const key_type& __x)
      { return iterator(_Base::find(__x), this); }

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 214. set::find() missing const overload
      const_iterator
      find(const key_type& __x) const
      { return const_iterator(_Base::find(__x), this); }

#if __cplusplus > 201103L
      template<typename _Kt,
	       typename _Req =
		 typename __has_is_transparent<_Compare, _Kt>::type>
	iterator
	find(const _Kt& __x)
	{ return { _Base::find(__x), this }; }

      template<typename _Kt,
	       typename _Req =
		 typename __has_is_transparent<_Compare, _Kt>::type>
	const_iterator
	find(const _Kt& __x) const
	{ return { _Base::find(__x), this }; }
#endif

      using _Base::count;

      iterator
      lower_bound(const key_type& __x)
      { return iterator(_Base::lower_bound(__x), this); }

      // _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), this); }

#if __cplusplus > 201103L
      template<typename _Kt,
	       typename _Req =
		 typename __has_is_transparent<_Compare, _Kt>::type>
	iterator
	lower_bound(const _Kt& __x)
	{ return { _Base::lower_bound(__x), this }; }

      template<typename _Kt,
	       typename _Req =
		 typename __has_is_transparent<_Compare, _Kt>::type>
	const_iterator
	lower_bound(const _Kt& __x) const
	{ return { _Base::lower_bound(__x), this }; }
#endif

      iterator
      upper_bound(const key_type& __x)
      { return iterator(_Base::upper_bound(__x), this); }

      // _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), this); }

#if __cplusplus > 201103L
      template<typename _Kt,
	       typename _Req =
		 typename __has_is_transparent<_Compare, _Kt>::type>
	iterator
	upper_bound(const _Kt& __x)
	{ return { _Base::upper_bound(__x), this }; }

      template<typename _Kt,
	       typename _Req =
		 typename __has_is_transparent<_Compare, _Kt>::type>
	const_iterator
	upper_bound(const _Kt& __x) const
	{ return { _Base::upper_bound(__x), this }; }
#endif

      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      {
	std::pair<_Base_iterator, _Base_iterator> __res =
	_Base::equal_range(__x);
	return std::make_pair(iterator(__res.first, this),
			      iterator(__res.second, this));
      }

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 214. set::find() missing const overload
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      {
	std::pair<_Base_const_iterator, _Base_const_iterator> __res =
	_Base::equal_range(__x);
	return std::make_pair(const_iterator(__res.first, this),
			      const_iterator(__res.second, this));
      }

#if __cplusplus > 201103L
      template<typename _Kt,
	       typename _Req =
		 typename __has_is_transparent<_Compare, _Kt>::type>
	std::pair<iterator, iterator>
	equal_range(const _Kt& __x)
	{
	  auto __res = _Base::equal_range(__x);
	  return { { __res.first, this }, { __res.second, this } };
	}

      template<typename _Kt,
	       typename _Req =
		 typename __has_is_transparent<_Compare, _Kt>::type>
	std::pair<const_iterator, const_iterator>
	equal_range(const _Kt& __x) const
	{
	  auto __res = _Base::equal_range(__x);
	  return { { __res.first, this }, { __res.second, this } };
	}
#endif

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

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

#if __cpp_deduction_guides >= 201606

  template<typename _InputIterator,
	   typename _Compare =
	     less<typename iterator_traits<_InputIterator>::value_type>,
	   typename _Allocator =
	     allocator<typename iterator_traits<_InputIterator>::value_type>,
	   typename = _RequireInputIter<_InputIterator>,
	   typename = _RequireNotAllocator<_Compare>,
	   typename = _RequireAllocator<_Allocator>>
    set(_InputIterator, _InputIterator,
	_Compare = _Compare(), _Allocator = _Allocator())
    -> set<typename iterator_traits<_InputIterator>::value_type,
	   _Compare, _Allocator>;

  template<typename _Key, typename _Compare = less<_Key>,
	   typename _Allocator = allocator<_Key>,
	   typename = _RequireNotAllocator<_Compare>,
	   typename = _RequireAllocator<_Allocator>>
    set(initializer_list<_Key>,
	_Compare = _Compare(), _Allocator = _Allocator())
    -> set<_Key, _Compare, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
	   typename = _RequireInputIter<_InputIterator>,
	   typename = _RequireAllocator<_Allocator>>
    set(_InputIterator, _InputIterator, _Allocator)
    -> set<typename iterator_traits<_InputIterator>::value_type,
	   less<typename iterator_traits<_InputIterator>::value_type>,
	   _Allocator>;

  template<typename _Key, typename _Allocator,
	   typename = _RequireAllocator<_Allocator>>
    set(initializer_list<_Key>, _Allocator)
    -> set<_Key, less<_Key>, _Allocator>;

#if __glibcxx_containers_ranges // C++ >= 23
  template<ranges::input_range _Rg,
	   __not_allocator_like _Compare = less<ranges::range_value_t<_Rg>>,
	   __allocator_like _Alloc = std::allocator<ranges::range_value_t<_Rg>>>
    set(from_range_t, _Rg&&, _Compare = _Compare(), _Alloc = _Alloc())
      -> set<ranges::range_value_t<_Rg>, _Compare, _Alloc>;

  template<ranges::input_range _Rg, __allocator_like _Alloc>
    set(from_range_t, _Rg&&, _Alloc)
      -> set<ranges::range_value_t<_Rg>, less<ranges::range_value_t<_Rg>>, _Alloc>;
#endif
#endif // deduction guides

  template<typename _Key, typename _Compare, typename _Allocator>
    inline bool
    operator==(const set<_Key, _Compare, _Allocator>& __lhs,
	       const set<_Key, _Compare, _Allocator>& __rhs)
    { return __lhs._M_base() == __rhs._M_base(); }

#if __cpp_lib_three_way_comparison
  template<typename _Key, typename _Compare, typename _Alloc>
    inline __detail::__synth3way_t<_Key>
    operator<=>(const set<_Key, _Compare, _Alloc>& __lhs,
		const set<_Key, _Compare, _Alloc>& __rhs)
    { return __lhs._M_base() <=> __rhs._M_base(); }
#else
  template<typename _Key, typename _Compare, typename _Allocator>
    inline bool
    operator!=(const set<_Key, _Compare, _Allocator>& __lhs,
	       const set<_Key, _Compare, _Allocator>& __rhs)
    { return __lhs._M_base() != __rhs._M_base(); }

  template<typename _Key, typename _Compare, typename _Allocator>
    inline bool
    operator<(const set<_Key, _Compare, _Allocator>& __lhs,
	      const set<_Key, _Compare, _Allocator>& __rhs)
    { return __lhs._M_base() < __rhs._M_base(); }

  template<typename _Key, typename _Compare, typename _Allocator>
    inline bool
    operator<=(const set<_Key, _Compare, _Allocator>& __lhs,
	       const set<_Key, _Compare, _Allocator>& __rhs)
    { return __lhs._M_base() <= __rhs._M_base(); }

  template<typename _Key, typename _Compare, typename _Allocator>
    inline bool
    operator>=(const set<_Key, _Compare, _Allocator>& __lhs,
	       const set<_Key, _Compare, _Allocator>& __rhs)
    { return __lhs._M_base() >= __rhs._M_base(); }

  template<typename _Key, typename _Compare, typename _Allocator>
    inline bool
    operator>(const set<_Key, _Compare, _Allocator>& __lhs,
	      const set<_Key, _Compare, _Allocator>& __rhs)
    { return __lhs._M_base() > __rhs._M_base(); }
#endif // three-way comparison

  template<typename _Key, typename _Compare, typename _Allocator>
    void
    swap(set<_Key, _Compare, _Allocator>& __x,
	 set<_Key, _Compare, _Allocator>& __y)
    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
    { return __x.swap(__y); }

} // namespace __debug
} // namespace std

#endif
Commit	Line	Data
	1	// Debugging set implementation -- C++ --
	2
	3	// Copyright (C) 2003-2025 Free Software Foundation, Inc.
	4	//
	5	// This file is part of the GNU ISO C++ Library. This library is free
	6	// software; you can redistribute it and/or modify it under the
	7	// terms of the GNU General Public License as published by the
	8	// Free Software Foundation; either version 3, or (at your option)
	9	// any later version.
	10
	11	// This library is distributed in the hope that it will be useful,
	12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	// GNU General Public License for more details.
	15
	16	// Under Section 7 of GPL version 3, you are granted additional
	17	// permissions described in the GCC Runtime Library Exception, version
	18	// 3.1, as published by the Free Software Foundation.
	19
	20	// You should have received a copy of the GNU General Public License and
	21	// a copy of the GCC Runtime Library Exception along with this program;
	22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
	23	// <http://www.gnu.org/licenses/>.
	24
	25	/** @file debug/set.h
	26	* This file is a GNU debug extension to the Standard C++ Library.
	27	*/
	28
	29	#ifndef _GLIBCXX_DEBUG_SET_H
	30	#define _GLIBCXX_DEBUG_SET_H 1
	31
	32	#include <debug/safe_sequence.h>
	33	#include <debug/safe_container.h>
	34	#include <debug/safe_iterator.h>
	35	#include <bits/stl_pair.h>
	36
	37	namespace std _GLIBCXX_VISIBILITY(default)
	38	{
	39	namespace __debug
	40	{
	41	/// Class std::set with safety/checking/debug instrumentation.
	42	template<typename _Key, typename _Compare = std::less<_Key>,
	43	typename _Allocator = std::allocator<_Key> >
	44	class set
	45	: public __gnu_debug::_Safe_container<
	46	set<_Key, _Compare, _Allocator>, _Allocator,
	47	__gnu_debug::_Safe_node_sequence>,
	48	public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>
	49	{
	50	typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base;
	51	typedef __gnu_debug::_Safe_container<
	52	set, _Allocator, __gnu_debug::_Safe_node_sequence> _Safe;
	53
	54	typedef typename _Base::const_iterator _Base_const_iterator;
	55	typedef typename _Base::iterator _Base_iterator;
	56	typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
	57
	58	template<typename _ItT, typename _SeqT, typename _CatT>
	59	friend class ::__gnu_debug::_Safe_iterator;
	60
	61	// Reference wrapper for base class. Disambiguates set(const _Base&)
	62	// from copy constructor by requiring a user-defined conversion.
	63	// See PR libstdc++/90102.
	64	struct _Base_ref
	65	{
	66	_Base_ref(const _Base& __r) : _M_ref(__r) { }
	67
	68	const _Base& _M_ref;
	69	};
	70
	71	public:
	72	// types:
	73	typedef _Key key_type;
	74	typedef _Key value_type;
	75	typedef _Compare key_compare;
	76	typedef _Compare value_compare;
	77	typedef _Allocator allocator_type;
	78	typedef typename _Base::reference reference;
	79	typedef typename _Base::const_reference const_reference;
	80
	81	typedef __gnu_debug::_Safe_iterator<_Base_iterator, set>
	82	iterator;
	83	typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, set>
	84	const_iterator;
	85
	86	typedef typename _Base::size_type size_type;
	87	typedef typename _Base::difference_type difference_type;
	88	typedef typename _Base::pointer pointer;
	89	typedef typename _Base::const_pointer const_pointer;
	90	typedef std::reverse_iterator<iterator> reverse_iterator;
	91	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
	92
	93	// 23.3.3.1 construct/copy/destroy:
	94
	95	#if __cplusplus < 201103L
	96	set() : _Base() { }
	97
	98	set(const set& __x)
	99	: _Base(__x) { }
	100
	101	~set() { }
	102	#else
	103	set() = default;
	104	set(const set&) = default;
	105	set(set&&) = default;
	106
	107	set(initializer_list<value_type> __l,
	108	const _Compare& __comp = _Compare(),
	109	const allocator_type& __a = allocator_type())
	110	: _Base(__l, __comp, __a) { }
	111
	112	explicit
	113	set(const allocator_type& __a)
	114	: _Base(__a) { }
	115
	116	set(const set& __x, const __type_identity_t<allocator_type>& __a)
	117	: _Base(__x, __a) { }
	118
	119	set(set&& __x, const __type_identity_t<allocator_type>& __a)
	120	noexcept( noexcept(_Base(std::move(__x), __a)) )
	121	: _Safe(std::move(__x), __a),
	122	_Base(std::move(__x), __a) { }
	123
	124	set(initializer_list<value_type> __l, const allocator_type& __a)
	125	: _Base(__l, __a) { }
	126
	127	template<typename _InputIterator>
	128	set(_InputIterator __first, _InputIterator __last,
	129	const allocator_type& __a)
	130	: _Base(__gnu_debug::__base(
	131	__glibcxx_check_valid_constructor_range(__first, __last)),
	132	__gnu_debug::__base(__last), __a) { }
	133
	134	#if __glibcxx_containers_ranges // C++ >= 23
	135	/**
	136	* @brief Construct a set from a range.
	137	* @since C++23
	138	*/
	139	template<std::__detail::__container_compatible_range<_Key> _Rg>
	140	set(std::from_range_t __t, _Rg&& __rg,
	141	const _Compare& __c,
	142	const allocator_type& __a = allocator_type())
	143	: _Base(__t, std::forward<_Rg>(__rg), __c, __a)
	144	{ }
	145
	146	template<std::__detail::__container_compatible_range<_Key> _Rg>
	147	set(std::from_range_t __t, _Rg&& __rg,
	148	const allocator_type& __a = allocator_type())
	149	: _Base(__t, std::forward<_Rg>(__rg), __a)
	150	{ }
	151	#endif
	152
	153	~set() = default;
	154	#endif
	155
	156	explicit set(const _Compare& __comp,
	157	const _Allocator& __a = _Allocator())
	158	: _Base(__comp, __a) { }
	159
	160	template<typename _InputIterator>
	161	set(_InputIterator __first, _InputIterator __last,
	162	const _Compare& __comp = _Compare(),
	163	const _Allocator& __a = _Allocator())
	164	: _Base(__gnu_debug::__base(
	165	__glibcxx_check_valid_constructor_range(__first, __last)),
	166	__gnu_debug::__base(__last),
	167	__comp, __a) { }
	168
	169	set(_Base_ref __x)
	170	: _Base(__x._M_ref) { }
	171
	172	#if __cplusplus >= 201103L
	173	set&
	174	operator=(const set&) = default;
	175
	176	set&
	177	operator=(set&&) = default;
	178
	179	set&
	180	operator=(initializer_list<value_type> __l)
	181	{
	182	_Base::operator=(__l);
	183	this->_M_invalidate_all();
	184	return *this;
	185	}
	186	#endif
	187
	188	using _Base::get_allocator;
	189
	190	// iterators:
	191	iterator
	192	begin() _GLIBCXX_NOEXCEPT
	193	{ return iterator(_Base::begin(), this); }
	194
	195	const_iterator
	196	begin() const _GLIBCXX_NOEXCEPT
	197	{ return const_iterator(_Base::begin(), this); }
	198
	199	iterator
	200	end() _GLIBCXX_NOEXCEPT
	201	{ return iterator(_Base::end(), this); }
	202
	203	const_iterator
	204	end() const _GLIBCXX_NOEXCEPT
	205	{ return const_iterator(_Base::end(), this); }
	206
	207	reverse_iterator
	208	rbegin() _GLIBCXX_NOEXCEPT
	209	{ return reverse_iterator(end()); }
	210
	211	const_reverse_iterator
	212	rbegin() const _GLIBCXX_NOEXCEPT
	213	{ return const_reverse_iterator(end()); }
	214
	215	reverse_iterator
	216	rend() _GLIBCXX_NOEXCEPT
	217	{ return reverse_iterator(begin()); }
	218
	219	const_reverse_iterator
	220	rend() const _GLIBCXX_NOEXCEPT
	221	{ return const_reverse_iterator(begin()); }
	222
	223	#if __cplusplus >= 201103L
	224	const_iterator
	225	cbegin() const noexcept
	226	{ return const_iterator(_Base::begin(), this); }
	227
	228	const_iterator
	229	cend() const noexcept
	230	{ return const_iterator(_Base::end(), this); }
	231
	232	const_reverse_iterator
	233	crbegin() const noexcept
	234	{ return const_reverse_iterator(end()); }
	235
	236	const_reverse_iterator
	237	crend() const noexcept
	238	{ return const_reverse_iterator(begin()); }
	239	#endif
	240
	241	// capacity:
	242	using _Base::empty;
	243	using _Base::size;
	244	using _Base::max_size;
	245
	246	// modifiers:
	247	#if __cplusplus >= 201103L
	248	template<typename... _Args>
	249	std::pair<iterator, bool>
	250	emplace(_Args&&... __args)
	251	{
	252	auto __res = _Base::emplace(std::forward<_Args>(__args)...);
	253	return { { __res.first, this }, __res.second };
	254	}
	255
	256	template<typename... _Args>
	257	iterator
	258	emplace_hint(const_iterator __pos, _Args&&... __args)
	259	{
	260	__glibcxx_check_insert(__pos);
	261	return
	262	{
	263	_Base::emplace_hint(__pos.base(), std::forward<_Args>(__args)...),
	264	this
	265	};
	266	}
	267	#endif
	268
	269	std::pair<iterator, bool>
	270	insert(const value_type& __x)
	271	{
	272	std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
	273	return std::pair<iterator, bool>(iterator(__res.first, this),
	274	__res.second);
	275	}
	276
	277	#if __cplusplus >= 201103L
	278	std::pair<iterator, bool>
	279	insert(value_type&& __x)
	280	{
	281	auto __res = _Base::insert(std::move(__x));
	282	return { { __res.first, this }, __res.second };
	283	}
	284	#endif
	285
	286	iterator
	287	insert(const_iterator __position, const value_type& __x)
	288	{
	289	__glibcxx_check_insert(__position);
	290	return iterator(_Base::insert(__position.base(), __x), this);
	291	}
	292
	293	#if __cplusplus >= 201103L
	294	iterator
	295	insert(const_iterator __position, value_type&& __x)
	296	{
	297	__glibcxx_check_insert(__position);
	298	return { _Base::insert(__position.base(), std::move(__x)), this };
	299	}
	300	#endif
	301
	302	template <typename _InputIterator>
	303	void
	304	insert(_InputIterator __first, _InputIterator __last)
	305	{
	306	typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
	307	__glibcxx_check_valid_range2(__first, __last, __dist);
	308
	309	if (__dist.second >= __gnu_debug::__dp_sign)
	310	_Base::insert(__gnu_debug::__unsafe(__first),
	311	__gnu_debug::__unsafe(__last));
	312	else
	313	_Base::insert(__first, __last);
	314	}
	315
	316	#if __cplusplus >= 201103L
	317	void
	318	insert(initializer_list<value_type> __l)
	319	{ _Base::insert(__l); }
	320	#endif
	321
	322	#if __cplusplus > 201402L
	323	using node_type = typename _Base::node_type;
	324	using insert_return_type = _Node_insert_return<iterator, node_type>;
	325
	326	node_type
	327	extract(const_iterator __position)
	328	{
	329	__glibcxx_check_erase(__position);
	330	this->_M_invalidate_if(_Equal(__position.base()));
	331	return _Base::extract(__position.base());
	332	}
	333
	334	node_type
	335	extract(const key_type& __key)
	336	{
	337	const auto __position = find(__key);
	338	if (__position != end())
	339	return extract(__position);
	340	return {};
	341	}
	342
	343	insert_return_type
	344	insert(node_type&& __nh)
	345	{
	346	auto __ret = _Base::insert(std::move(__nh));
	347	iterator __pos = iterator(__ret.position, this);
	348	return { __pos, __ret.inserted, std::move(__ret.node) };
	349	}
	350
	351	iterator
	352	insert(const_iterator __hint, node_type&& __nh)
	353	{
	354	__glibcxx_check_insert(__hint);
	355	return { _Base::insert(__hint.base(), std::move(__nh)), this };
	356	}
	357
	358	using _Base::merge;
	359	#endif // C++17
	360
	361	#if __cplusplus >= 201103L
	362	_GLIBCXX_ABI_TAG_CXX11
	363	iterator
	364	erase(const_iterator __position)
	365	{
	366	__glibcxx_check_erase(__position);
	367	return { erase(__position.base()), this };
	368	}
	369
	370	_Base_iterator
	371	erase(_Base_const_iterator __position)
	372	{
	373	__glibcxx_check_erase2(__position);
	374	this->_M_invalidate_if(_Equal(__position));
	375	return _Base::erase(__position);
	376	}
	377	#else
	378	void
	379	erase(iterator __position)
	380	{
	381	__glibcxx_check_erase(__position);
	382	this->_M_invalidate_if(_Equal(__position.base()));
	383	_Base::erase(__position.base());
	384	}
	385	#endif
	386
	387	size_type
	388	erase(const key_type& __x)
	389	{
	390	_Base_iterator __victim = _Base::find(__x);
	391	if (__victim == _Base::end())
	392	return 0;
	393	else
	394	{
	395	this->_M_invalidate_if(_Equal(__victim));
	396	_Base::erase(__victim);
	397	return 1;
	398	}
	399	}
	400
	401	#if __cplusplus >= 201103L
	402	_GLIBCXX_ABI_TAG_CXX11
	403	iterator
	404	erase(const_iterator __first, const_iterator __last)
	405	{
	406	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	407	// 151. can't currently clear() empty container
	408	__glibcxx_check_erase_range(__first, __last);
	409	for (_Base_const_iterator __victim = __first.base();
	410	__victim != __last.base(); ++__victim)
	411	{
	412	_GLIBCXX_DEBUG_VERIFY(__victim != _Base::cend(),
	413	_M_message(__gnu_debug::__msg_valid_range)
	414	._M_iterator(__first, "first")
	415	._M_iterator(__last, "last"));
	416	this->_M_invalidate_if(_Equal(__victim));
	417	}
	418
	419	return { _Base::erase(__first.base(), __last.base()), this };
	420	}
	421	#else
	422	void
	423	erase(iterator __first, iterator __last)
	424	{
	425	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	426	// 151. can't currently clear() empty container
	427	__glibcxx_check_erase_range(__first, __last);
	428	for (_Base_iterator __victim = __first.base();
	429	__victim != __last.base(); ++__victim)
	430	{
	431	_GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
	432	_M_message(__gnu_debug::__msg_valid_range)
	433	._M_iterator(__first, "first")
	434	._M_iterator(__last, "last"));
	435	this->_M_invalidate_if(_Equal(__victim));
	436	}
	437	_Base::erase(__first.base(), __last.base());
	438	}
	439	#endif
	440
	441	void
	442	swap(set& __x)
	443	_GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
	444	{
	445	_Safe::_M_swap(__x);
	446	_Base::swap(__x);
	447	}
	448
	449	void
	450	clear() _GLIBCXX_NOEXCEPT
	451	{
	452	this->_M_invalidate_all();
	453	_Base::clear();
	454	}
	455
	456	// observers:
	457	using _Base::key_comp;
	458	using _Base::value_comp;
	459
	460	// set operations:
	461	iterator
	462	find(const key_type& __x)
	463	{ return iterator(_Base::find(__x), this); }
	464
	465	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	466	// 214. set::find() missing const overload
	467	const_iterator
	468	find(const key_type& __x) const
	469	{ return const_iterator(_Base::find(__x), this); }
	470
	471	#if __cplusplus > 201103L
	472	template<typename _Kt,
	473	typename _Req =
	474	typename __has_is_transparent<_Compare, _Kt>::type>
	475	iterator
	476	find(const _Kt& __x)
	477	{ return { _Base::find(__x), this }; }
	478
	479	template<typename _Kt,
	480	typename _Req =
	481	typename __has_is_transparent<_Compare, _Kt>::type>
	482	const_iterator
	483	find(const _Kt& __x) const
	484	{ return { _Base::find(__x), this }; }
	485	#endif
	486
	487	using _Base::count;
	488
	489	iterator
	490	lower_bound(const key_type& __x)
	491	{ return iterator(_Base::lower_bound(__x), this); }
	492
	493	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	494	// 214. set::find() missing const overload
	495	const_iterator
	496	lower_bound(const key_type& __x) const
	497	{ return const_iterator(_Base::lower_bound(__x), this); }
	498
	499	#if __cplusplus > 201103L
	500	template<typename _Kt,
	501	typename _Req =
	502	typename __has_is_transparent<_Compare, _Kt>::type>
	503	iterator
	504	lower_bound(const _Kt& __x)
	505	{ return { _Base::lower_bound(__x), this }; }
	506
	507	template<typename _Kt,
	508	typename _Req =
	509	typename __has_is_transparent<_Compare, _Kt>::type>
	510	const_iterator
	511	lower_bound(const _Kt& __x) const
	512	{ return { _Base::lower_bound(__x), this }; }
	513	#endif
	514
	515	iterator
	516	upper_bound(const key_type& __x)
	517	{ return iterator(_Base::upper_bound(__x), this); }
	518
	519	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	520	// 214. set::find() missing const overload
	521	const_iterator
	522	upper_bound(const key_type& __x) const
	523	{ return const_iterator(_Base::upper_bound(__x), this); }
	524
	525	#if __cplusplus > 201103L
	526	template<typename _Kt,
	527	typename _Req =
	528	typename __has_is_transparent<_Compare, _Kt>::type>
	529	iterator
	530	upper_bound(const _Kt& __x)
	531	{ return { _Base::upper_bound(__x), this }; }
	532
	533	template<typename _Kt,
	534	typename _Req =
	535	typename __has_is_transparent<_Compare, _Kt>::type>
	536	const_iterator
	537	upper_bound(const _Kt& __x) const
	538	{ return { _Base::upper_bound(__x), this }; }
	539	#endif
	540
	541	std::pair<iterator, iterator>
	542	equal_range(const key_type& __x)
	543	{
	544	std::pair<_Base_iterator, _Base_iterator> __res =
	545	_Base::equal_range(__x);
	546	return std::make_pair(iterator(__res.first, this),
	547	iterator(__res.second, this));
	548	}
	549
	550	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	551	// 214. set::find() missing const overload
	552	std::pair<const_iterator, const_iterator>
	553	equal_range(const key_type& __x) const
	554	{
	555	std::pair<_Base_const_iterator, _Base_const_iterator> __res =
	556	_Base::equal_range(__x);
	557	return std::make_pair(const_iterator(__res.first, this),
	558	const_iterator(__res.second, this));
	559	}
	560
	561	#if __cplusplus > 201103L
	562	template<typename _Kt,
	563	typename _Req =
	564	typename __has_is_transparent<_Compare, _Kt>::type>
	565	std::pair<iterator, iterator>
	566	equal_range(const _Kt& __x)
	567	{
	568	auto __res = _Base::equal_range(__x);
	569	return { { __res.first, this }, { __res.second, this } };
	570	}
	571
	572	template<typename _Kt,
	573	typename _Req =
	574	typename __has_is_transparent<_Compare, _Kt>::type>
	575	std::pair<const_iterator, const_iterator>
	576	equal_range(const _Kt& __x) const
	577	{
	578	auto __res = _Base::equal_range(__x);
	579	return { { __res.first, this }, { __res.second, this } };
	580	}
	581	#endif
	582
	583	_Base&
	584	_M_base() _GLIBCXX_NOEXCEPT { return *this; }
	585
	586	const _Base&
	587	_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
	588	};
	589
	590	#if __cpp_deduction_guides >= 201606
	591
	592	template<typename _InputIterator,
	593	typename _Compare =
	594	less<typename iterator_traits<_InputIterator>::value_type>,
	595	typename _Allocator =
	596	allocator<typename iterator_traits<_InputIterator>::value_type>,
	597	typename = _RequireInputIter<_InputIterator>,
	598	typename = _RequireNotAllocator<_Compare>,
	599	typename = _RequireAllocator<_Allocator>>
	600	set(_InputIterator, _InputIterator,
	601	_Compare = _Compare(), _Allocator = _Allocator())
	602	-> set<typename iterator_traits<_InputIterator>::value_type,
	603	_Compare, _Allocator>;
	604
	605	template<typename _Key, typename _Compare = less<_Key>,
	606	typename _Allocator = allocator<_Key>,
	607	typename = _RequireNotAllocator<_Compare>,
	608	typename = _RequireAllocator<_Allocator>>
	609	set(initializer_list<_Key>,
	610	_Compare = _Compare(), _Allocator = _Allocator())
	611	-> set<_Key, _Compare, _Allocator>;
	612
	613	template<typename _InputIterator, typename _Allocator,
	614	typename = _RequireInputIter<_InputIterator>,
	615	typename = _RequireAllocator<_Allocator>>
	616	set(_InputIterator, _InputIterator, _Allocator)
	617	-> set<typename iterator_traits<_InputIterator>::value_type,
	618	less<typename iterator_traits<_InputIterator>::value_type>,
	619	_Allocator>;
	620
	621	template<typename _Key, typename _Allocator,
	622	typename = _RequireAllocator<_Allocator>>
	623	set(initializer_list<_Key>, _Allocator)
	624	-> set<_Key, less<_Key>, _Allocator>;
	625
	626	#if __glibcxx_containers_ranges // C++ >= 23
	627	template<ranges::input_range _Rg,
	628	__not_allocator_like _Compare = less<ranges::range_value_t<_Rg>>,
	629	__allocator_like _Alloc = std::allocator<ranges::range_value_t<_Rg>>>
	630	set(from_range_t, _Rg&&, _Compare = _Compare(), _Alloc = _Alloc())
	631	-> set<ranges::range_value_t<_Rg>, _Compare, _Alloc>;
	632
	633	template<ranges::input_range _Rg, __allocator_like _Alloc>
	634	set(from_range_t, _Rg&&, _Alloc)
	635	-> set<ranges::range_value_t<_Rg>, less<ranges::range_value_t<_Rg>>, _Alloc>;
	636	#endif
	637	#endif // deduction guides
	638
	639	template<typename _Key, typename _Compare, typename _Allocator>
	640	inline bool
	641	operator==(const set<_Key, _Compare, _Allocator>& __lhs,
	642	const set<_Key, _Compare, _Allocator>& __rhs)
	643	{ return __lhs._M_base() == __rhs._M_base(); }
	644
	645	#if __cpp_lib_three_way_comparison
	646	template<typename _Key, typename _Compare, typename _Alloc>
	647	inline __detail::__synth3way_t<_Key>
	648	operator<=>(const set<_Key, _Compare, _Alloc>& __lhs,
	649	const set<_Key, _Compare, _Alloc>& __rhs)
	650	{ return __lhs._M_base() <=> __rhs._M_base(); }
	651	#else
	652	template<typename _Key, typename _Compare, typename _Allocator>
	653	inline bool
	654	operator!=(const set<_Key, _Compare, _Allocator>& __lhs,
	655	const set<_Key, _Compare, _Allocator>& __rhs)
	656	{ return __lhs._M_base() != __rhs._M_base(); }
	657
	658	template<typename _Key, typename _Compare, typename _Allocator>
	659	inline bool
	660	operator<(const set<_Key, _Compare, _Allocator>& __lhs,
	661	const set<_Key, _Compare, _Allocator>& __rhs)
	662	{ return __lhs._M_base() < __rhs._M_base(); }
	663
	664	template<typename _Key, typename _Compare, typename _Allocator>
	665	inline bool
	666	operator<=(const set<_Key, _Compare, _Allocator>& __lhs,
	667	const set<_Key, _Compare, _Allocator>& __rhs)
	668	{ return __lhs._M_base() <= __rhs._M_base(); }
	669
	670	template<typename _Key, typename _Compare, typename _Allocator>
	671	inline bool
	672	operator>=(const set<_Key, _Compare, _Allocator>& __lhs,
	673	const set<_Key, _Compare, _Allocator>& __rhs)
	674	{ return __lhs._M_base() >= __rhs._M_base(); }
	675
	676	template<typename _Key, typename _Compare, typename _Allocator>
	677	inline bool
	678	operator>(const set<_Key, _Compare, _Allocator>& __lhs,
	679	const set<_Key, _Compare, _Allocator>& __rhs)
	680	{ return __lhs._M_base() > __rhs._M_base(); }
	681	#endif // three-way comparison
	682
	683	template<typename _Key, typename _Compare, typename _Allocator>
	684	void
	685	swap(set<_Key, _Compare, _Allocator>& __x,
	686	set<_Key, _Compare, _Allocator>& __y)
	687	_GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
	688	{ return __x.swap(__y); }
	689
	690	} // namespace __debug
	691	} // namespace std
	692
	693	#endif