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

// Debugging bitset implementation -*- C++ -*-

// Copyright (C) 2003-2021 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/bitset
 *  This file is a GNU debug extension to the Standard C++ Library.
 */

#ifndef _GLIBCXX_DEBUG_BITSET
#define _GLIBCXX_DEBUG_BITSET

#pragma GCC system_header

#include <bitset>
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
  /// Class std::bitset with additional safety/checking/debug instrumentation.
  template<size_t _Nb>
    class bitset
    : public _GLIBCXX_STD_C::bitset<_Nb>
#if __cplusplus < 201103L
    , public __gnu_debug::_Safe_sequence_base
#endif
    {
      typedef _GLIBCXX_STD_C::bitset<_Nb> _Base;

    public:
      // In C++11 we rely on normal reference type to preserve the property
      // of bitset to be use as a literal.
      // TODO: Find another solution.
#if __cplusplus >= 201103L
      typedef typename _Base::reference reference;
#else
      // bit reference:
      class reference
      : private _Base::reference
        , public __gnu_debug::_Safe_iterator_base
      {
	typedef typename _Base::reference _Base_ref;

	friend class bitset;
	reference();

	reference(const _Base_ref& __base, bitset* __seq) _GLIBCXX_NOEXCEPT
	: _Base_ref(__base)
	, _Safe_iterator_base(__seq, false)
	{ }

      public:
	reference(const reference& __x) _GLIBCXX_NOEXCEPT
	: _Base_ref(__x)
	, _Safe_iterator_base(__x, false)
	{ }

	reference&
	operator=(bool __x) _GLIBCXX_NOEXCEPT
	{
	  _GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
			      _M_message(__gnu_debug::__msg_bad_bitset_write)
				._M_iterator(*this));
	  *static_cast<_Base_ref*>(this) = __x;
	  return *this;
	}

	reference&
	operator=(const reference& __x) _GLIBCXX_NOEXCEPT
	{
	  _GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
			       _M_message(__gnu_debug::__msg_bad_bitset_read)
				._M_iterator(__x));
	  _GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
			      _M_message(__gnu_debug::__msg_bad_bitset_write)
				._M_iterator(*this));
	  *static_cast<_Base_ref*>(this) = __x;
	  return *this;
	}

	bool
	operator~() const _GLIBCXX_NOEXCEPT
	{
	  _GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
			       _M_message(__gnu_debug::__msg_bad_bitset_read)
				._M_iterator(*this));
	  return ~(*static_cast<const _Base_ref*>(this));
	}

	operator bool() const _GLIBCXX_NOEXCEPT
	{
	  _GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
			      _M_message(__gnu_debug::__msg_bad_bitset_read)
				._M_iterator(*this));
	  return *static_cast<const _Base_ref*>(this);
	}

	reference&
	flip() _GLIBCXX_NOEXCEPT
	{
	  _GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
			      _M_message(__gnu_debug::__msg_bad_bitset_flip)
				._M_iterator(*this));
	  _Base_ref::flip();
	  return *this;
	}
      };
#endif

      // 23.3.5.1 constructors:
      _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT
      : _Base() { }

#if __cplusplus >= 201103L
      constexpr bitset(unsigned long long __val) noexcept
#else
      bitset(unsigned long __val)
#endif
      : _Base(__val) { }

      template<typename _CharT, typename _Traits, typename _Alloc>
        explicit
        bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
	       __pos = 0,
	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
	       __n = (std::basic_string<_CharT, _Traits, _Alloc>::npos))
	: _Base(__str, __pos, __n) { }

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 396. what are characters zero and one.
      template<class _CharT, class _Traits, class _Alloc>
	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
	       __pos,
	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
	       __n,
	       _CharT __zero, _CharT __one = _CharT('1'))
	: _Base(__str, __pos, __n, __zero, __one) { }

      bitset(const _Base& __x) : _Base(__x) { }

#if __cplusplus >= 201103L
      template<typename _CharT>
        explicit
        bitset(const _CharT* __str,
	       typename std::basic_string<_CharT>::size_type __n
	       = std::basic_string<_CharT>::npos,
	       _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
	: _Base(__str, __n, __zero, __one) { }
#endif

      // 23.3.5.2 bitset operations:
      bitset<_Nb>&
      operator&=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
      {
	_M_base() &= __rhs;
	return *this;
      }

      bitset<_Nb>&
      operator|=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
      {
	_M_base() |= __rhs;
	return *this;
      }

      bitset<_Nb>&
      operator^=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
      {
	_M_base() ^= __rhs;
	return *this;
      }

      bitset<_Nb>&
      operator<<=(size_t __pos) _GLIBCXX_NOEXCEPT
      {
	_M_base() <<= __pos;
	return *this;
      }

      bitset<_Nb>&
      operator>>=(size_t __pos) _GLIBCXX_NOEXCEPT
      {
	_M_base() >>= __pos;
	return *this;
      }

      bitset<_Nb>&
      set() _GLIBCXX_NOEXCEPT
      {
	_Base::set();
	return *this;
      }

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 186. bitset::set() second parameter should be bool
      bitset<_Nb>&
      set(size_t __pos, bool __val = true)
      {
	_Base::set(__pos, __val);
	return *this;
      }

      bitset<_Nb>&
      reset() _GLIBCXX_NOEXCEPT
      {
	_Base::reset();
	return *this;
      }

      bitset<_Nb>&
      reset(size_t __pos)
      {
	_Base::reset(__pos);
	return *this;
      }

      bitset<_Nb>
      operator~() const _GLIBCXX_NOEXCEPT
      { return bitset(~_M_base()); }

      bitset<_Nb>&
      flip() _GLIBCXX_NOEXCEPT
      {
	_Base::flip();
	return *this;
      }

      bitset<_Nb>&
      flip(size_t __pos)
      {
	_Base::flip(__pos);
	return *this;
      }

      // element access:
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 11. Bitset minor problems
      reference
      operator[](size_t __pos)
      {
	__glibcxx_check_subscript(__pos);
#if __cplusplus >= 201103L
	return _M_base()[__pos];
#else
	return reference(_M_base()[__pos], this);
#endif
      }

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 11. Bitset minor problems
      _GLIBCXX_CONSTEXPR bool
      operator[](size_t __pos) const
      {
#if __cplusplus < 201103L
	// TODO: Check in debug-mode too.
	__glibcxx_check_subscript(__pos);
#endif
	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._M_base(); }

#if __cpp_impl_three_way_comparison < 201907L
      bool
      operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
      { return _M_base() != __rhs._M_base(); }
#endif

      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); }

      bitset<_Nb>
      operator>>(size_t __pos) const _GLIBCXX_NOEXCEPT
      { return bitset<_Nb>(_M_base() >> __pos); }

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

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

  template<size_t _Nb>
    bitset<_Nb>
    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
    { return bitset<_Nb>(__x) &= __y; }

  template<size_t _Nb>
    bitset<_Nb>
    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
    { return bitset<_Nb>(__x) |= __y; }

  template<size_t _Nb>
    bitset<_Nb>
    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
    { return bitset<_Nb>(__x) ^= __y; }

  template<typename _CharT, typename _Traits, size_t _Nb>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
    { return __is >> __x._M_base(); }

  template<typename _CharT, typename _Traits, size_t _Nb>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
	       const bitset<_Nb>& __x)
    { return __os << __x._M_base(); }

} // namespace __debug

#if __cplusplus >= 201103L
  // DR 1182.
  /// std::hash specialization for bitset.
  template<size_t _Nb>
    struct hash<__debug::bitset<_Nb>>
    : public __hash_base<size_t, __debug::bitset<_Nb>>
    {
      size_t
      operator()(const __debug::bitset<_Nb>& __b) const noexcept
      { return std::hash<_GLIBCXX_STD_C::bitset<_Nb>>()(__b._M_base()); }
    };
#endif

} // namespace std

#endif
Commit	Line	Data
285b36d6 BK	1	// Debugging bitset implementation -- C++ --
285b36d6 BK	2
99dee823	3	// Copyright (C) 2003-2021 Free Software Foundation, Inc.
285b36d6 BK	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
748086b7	8	// Free Software Foundation; either version 3, or (at your option)
285b36d6 BK	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
748086b7 JJ	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/>.
285b36d6	24
78a53887 BK	25	/** @file debug/bitset
	26	* This file is a GNU debug extension to the Standard C++ Library.
	27	*/
	28
285b36d6 BK	29	#ifndef _GLIBCXX_DEBUG_BITSET
	30	#define _GLIBCXX_DEBUG_BITSET
	31
541a9b10 JW	32	#pragma GCC system_header
541a9b10 JW	33
285b36d6 BK	34	#include <bitset>
	35	#include <debug/safe_sequence.h>
	36	#include <debug/safe_iterator.h>
	37
12ffa228	38	namespace std _GLIBCXX_VISIBILITY(default)
3cbc7af0	39	{
45f388bb	40	namespace __debug
526da49c	41	{
1ceb9e06	42	/// Class std::bitset with additional safety/checking/debug instrumentation.
526da49c	43	template<size_t _Nb>
285b36d6	44	class bitset
12ffa228	45	: public _GLIBCXX_STD_C::bitset<_Nb>
734f5023	46	#if __cplusplus < 201103L
17e3f4aa PC	47	, public __gnu_debug::_Safe_sequence_base
17e3f4aa PC	48	#endif
285b36d6	49	{
12ffa228	50	typedef _GLIBCXX_STD_C::bitset<_Nb> _Base;
285b36d6 BK	51
285b36d6 BK	52	public:
4f5f9962	53	// In C++11 we rely on normal reference type to preserve the property
c5589aa7	54	// of bitset to be use as a literal.
fc09e5b6	55	// TODO: Find another solution.
734f5023	56	#if __cplusplus >= 201103L
c5589aa7 FD	57	typedef typename _Base::reference reference;
c5589aa7 FD	58	#else
285b36d6	59	// bit reference:
526da49c	60	class reference
17e3f4aa	61	: private _Base::reference
17e3f4aa	62	, public __gnu_debug::_Safe_iterator_base
285b36d6 BK	63	{
	64	typedef typename _Base::reference _Base_ref;
	65
	66	friend class bitset;
	67	reference();
526da49c	68
5d045324	69	reference(const _Base_ref& __base, bitset* __seq) _GLIBCXX_NOEXCEPT
17e3f4aa	70	: _Base_ref(__base)
17e3f4aa	71	, _Safe_iterator_base(__seq, false)
285b36d6 BK	72	{ }
	73
	74	public:
5d861bf2	75	reference(const reference& __x) _GLIBCXX_NOEXCEPT
17e3f4aa	76	: _Base_ref(__x)
17e3f4aa	77	, _Safe_iterator_base(__x, false)
285b36d6 BK	78	{ }
285b36d6 BK	79
526da49c	80	reference&
5d861bf2	81	operator=(bool __x) _GLIBCXX_NOEXCEPT
285b36d6	82	{
5d045324	83	_GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
3cbc7af0	84	_M_message(__gnu_debug::__msg_bad_bitset_write)
285b36d6 BK	85	._M_iterator(*this));
	86	static_cast<_Base_ref>(this) = __x;
	87	return *this;
	88	}
	89
526da49c	90	reference&
5d861bf2	91	operator=(const reference& __x) _GLIBCXX_NOEXCEPT
285b36d6	92	{
5d045324	93	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
3cbc7af0	94	_M_message(__gnu_debug::__msg_bad_bitset_read)
285b36d6	95	._M_iterator(__x));
5d045324	96	_GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
3cbc7af0	97	_M_message(__gnu_debug::__msg_bad_bitset_write)
285b36d6 BK	98	._M_iterator(*this));
	99	static_cast<_Base_ref>(this) = __x;
	100	return *this;
	101	}
526da49c BI	102
526da49c BI	103	bool
5d861bf2	104	operator~() const _GLIBCXX_NOEXCEPT
285b36d6	105	{
5d045324	106	_GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
3cbc7af0	107	_M_message(__gnu_debug::__msg_bad_bitset_read)
285b36d6 BK	108	._M_iterator(*this));
	109	return ~(static_cast<const _Base_ref>(this));
	110	}
526da49c	111
5d861bf2	112	operator bool() const _GLIBCXX_NOEXCEPT
285b36d6	113	{
5d045324	114	_GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
3cbc7af0	115	_M_message(__gnu_debug::__msg_bad_bitset_read)
285b36d6 BK	116	._M_iterator(*this));
	117	return static_cast<const _Base_ref>(this);
	118	}
526da49c BI	119
526da49c BI	120	reference&
5d861bf2	121	flip() _GLIBCXX_NOEXCEPT
285b36d6	122	{
5d045324	123	_GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
3cbc7af0	124	_M_message(__gnu_debug::__msg_bad_bitset_flip)
285b36d6 BK	125	._M_iterator(*this));
	126	_Base_ref::flip();
	127	return *this;
	128	}
	129	};
c5589aa7	130	#endif
285b36d6 BK	131
285b36d6 BK	132	// 23.3.5.1 constructors:
5d861bf2 PC	133	_GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT
5d861bf2 PC	134	: _Base() { }
526da49c	135
734f5023	136	#if __cplusplus >= 201103L
5d861bf2	137	constexpr bitset(unsigned long long __val) noexcept
eb07a8f5 PC	138	#else
	139	bitset(unsigned long __val)
	140	#endif
	141	: _Base(__val) { }
526da49c	142
47cd1557	143	template<typename _CharT, typename _Traits, typename _Alloc>
526da49c	144	explicit
47cd1557 PC	145	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
47cd1557 PC	146	typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
285b36d6	147	__pos = 0,
47cd1557 PC	148	typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
47cd1557 PC	149	__n = (std::basic_string<_CharT, _Traits, _Alloc>::npos))
285b36d6 BK	150	: _Base(__str, __pos, __n) { }
285b36d6 BK	151
47cd1557 PC	152	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	153	// 396. what are characters zero and one.
	154	template<class _CharT, class _Traits, class _Alloc>
	155	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
	156	typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
	157	__pos,
	158	typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
	159	__n,
	160	_CharT __zero, _CharT __one = _CharT('1'))
	161	: _Base(__str, __pos, __n, __zero, __one) { }
	162
17e3f4aa	163	bitset(const _Base& __x) : _Base(__x) { }
285b36d6	164
734f5023	165	#if __cplusplus >= 201103L
a0a2a399 PC	166	template<typename _CharT>
	167	explicit
	168	bitset(const _CharT* __str,
	169	typename std::basic_string<_CharT>::size_type __n
	170	= std::basic_string<_CharT>::npos,
	171	_CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
	172	: _Base(__str, __n, __zero, __one) { }
2838468c PC	173	#endif
2838468c PC	174
285b36d6	175	// 23.3.5.2 bitset operations:
526da49c	176	bitset<_Nb>&
5d861bf2	177	operator&=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
285b36d6 BK	178	{
	179	_M_base() &= __rhs;
	180	return *this;
	181	}
526da49c BI	182
526da49c BI	183	bitset<_Nb>&
5d861bf2	184	operator\|=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
285b36d6	185	{
72afd981	186	_M_base() \|= __rhs;
285b36d6 BK	187	return *this;
285b36d6 BK	188	}
526da49c BI	189
526da49c BI	190	bitset<_Nb>&
5d861bf2	191	operator^=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
285b36d6 BK	192	{
	193	_M_base() ^= __rhs;
	194	return *this;
	195	}
526da49c BI	196
526da49c BI	197	bitset<_Nb>&
5d861bf2	198	operator<<=(size_t __pos) _GLIBCXX_NOEXCEPT
285b36d6 BK	199	{
	200	_M_base() <<= __pos;
	201	return *this;
	202	}
526da49c BI	203
526da49c BI	204	bitset<_Nb>&
5d861bf2	205	operator>>=(size_t __pos) _GLIBCXX_NOEXCEPT
285b36d6 BK	206	{
	207	_M_base() >>= __pos;
	208	return *this;
	209	}
526da49c BI	210
526da49c BI	211	bitset<_Nb>&
5d861bf2	212	set() _GLIBCXX_NOEXCEPT
285b36d6 BK	213	{
	214	_Base::set();
	215	return *this;
	216	}
526da49c	217
285b36d6	218	// _GLIBCXX_RESOLVE_LIB_DEFECTS
526da49c BI	219	// 186. bitset::set() second parameter should be bool
526da49c BI	220	bitset<_Nb>&
285b36d6 BK	221	set(size_t __pos, bool __val = true)
	222	{
	223	_Base::set(__pos, __val);
	224	return *this;
	225	}
526da49c BI	226
526da49c BI	227	bitset<_Nb>&
5d861bf2	228	reset() _GLIBCXX_NOEXCEPT
285b36d6 BK	229	{
	230	_Base::reset();
	231	return *this;
	232	}
526da49c BI	233
526da49c BI	234	bitset<_Nb>&
285b36d6 BK	235	reset(size_t __pos)
	236	{
	237	_Base::reset(__pos);
	238	return *this;
	239	}
526da49c	240
5d861bf2 PC	241	bitset<_Nb>
	242	operator~() const _GLIBCXX_NOEXCEPT
	243	{ return bitset(~_M_base()); }
526da49c BI	244
526da49c BI	245	bitset<_Nb>&
5d861bf2	246	flip() _GLIBCXX_NOEXCEPT
285b36d6 BK	247	{
	248	_Base::flip();
	249	return *this;
	250	}
526da49c BI	251
526da49c BI	252	bitset<_Nb>&
285b36d6 BK	253	flip(size_t __pos)
	254	{
	255	_Base::flip(__pos);
	256	return *this;
	257	}
526da49c	258
285b36d6 BK	259	// element access:
285b36d6 BK	260	// _GLIBCXX_RESOLVE_LIB_DEFECTS
526da49c BI	261	// 11. Bitset minor problems
526da49c BI	262	reference
285b36d6	263	operator[](size_t __pos)
526da49c	264	{
285b36d6	265	__glibcxx_check_subscript(__pos);
734f5023	266	#if __cplusplus >= 201103L
c5589aa7 FD	267	return _M_base()[__pos];
c5589aa7 FD	268	#else
526da49c	269	return reference(_M_base()[__pos], this);
c5589aa7	270	#endif
285b36d6	271	}
526da49c	272
285b36d6	273	// _GLIBCXX_RESOLVE_LIB_DEFECTS
526da49c	274	// 11. Bitset minor problems
fc09e5b6	275	_GLIBCXX_CONSTEXPR bool
526da49c BI	276	operator[](size_t __pos) const
526da49c BI	277	{
734f5023	278	#if __cplusplus < 201103L
fc09e5b6	279	// TODO: Check in debug-mode too.
285b36d6	280	__glibcxx_check_subscript(__pos);
fc09e5b6 PC	281	#endif
fc09e5b6 PC	282	return _Base::operator[](__pos);
285b36d6	283	}
526da49c	284
285b36d6	285	using _Base::to_ulong;
734f5023	286	#if __cplusplus >= 201103L
700d2899 PC	287	using _Base::to_ullong;
700d2899 PC	288	#endif
526da49c	289
47cd1557 PC	290	template <typename _CharT, typename _Traits, typename _Alloc>
47cd1557 PC	291	std::basic_string<_CharT, _Traits, _Alloc>
285b36d6	292	to_string() const
47cd1557 PC	293	{ return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }
	294
	295	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	296	// 396. what are characters zero and one.
	297	template<class _CharT, class _Traits, class _Alloc>
	298	std::basic_string<_CharT, _Traits, _Alloc>
	299	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
	300	{
	301	return _M_base().template
	302	to_string<_CharT, _Traits, _Alloc>(__zero, __one);
	303	}
526da49c	304
48cf14eb JW	305	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	306	// 434. bitset::to_string() hard to use.
	307	template<typename _CharT, typename _Traits>
	308	std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
	309	to_string() const
	310	{ return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
	311
47cd1557	312	// _GLIBCXX_RESOLVE_LIB_DEFECTS
19a6a2ea	313	// 853. to_string needs updating with zero and one.
47cd1557 PC	314	template<class _CharT, class _Traits>
	315	std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
	316	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
	317	{ return to_string<_CharT, _Traits,
	318	std::allocator<_CharT> >(__zero, __one); }
	319
48cf14eb JW	320	template<typename _CharT>
	321	std::basic_string<_CharT, std::char_traits<_CharT>,
	322	std::allocator<_CharT> >
	323	to_string() const
	324	{
	325	return to_string<_CharT, std::char_traits<_CharT>,
	326	std::allocator<_CharT> >();
	327	}
	328
47cd1557 PC	329	template<class _CharT>
	330	std::basic_string<_CharT, std::char_traits<_CharT>,
	331	std::allocator<_CharT> >
	332	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
	333	{
	334	return to_string<_CharT, std::char_traits<_CharT>,
	335	std::allocator<_CharT> >(__zero, __one);
	336	}
	337
48cf14eb	338	std::basic_string<char, std::char_traits<char>, std::allocator<char> >
47cd1557 PC	339	to_string() const
	340	{
	341	return to_string<char,std::char_traits<char>,std::allocator<char> >();
	342	}
	343
	344	std::basic_string<char, std::char_traits<char>, std::allocator<char> >
	345	to_string(char __zero, char __one = '1') const
	346	{
	347	return to_string<char, std::char_traits<char>,
	348	std::allocator<char> >(__zero, __one);
	349	}
48cf14eb	350
285b36d6 BK	351	using _Base::count;
285b36d6 BK	352	using _Base::size;
526da49c BI	353
526da49c BI	354	bool
5d861bf2	355	operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
de1e3b87	356	{ return _M_base() == __rhs._M_base(); }
285b36d6	357
de1e3b87	358	#if __cpp_impl_three_way_comparison < 201907L
526da49c	359	bool
5d861bf2	360	operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
de1e3b87 JW	361	{ return _M_base() != __rhs._M_base(); }
de1e3b87 JW	362	#endif
526da49c	363
285b36d6	364	using _Base::test;
b96817da	365	using _Base::all;
285b36d6 BK	366	using _Base::any;
285b36d6 BK	367	using _Base::none;
526da49c BI	368
526da49c BI	369	bitset<_Nb>
5d861bf2	370	operator<<(size_t __pos) const _GLIBCXX_NOEXCEPT
285b36d6	371	{ return bitset<_Nb>(_M_base() << __pos); }
526da49c BI	372
526da49c BI	373	bitset<_Nb>
5d861bf2	374	operator>>(size_t __pos) const _GLIBCXX_NOEXCEPT
285b36d6	375	{ return bitset<_Nb>(_M_base() >> __pos); }
526da49c	376
5d861bf2 PC	377	_Base&
	378	_M_base() _GLIBCXX_NOEXCEPT
	379	{ return *this; }
285b36d6	380
526da49c	381	const _Base&
5d861bf2 PC	382	_M_base() const _GLIBCXX_NOEXCEPT
5d861bf2 PC	383	{ return *this; }
285b36d6	384	};
526da49c	385
285b36d6	386	template<size_t _Nb>
526da49c	387	bitset<_Nb>
5d861bf2	388	operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
285b36d6	389	{ return bitset<_Nb>(__x) &= __y; }
526da49c	390
285b36d6	391	template<size_t _Nb>
526da49c	392	bitset<_Nb>
5d861bf2	393	operator\|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
285b36d6 BK	394	{ return bitset<_Nb>(__x) \|= __y; }
	395
	396	template<size_t _Nb>
526da49c	397	bitset<_Nb>
5d861bf2	398	operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
285b36d6 BK	399	{ return bitset<_Nb>(__x) ^= __y; }
	400
	401	template<typename _CharT, typename _Traits, size_t _Nb>
	402	std::basic_istream<_CharT, _Traits>&
	403	operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
	404	{ return __is >> __x._M_base(); }
	405
	406	template<typename _CharT, typename _Traits, size_t _Nb>
	407	std::basic_ostream<_CharT, _Traits>&
526da49c	408	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
285b36d6 BK	409	const bitset<_Nb>& __x)
285b36d6 BK	410	{ return __os << __x._M_base(); }
1ceb9e06	411
45f388bb	412	} // namespace __debug
ec7058d6	413
734f5023	414	#if __cplusplus >= 201103L
ec7058d6 PC	415	// DR 1182.
	416	/// std::hash specialization for bitset.
	417	template<size_t _Nb>
95addb1b	418	struct hash<__debug::bitset<_Nb>>
5d64ee19	419	: public __hash_base<size_t, __debug::bitset<_Nb>>
ec7058d6 PC	420	{
ec7058d6 PC	421	size_t
72f1c34b	422	operator()(const __debug::bitset<_Nb>& __b) const noexcept
12ffa228	423	{ return std::hash<_GLIBCXX_STD_C::bitset<_Nb>>()(__b._M_base()); }
ec7058d6 PC	424	};
	425	#endif
	426
3cbc7af0	427	} // namespace std
285b36d6 BK	428
285b36d6 BK	429	#endif