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

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

// Copyright (C) 2003-2019 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; }

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

      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
d570f2e9	1	// Debugging bitset implementation -- C++ --
d570f2e9	2
fbd26352	3	// Copyright (C) 2003-2019 Free Software Foundation, Inc.
d570f2e9	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
6bc9506f	8	// Free Software Foundation; either version 3, or (at your option)
d570f2e9	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
6bc9506f	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/>.
d570f2e9	24
0e014800	25	/** @file debug/bitset
	26	* This file is a GNU debug extension to the Standard C++ Library.
	27	*/
	28
d570f2e9	29	#ifndef _GLIBCXX_DEBUG_BITSET
	30	#define _GLIBCXX_DEBUG_BITSET
	31
4477c18b	32	#pragma GCC system_header
4477c18b	33
d570f2e9	34	#include <bitset>
	35	#include <debug/safe_sequence.h>
	36	#include <debug/safe_iterator.h>
	37
2948dd21	38	namespace std _GLIBCXX_VISIBILITY(default)
1069247d	39	{
10c73e3f	40	namespace __debug
6a299e0b	41	{
5cb6199d	42	/// Class std::bitset with additional safety/checking/debug instrumentation.
6a299e0b	43	template<size_t _Nb>
d570f2e9	44	class bitset
2948dd21	45	: public _GLIBCXX_STD_C::bitset<_Nb>
0c8766b1	46	#if __cplusplus < 201103L
d7d0665f	47	, public __gnu_debug::_Safe_sequence_base
d7d0665f	48	#endif
d570f2e9	49	{
2948dd21	50	typedef _GLIBCXX_STD_C::bitset<_Nb> _Base;
d570f2e9	51
d570f2e9	52	public:
1eb7eb4d	53	// In C++11 we rely on normal reference type to preserve the property
c7d2e7f7	54	// of bitset to be use as a literal.
45e0b6c8	55	// TODO: Find another solution.
0c8766b1	56	#if __cplusplus >= 201103L
c7d2e7f7	57	typedef typename _Base::reference reference;
c7d2e7f7	58	#else
d570f2e9	59	// bit reference:
6a299e0b	60	class reference
d7d0665f	61	: private _Base::reference
d7d0665f	62	, public __gnu_debug::_Safe_iterator_base
d570f2e9	63	{
	64	typedef typename _Base::reference _Base_ref;
	65
	66	friend class bitset;
	67	reference();
6a299e0b	68
c7825a47	69	reference(const _Base_ref& __base, bitset* __seq) _GLIBCXX_NOEXCEPT
d7d0665f	70	: _Base_ref(__base)
d7d0665f	71	, _Safe_iterator_base(__seq, false)
d570f2e9	72	{ }
	73
	74	public:
7643295e	75	reference(const reference& __x) _GLIBCXX_NOEXCEPT
d7d0665f	76	: _Base_ref(__x)
d7d0665f	77	, _Safe_iterator_base(__x, false)
d570f2e9	78	{ }
d570f2e9	79
6a299e0b	80	reference&
7643295e	81	operator=(bool __x) _GLIBCXX_NOEXCEPT
d570f2e9	82	{
c7825a47	83	_GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
1069247d	84	_M_message(__gnu_debug::__msg_bad_bitset_write)
d570f2e9	85	._M_iterator(*this));
	86	static_cast<_Base_ref>(this) = __x;
	87	return *this;
	88	}
	89
6a299e0b	90	reference&
7643295e	91	operator=(const reference& __x) _GLIBCXX_NOEXCEPT
d570f2e9	92	{
c7825a47	93	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
1069247d	94	_M_message(__gnu_debug::__msg_bad_bitset_read)
d570f2e9	95	._M_iterator(__x));
c7825a47	96	_GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
1069247d	97	_M_message(__gnu_debug::__msg_bad_bitset_write)
d570f2e9	98	._M_iterator(*this));
	99	static_cast<_Base_ref>(this) = __x;
	100	return *this;
	101	}
6a299e0b	102
6a299e0b	103	bool
7643295e	104	operator~() const _GLIBCXX_NOEXCEPT
d570f2e9	105	{
c7825a47	106	_GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
1069247d	107	_M_message(__gnu_debug::__msg_bad_bitset_read)
d570f2e9	108	._M_iterator(*this));
	109	return ~(static_cast<const _Base_ref>(this));
	110	}
6a299e0b	111
7643295e	112	operator bool() const _GLIBCXX_NOEXCEPT
d570f2e9	113	{
c7825a47	114	_GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
1069247d	115	_M_message(__gnu_debug::__msg_bad_bitset_read)
d570f2e9	116	._M_iterator(*this));
	117	return static_cast<const _Base_ref>(this);
	118	}
6a299e0b	119
6a299e0b	120	reference&
7643295e	121	flip() _GLIBCXX_NOEXCEPT
d570f2e9	122	{
c7825a47	123	_GLIBCXX_DEBUG_VERIFY(!this->_M_singular(),
1069247d	124	_M_message(__gnu_debug::__msg_bad_bitset_flip)
d570f2e9	125	._M_iterator(*this));
	126	_Base_ref::flip();
	127	return *this;
	128	}
	129	};
c7d2e7f7	130	#endif
d570f2e9	131
d570f2e9	132	// 23.3.5.1 constructors:
7643295e	133	_GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT
7643295e	134	: _Base() { }
6a299e0b	135
0c8766b1	136	#if __cplusplus >= 201103L
7643295e	137	constexpr bitset(unsigned long long __val) noexcept
6fa56138	138	#else
	139	bitset(unsigned long __val)
	140	#endif
	141	: _Base(__val) { }
6a299e0b	142
c3d5e955	143	template<typename _CharT, typename _Traits, typename _Alloc>
6a299e0b	144	explicit
c3d5e955	145	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
c3d5e955	146	typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
d570f2e9	147	__pos = 0,
c3d5e955	148	typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
c3d5e955	149	__n = (std::basic_string<_CharT, _Traits, _Alloc>::npos))
d570f2e9	150	: _Base(__str, __pos, __n) { }
d570f2e9	151
c3d5e955	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
d7d0665f	163	bitset(const _Base& __x) : _Base(__x) { }
d570f2e9	164
0c8766b1	165	#if __cplusplus >= 201103L
0f0ce5ae	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) { }
433f8a43	173	#endif
433f8a43	174
d570f2e9	175	// 23.3.5.2 bitset operations:
6a299e0b	176	bitset<_Nb>&
7643295e	177	operator&=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
d570f2e9	178	{
	179	_M_base() &= __rhs;
	180	return *this;
	181	}
6a299e0b	182
6a299e0b	183	bitset<_Nb>&
7643295e	184	operator\|=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
d570f2e9	185	{
c46c0a29	186	_M_base() \|= __rhs;
d570f2e9	187	return *this;
d570f2e9	188	}
6a299e0b	189
6a299e0b	190	bitset<_Nb>&
7643295e	191	operator^=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
d570f2e9	192	{
	193	_M_base() ^= __rhs;
	194	return *this;
	195	}
6a299e0b	196
6a299e0b	197	bitset<_Nb>&
7643295e	198	operator<<=(size_t __pos) _GLIBCXX_NOEXCEPT
d570f2e9	199	{
	200	_M_base() <<= __pos;
	201	return *this;
	202	}
6a299e0b	203
6a299e0b	204	bitset<_Nb>&
7643295e	205	operator>>=(size_t __pos) _GLIBCXX_NOEXCEPT
d570f2e9	206	{
	207	_M_base() >>= __pos;
	208	return *this;
	209	}
6a299e0b	210
6a299e0b	211	bitset<_Nb>&
7643295e	212	set() _GLIBCXX_NOEXCEPT
d570f2e9	213	{
	214	_Base::set();
	215	return *this;
	216	}
6a299e0b	217
d570f2e9	218	// _GLIBCXX_RESOLVE_LIB_DEFECTS
6a299e0b	219	// 186. bitset::set() second parameter should be bool
6a299e0b	220	bitset<_Nb>&
d570f2e9	221	set(size_t __pos, bool __val = true)
	222	{
	223	_Base::set(__pos, __val);
	224	return *this;
	225	}
6a299e0b	226
6a299e0b	227	bitset<_Nb>&
7643295e	228	reset() _GLIBCXX_NOEXCEPT
d570f2e9	229	{
	230	_Base::reset();
	231	return *this;
	232	}
6a299e0b	233
6a299e0b	234	bitset<_Nb>&
d570f2e9	235	reset(size_t __pos)
	236	{
	237	_Base::reset(__pos);
	238	return *this;
	239	}
6a299e0b	240
7643295e	241	bitset<_Nb>
	242	operator~() const _GLIBCXX_NOEXCEPT
	243	{ return bitset(~_M_base()); }
6a299e0b	244
6a299e0b	245	bitset<_Nb>&
7643295e	246	flip() _GLIBCXX_NOEXCEPT
d570f2e9	247	{
	248	_Base::flip();
	249	return *this;
	250	}
6a299e0b	251
6a299e0b	252	bitset<_Nb>&
d570f2e9	253	flip(size_t __pos)
	254	{
	255	_Base::flip(__pos);
	256	return *this;
	257	}
6a299e0b	258
d570f2e9	259	// element access:
d570f2e9	260	// _GLIBCXX_RESOLVE_LIB_DEFECTS
6a299e0b	261	// 11. Bitset minor problems
6a299e0b	262	reference
d570f2e9	263	operator[](size_t __pos)
6a299e0b	264	{
d570f2e9	265	__glibcxx_check_subscript(__pos);
0c8766b1	266	#if __cplusplus >= 201103L
c7d2e7f7	267	return _M_base()[__pos];
c7d2e7f7	268	#else
6a299e0b	269	return reference(_M_base()[__pos], this);
c7d2e7f7	270	#endif
d570f2e9	271	}
6a299e0b	272
d570f2e9	273	// _GLIBCXX_RESOLVE_LIB_DEFECTS
6a299e0b	274	// 11. Bitset minor problems
45e0b6c8	275	_GLIBCXX_CONSTEXPR bool
6a299e0b	276	operator[](size_t __pos) const
6a299e0b	277	{
0c8766b1	278	#if __cplusplus < 201103L
45e0b6c8	279	// TODO: Check in debug-mode too.
d570f2e9	280	__glibcxx_check_subscript(__pos);
45e0b6c8	281	#endif
45e0b6c8	282	return _Base::operator[](__pos);
d570f2e9	283	}
6a299e0b	284
d570f2e9	285	using _Base::to_ulong;
0c8766b1	286	#if __cplusplus >= 201103L
2ad15b7c	287	using _Base::to_ullong;
2ad15b7c	288	#endif
6a299e0b	289
c3d5e955	290	template <typename _CharT, typename _Traits, typename _Alloc>
c3d5e955	291	std::basic_string<_CharT, _Traits, _Alloc>
d570f2e9	292	to_string() const
c3d5e955	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	}
6a299e0b	304
436098f3	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
c3d5e955	312	// _GLIBCXX_RESOLVE_LIB_DEFECTS
56cb6c7d	313	// 853. to_string needs updating with zero and one.
c3d5e955	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
436098f3	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
c3d5e955	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
436098f3	338	std::basic_string<char, std::char_traits<char>, std::allocator<char> >
c3d5e955	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	}
436098f3	350
d570f2e9	351	using _Base::count;
d570f2e9	352	using _Base::size;
6a299e0b	353
6a299e0b	354	bool
7643295e	355	operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
d570f2e9	356	{ return _M_base() == __rhs; }
d570f2e9	357
6a299e0b	358	bool
7643295e	359	operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
d570f2e9	360	{ return _M_base() != __rhs; }
6a299e0b	361
d570f2e9	362	using _Base::test;
731b672f	363	using _Base::all;
d570f2e9	364	using _Base::any;
d570f2e9	365	using _Base::none;
6a299e0b	366
6a299e0b	367	bitset<_Nb>
7643295e	368	operator<<(size_t __pos) const _GLIBCXX_NOEXCEPT
d570f2e9	369	{ return bitset<_Nb>(_M_base() << __pos); }
6a299e0b	370
6a299e0b	371	bitset<_Nb>
7643295e	372	operator>>(size_t __pos) const _GLIBCXX_NOEXCEPT
d570f2e9	373	{ return bitset<_Nb>(_M_base() >> __pos); }
6a299e0b	374
7643295e	375	_Base&
	376	_M_base() _GLIBCXX_NOEXCEPT
	377	{ return *this; }
d570f2e9	378
6a299e0b	379	const _Base&
7643295e	380	_M_base() const _GLIBCXX_NOEXCEPT
7643295e	381	{ return *this; }
d570f2e9	382	};
6a299e0b	383
d570f2e9	384	template<size_t _Nb>
6a299e0b	385	bitset<_Nb>
7643295e	386	operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
d570f2e9	387	{ return bitset<_Nb>(__x) &= __y; }
6a299e0b	388
d570f2e9	389	template<size_t _Nb>
6a299e0b	390	bitset<_Nb>
7643295e	391	operator\|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
d570f2e9	392	{ return bitset<_Nb>(__x) \|= __y; }
	393
	394	template<size_t _Nb>
6a299e0b	395	bitset<_Nb>
7643295e	396	operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
d570f2e9	397	{ return bitset<_Nb>(__x) ^= __y; }
	398
	399	template<typename _CharT, typename _Traits, size_t _Nb>
	400	std::basic_istream<_CharT, _Traits>&
	401	operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
	402	{ return __is >> __x._M_base(); }
	403
	404	template<typename _CharT, typename _Traits, size_t _Nb>
	405	std::basic_ostream<_CharT, _Traits>&
6a299e0b	406	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
d570f2e9	407	const bitset<_Nb>& __x)
d570f2e9	408	{ return __os << __x._M_base(); }
5cb6199d	409
10c73e3f	410	} // namespace __debug
b6c27c10	411
0c8766b1	412	#if __cplusplus >= 201103L
b6c27c10	413	// DR 1182.
	414	/// std::hash specialization for bitset.
	415	template<size_t _Nb>
7b80cc2b	416	struct hash<__debug::bitset<_Nb>>
a0f415f0	417	: public __hash_base<size_t, __debug::bitset<_Nb>>
b6c27c10	418	{
b6c27c10	419	size_t
d377f164	420	operator()(const __debug::bitset<_Nb>& __b) const noexcept
2948dd21	421	{ return std::hash<_GLIBCXX_STD_C::bitset<_Nb>>()(__b._M_base()); }
b6c27c10	422	};
	423	#endif
	424
1069247d	425	} // namespace std
d570f2e9	426
d570f2e9	427	#endif