Subversion Repositories altor32

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

// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011

// 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

// .

/** @file debug/bitset

 *  This file is a GNU debug extension to the Standard C++ Library.

 */

#ifndef _GLIBCXX_DEBUG_BITSET

#define _GLIBCXX_DEBUG_BITSET

#include 

#include 

#include 

namespace std _GLIBCXX_VISIBILITY(default)

{

namespace __debug

{

  /// Class std::bitset with additional safety/checking/debug instrumentation.

  template

    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++0x 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 __attribute__((__unused__))) _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(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(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

        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

        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

        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 

        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

        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

        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

        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

        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

        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, std::allocator >

      to_string() const

      {

        return to_string,std::allocator >();

      }

      std::basic_string, std::allocator >

      to_string(char __zero, char __one = '1') const

      {

        return to_string,

                         std::allocator >(__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

    bitset<_Nb>

    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT

    { return bitset<_Nb>(__x) &= __y; }

  template

    bitset<_Nb>

    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT

    { return bitset<_Nb>(__x) |= __y; }

  template

    bitset<_Nb>

    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT

    { return bitset<_Nb>(__x) ^= __y; }

  template

    std::basic_istream<_CharT, _Traits>&

    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)

    { return __is >> __x._M_base(); }

  template

    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

    struct hash<__debug::bitset<_Nb>>

    : public __hash_base>

    {

      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