bitset

symbian上STL模板库的实现

// <bitset> -*- C++ -*-

// Copyright (C) 2001, 2002, 2003, 2004 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 2, 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.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

/*
 * Copyright (c) 1998
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 */

/** @file bitset
 *  This is a Standard C++ Library header.  You should @c #include this header
 *  in your programs, rather than any of the "st[dl]_*.h" implementation files.
 */

#ifndef _GLIBCXX_BITSET
#define _GLIBCXX_BITSET 1

//#pragma GCC system_header

#include <cstddef>     // For size_t
#include <cstring>     // For memset
#include <limits>      // For numeric_limits
#include <string>
#include <bits/functexcept.h>   // For invalid_argument, out_of_range,
// overflow_error
#include <ostream>     // For ostream (operator<<)
#include <istream>     // For istream (operator>>)

#define _GLIBCXX_BITSET_BITS_PER_WORD  numeric_limits<unsigned long>::digits
#define _GLIBCXX_BITSET_WORDS(__n) \
    ((__n) < 1 ? 0 : ((__n) + _GLIBCXX_BITSET_BITS_PER_WORD - 1)/_GLIBCXX_BITSET_BITS_PER_WORD)

namespace _GLIBCXX_STD
{
    /**
     *  @if maint
     *  Base class, general case.  It is a class inveriant that _Nw will be
     *  nonnegative.
     *
     *  See documentation for bitset.
     *  @endif
     */
    template<size_t _Nw>
        struct _Base_bitset
        {
            typedef unsigned long _WordT;

            /// 0 is the least significant word.
            _WordT 		_M_w[_Nw];

            _Base_bitset() { _M_do_reset(); }
            _Base_bitset(unsigned long __val)
            {
                _M_do_reset();
                _M_w[0] = __val;
            }

            static size_t
                _S_whichword(size_t __pos )
                { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }

            static size_t
                _S_whichbyte(size_t __pos )
                { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }

            static size_t
                _S_whichbit(size_t __pos )
                { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }

            static _WordT
                _S_maskbit(size_t __pos )
                { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }

            _WordT&
                _M_getword(size_t __pos)
                { return _M_w[_S_whichword(__pos)]; }

            _WordT
                _M_getword(size_t __pos) const
                { return _M_w[_S_whichword(__pos)]; }

            _WordT&
                _M_hiword() { return _M_w[_Nw - 1]; }

            _WordT
                _M_hiword() const { return _M_w[_Nw - 1]; }

            void
                _M_do_and(const _Base_bitset<_Nw>& __x)
                {
                    for (size_t __i = 0; __i < _Nw; __i++)
                        _M_w[__i] &= __x._M_w[__i];
                }

            void
                _M_do_or(const _Base_bitset<_Nw>& __x)
                {
                    for (size_t __i = 0; __i < _Nw; __i++)
                        _M_w[__i] |= __x._M_w[__i];
                }

            void
                _M_do_xor(const _Base_bitset<_Nw>& __x)
                {
                    for (size_t __i = 0; __i < _Nw; __i++)
                        _M_w[__i] ^= __x._M_w[__i];
                }

            void
                _M_do_left_shift(size_t __shift);

            void
                _M_do_right_shift(size_t __shift);

            void
                _M_do_flip()
                {
                    for (size_t __i = 0; __i < _Nw; __i++)
                        _M_w[__i] = ~_M_w[__i];
                }

            void
                _M_do_set()
                {
                    for (size_t __i = 0; __i < _Nw; __i++)
                        _M_w[__i] = ~static_cast<_WordT>(0);
                }

            void
                _M_do_reset() { memset(_M_w, 0, _Nw * sizeof(_WordT)); }

            bool
                _M_is_equal(const _Base_bitset<_Nw>& __x) const
                {
                    for (size_t __i = 0; __i < _Nw; ++__i)
                    {
                        if (_M_w[__i] != __x._M_w[__i])
                            return false;
                    }
                    return true;
                }

            bool
                _M_is_any() const
                {
                    for (size_t __i = 0; __i < _Nw; __i++)
                    {
                        if (_M_w[__i] != static_cast<_WordT>(0))
                            return true;
                    }
                    return false;
                }

            size_t
                _M_do_count() const
                {
                    size_t __result = 0;
                    for (size_t __i = 0; __i < _Nw; __i++)
                        __result += __builtin_popcountl(_M_w[__i]);
                    return __result;
                }

            unsigned long
                _M_do_to_ulong() const;

            // find first "on" bit
            size_t
                _M_do_find_first(size_t __not_found) const;

            // find the next "on" bit that follows "prev"
            size_t
                _M_do_find_next(size_t __prev, size_t __not_found) const;
        };

    // Definitions of non-inline functions from _Base_bitset.
    template<size_t _Nw>
        void
        _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift)
        {
            if (__builtin_expect(__shift != 0, 1))
            {
                const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD;
                const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD;

                if (__offset == 0)
                    for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
                        _M_w[__n] = _M_w[__n - __wshift];
                else
                {
                    const size_t __sub_offset = _GLIBCXX_BITSET_BITS_PER_WORD - __offset;
                    for (size_t __n = _Nw - 1; __n > __wshift; --__n)
                        _M_w[__n] = (_M_w[__n - __wshift] << __offset) |
                            (_M_w[__n - __wshift - 1] >> __sub_offset);
                    _M_w[__wshift] = _M_w[0] << __offset;
                }

                std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
            }
        }

    template<size_t _Nw>
        void
        _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift)
        {
            if (__builtin_expect(__shift != 0, 1))
            {
                const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD;
                const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD;
                const size_t __limit = _Nw - __wshift - 1;

                if (__offset == 0)
                    for (size_t __n = 0; __n <= __limit; ++__n)
                        _M_w[__n] = _M_w[__n + __wshift];
                else
                {
                    const size_t __sub_offset = _GLIBCXX_BITSET_BITS_PER_WORD - __offset;
                    for (size_t __n = 0; __n < __limit; ++__n)
                        _M_w[__n] = (_M_w[__n + __wshift] >> __offset) |
                            (_M_w[__n + __wshift + 1] << __sub_offset);
                    _M_w[__limit] = _M_w[_Nw-1] >> __offset;
                }

                std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
            }
        }

    template<size_t _Nw>
        unsigned long
        _Base_bitset<_Nw>::_M_do_to_ulong() const
        {
            for (size_t __i = 1; __i < _Nw; ++__i)
                if (_M_w[__i])
                    __throw_overflow_error(__N("_Base_bitset::_M_do_to_ulong"));
            return _M_w[0];
        }

    template<size_t _Nw>
        size_t
        _Base_bitset<_Nw>::_M_do_find_first(size_t __not_found) const
        {
            for (size_t __i = 0; __i < _Nw; __i++)
            {
                _WordT __thisword = _M_w[__i];
                if (__thisword != static_cast<_WordT>(0))
                    return __i * _GLIBCXX_BITSET_BITS_PER_WORD
                        + __builtin_ctzl(__thisword);
            }
            // not found, so return an indication of failure.
            return __not_found;
        }

    template<size_t _Nw>
        size_t
        _Base_bitset<_Nw>::_M_do_find_next(size_t __prev, size_t __not_found) const
        {
            // make bound inclusive
            ++__prev;

            // check out of bounds
            if (__prev >= _Nw * _GLIBCXX_BITSET_BITS_PER_WORD)
                return __not_found;

            // search first word
            size_t __i = _S_whichword(__prev);
            _WordT __thisword = _M_w[__i];

            // mask off bits below bound
            __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);

            if (__thisword != static_cast<_WordT>(0))
                return __i * _GLIBCXX_BITSET_BITS_PER_WORD
                    + __builtin_ctzl(__thisword);

            // check subsequent words
            __i++;
            for ( ; __i < _Nw; __i++ )
            {
                __thisword = _M_w[__i];
                if (__thisword != static_cast<_WordT>(0))
                    return __i * _GLIBCXX_BITSET_BITS_PER_WORD
                        + __builtin_ctzl(__thisword);
            }
            // not found, so return an indication of failure.
            return __not_found;
        } // end _M_do_find_next


    /**
     *  @if maint
     *  Base class, specialization for a single word.
     *
     *  See documentation for bitset.
     *  @endif
     */
    template<>
        struct _Base_bitset<1>
        {
            typedef unsigned long _WordT;
            _WordT _M_w;

            _Base_bitset( void ) : _M_w(0) {}
            _Base_bitset(unsigned long __val) : _M_w(__val) {}

            static size_t
                _S_whichword(size_t __pos )
                { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }

            static size_t
                _S_whichbyte(size_t __pos )
                { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }

            static size_t
                _S_whichbit(size_t __pos )
                {  return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }

            static _WordT
                _S_maskbit(size_t __pos )
                { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }

            _WordT&
                _M_getword(size_t) { return _M_w; }

            _WordT
                _M_getword(size_t) const { return _M_w; }

            _WordT&
                _M_hiword() { return _M_w; }

            _WordT
                _M_hiword() const { return _M_w; }

            void
                _M_do_and(const _Base_bitset<1>& __x) { _M_w &= __x._M_w; }

            void
                _M_do_or(const _Base_bitset<1>& __x)  { _M_w |= __x._M_w; }

            void
                _M_do_xor(const _Base_bitset<1>& __x) { _M_w ^= __x._M_w; }

            void
                _M_do_left_shift(size_t __shift) { _M_w <<= __shift; }

            void
                _M_do_right_shift(size_t __shift) { _M_w >>= __shift; }

            void
                _M_do_flip() { _M_w = ~_M_w; }

            void
                _M_do_set() { _M_w = ~static_cast<_WordT>(0); }

            void
                _M_do_reset() { _M_w = 0; }

            bool
                _M_is_equal(const _Base_bitset<1>& __x) const
                { return _M_w == __x._M_w; }

            bool
                _M_is_any() const { return _M_w != 0; }

            size_t
                _M_do_count() const { return __builtin_popcountl(_M_w); }

            unsigned long
                _M_do_to_ulong() const { return _M_w; }

            size_t
                _M_do_find_first(size_t __not_found) const
                {
                    if (_M_w != 0)
                        return __builtin_ctzl(_M_w);
                    else
                        return __not_found;
                }