blob: a0131f919edd1dd52989f42f8e62372715a2dbfb [file] [log] [blame]
// -*- C++ -*-
/***************************************************************************
*
* <bitset> - definition of the bitset template
*
* $Id$
*
***************************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License.
*
* Copyright 1994-2006 Rogue Wave Software.
*
**************************************************************************/
#ifndef _RWSTD_BITSET_INCLUDED
#define _RWSTD_BITSET_INCLUDED
#include <string>
#include <rw/_iosfwd.h>
#include <rw/_error.h>
#include <rw/_defs.h>
_RWSTD_NAMESPACE (__rw) {
// helper, implements bitset converting ctor
_EXPORT
template <class _CharT, class _Traits>
void
__rw_bitset (unsigned long*, _RWSTD_SIZE_T,
const _CharT*, _RWSTD_SIZE_T,
const _Traits*, _CharT, _CharT,
_RWSTD_SIZE_T, _RWSTD_SIZE_T,
const char*, const char*);
_RWSTD_SPECIALIZED_FUNCTION
_RWSTD_EXPORT void
__rw_bitset (unsigned long*, _RWSTD_SIZE_T,
const char*, _RWSTD_SIZE_T,
const _STD::char_traits<char>*, char, char,
_RWSTD_SIZE_T, _RWSTD_SIZE_T,
const char*, const char*);
#ifdef __SUNPRO_CC
# pragma no_side_effect (__rw_bitset)
#endif // Sun C++
#ifndef _RWSTD_NO_WCHAR_T
_RWSTD_SPECIALIZED_FUNCTION
_RWSTD_EXPORT void
__rw_bitset (unsigned long*, _RWSTD_SIZE_T,
const wchar_t*, _RWSTD_SIZE_T,
const _STD::char_traits<wchar_t>*, wchar_t, wchar_t,
_RWSTD_SIZE_T, _RWSTD_SIZE_T,
const char*, const char*);
# ifdef __SUNPRO_CC
# pragma no_side_effect (__rw_bitset)
# endif // Sun C++
#endif // _RWSTD_NO_WCHAR_T
// helper, implements bitset::count()
_RWSTD_EXPORT _RWSTD_SIZE_T
__rw_bit_count (const unsigned long*, _RWSTD_SIZE_T) _THROWS (());
// helpers, implement bitset<>::operator<<=() and operator>>=()
_RWSTD_EXPORT void
__rw_shl (unsigned long*, _RWSTD_SIZE_T, _RWSTD_SIZE_T) _THROWS (());
_RWSTD_EXPORT void
__rw_shr (unsigned long*, _RWSTD_SIZE_T, _RWSTD_SIZE_T) _THROWS (());
#ifdef __SUNPRO_CC
# pragma no_side_effect (__rw_bit_count, __rw_shl, __rw_shr)
#endif // Sun C++
} // namespace __rw
_RWSTD_NAMESPACE (std) {
_EXPORT
template <_RWSTD_SIZE_T _Size>
class bitset
{
enum { _C_elembits = _RWSTD_CHAR_BIT * sizeof (unsigned long) };
enum { _C_nelems = _Size ? 1 + (_Size - 1) / _C_elembits : 0 };
// must have at least one element even if size is 0
unsigned long _C_bits [_C_nelems ? _C_nelems : 1];
bool _C_valid_pos (_RWSTD_SIZE_T __pos) const _THROWS (()) {
// prevent warnings if _Size == 0
return _Size + 1 > __pos + 1;
}
void _C_from_ulong (unsigned long __n) _THROWS (()) {
reset ();
_C_bits [0] =
__n & (_RWSTD_ULONG_MAX >> ((_Size > _C_elembits ? 0 :
_C_elembits - _Size % _C_elembits) % _C_elembits));
}
template <class _CharT, class _Traits>
void _C_from_char (const _CharT *__str, _RWSTD_SIZE_T __len,
const _Traits *__traits, _CharT __b0, _CharT __b1,
_RWSTD_SIZE_T __pos, _RWSTD_SIZE_T __n,
const char *__file, const char *__fun) {
_RW::__rw_bitset (_C_bits, _Size, __str, __len,
__traits, __b0, __b1,
__pos, __n, __file, __fun);
}
public:
class reference {
friend class bitset<_Size>;
bitset<_Size>& _C_ref;
_RWSTD_SIZE_T _C_pos;
reference (bitset<_Size> &__r, _RWSTD_SIZE_T __p) _THROWS (())
: _C_ref (__r), _C_pos (__p) { }
public:
reference& operator= (bool __val) _THROWS (()) {
return _C_ref.set (_C_pos, __val), *this;
}
reference& operator= (const reference &__rhs) _THROWS (()) {
return *this = bool (__rhs);
}
bool operator~ () const _THROWS (()) {
return !bool (*this);
}
operator bool () const _THROWS (()) {
return _RWSTD_CONST_CAST (const bitset<_Size>&, _C_ref)[_C_pos];
}
reference& flip () _THROWS (()) {
return _C_ref.flip (_C_pos), *this;
}
};
// 23.3.5.1, p1
bitset () _THROWS (()) {
reset ();
}
// 23.3.5.1, p2
bitset (unsigned long __n) _THROWS (()) {
_C_from_ulong (__n);
}
#if !defined (_RWSTD_NO_NONDEDUCED_CONTEXT) \
&& (!defined (__SUNPRO_CC) || __SUNPRO_CC > 0x550)
// 23.3.5.1, p3
template <class _CharT, class _Traits, class _Allocator>
explicit
bitset (const basic_string<_CharT, _Traits, _Allocator> &__str,
typename basic_string<_CharT, _Traits,
_Allocator>::size_type __pos = 0,
typename basic_string<_CharT, _Traits,
_Allocator>::size_type __n =
_RWSTD_SIZE_MAX,
_CharT __b0 = '0', _CharT __b1 = '1') {
_C_from_char (__str.data (), __str.size (),
(_Traits*)0, __b0, __b1, __pos, __n,
_RWSTD_FUNC ("bitset::bitset (const basic_string&, "
"size_type, size_type)"));
}
#else // if defined (_RWSTD_NO_NONDEDUCED_CONTEXT)
// working around a SunPro 5.5 and prior bug (PR #28992)
// 23.3.5.1, p3
template <class _CharT, class _Traits, class _Allocator>
explicit
bitset (const basic_string<_CharT, _Traits, _Allocator> &__str,
_RWSTD_SIZE_T __pos = 0, _RWSTD_SIZE_T __n = _RWSTD_SIZE_MAX,
_CharT __b0 = '0', _CharT __b1 = '1') {
_C_from_char (__str.data (), __str.size (),
(const _Traits*)0, __b0, __b1, __pos, __n,
_RWSTD_FUNC ("bitset::bitset (const basic_string&, "
"size_t, size_t)"));
}
#endif // _RWSTD_NO_NONDEDUCED_CONTEXT
#ifndef _RWSTD_NO_EXT_BITSET_CTOR_STRING
// extension
explicit
bitset (const string &__str,
_RWSTD_SIZE_T __pos = 0, _RWSTD_SIZE_T __n = _RWSTD_SIZE_MAX,
char __b0 = '0', char __b1 = '1') {
_C_from_char (__str.data (), __str.size (),
(const char_traits<char>*)0, __b0, __b1, __pos, __n,
_RWSTD_FUNC ("bitset::bitset (const string&, "
"size_t, size_t)"));
}
# ifndef _RWSTD_NO_WCHAR_T
// extension
explicit
bitset (const wstring &__str,
_RWSTD_SIZE_T __pos = 0, _RWSTD_SIZE_T __n = _RWSTD_SIZE_MAX,
wchar_t __b0 = L'0', wchar_t __b1 = L'1') {
_C_from_char (__str.data (), __str.size (),
(const char_traits<wchar_t>*)0, __b0, __b1, __pos, __n,
_RWSTD_FUNC ("bitset::bitset (const wstring&, "
"size_t, size_t)"));
}
# endif // _RWSTD_NO_WCHAR_T
#endif // _RWSTD_NO_EXT_BITSET_CTOR_STRING
#ifndef _RWSTD_NO_EXT_BITSET_CTOR_CHAR_ARRAY
// extension
explicit
bitset (const char *__str,
_RWSTD_SIZE_T __pos = 0, _RWSTD_SIZE_T __n = _RWSTD_SIZE_MAX,
char __b0 = '0', char __b1 = '1') {
_C_from_char (__str, _RWSTD_SIZE_MAX,
(const char_traits<char>*)0, __b0, __b1, __pos, __n,
_RWSTD_FUNC ("bitset::bitset (const char*, "
"size_t, size_t)"));
}
# ifndef _RWSTD_NO_WCHAR_T
// extension
explicit
bitset (const wchar_t *__str,
_RWSTD_SIZE_T __pos = 0, _RWSTD_SIZE_T __n = _RWSTD_SIZE_MAX,
wchar_t __b0 = L'0', wchar_t __b1 = L'1') {
_C_from_char (__str, _RWSTD_SIZE_MAX,
(const char_traits<wchar_t>*)0, __b0, __b1, __pos, __n,
_RWSTD_FUNC ("bitset::bitset (const wchar_t*, "
"size_t, size_t)"));
}
# endif // _RWSTD_NO_WCHAR_T
// extension:
// uses char_traits<CharT>::length() to compute the length of the string
// and char_traits<CharT>::eq() to compare characters with `b0' and `b1'
template <class _CharT>
explicit
bitset (const _CharT *__str,
_RWSTD_SIZE_T __pos = 0, _RWSTD_SIZE_T __n = _RWSTD_SIZE_MAX,
_CharT __b0 = '0', _CharT __b1 = '1') {
_C_from_char (__str, _RWSTD_SIZE_MAX,
(const char_traits<_CharT>*)0, __b0, __b1, __pos, __n,
_RWSTD_FUNC ("bitset::bitset (const charT*, "
"size_t, size_t)"));
}
// extensions:
// prevent ambiguities between the above and bitset(unsigned long)
bitset (int __n) _THROWS (()) {
_C_from_ulong (__n);
}
bitset (unsigned __n) _THROWS (()) {
_C_from_ulong (__n);
}
bitset (long __n) _THROWS (()) {
_C_from_ulong (__n);
}
#endif // _RWSTD_NO_EXT_BITSET_CTOR_CHAR_ARRAY
// 23.3.5.2, p1
bitset& operator&= (const bitset &__rhs) _THROWS (()) {
for (_RWSTD_SIZE_T __i = 0; __i != _C_nelems; ++__i)
_C_bits [__i] &= __rhs._C_bits [__i];
return *this;
}
// 23.3.5.2, p3
bitset& operator|= (const bitset &__rhs) _THROWS (()) {
for (_RWSTD_SIZE_T __i = 0; __i != _C_nelems; ++__i)
_C_bits[__i] |= __rhs._C_bits [__i];
return *this;
}
// 23.3.5.2, p5
bitset& operator^= (const bitset& __rhs) _THROWS (()) {
for (_RWSTD_SIZE_T __i = 0; __i != _C_nelems; ++__i)
_C_bits [__i] ^= __rhs._C_bits [__i];
return *this;
}
// 23.3.5.2, p7
bitset& operator<<= (_RWSTD_SIZE_T) _THROWS (());
// 23.3.5.2, p9
bitset& operator>>= (_RWSTD_SIZE_T) _THROWS (());
// 23.3.5.2, p11
bitset& set () _THROWS (());
// 23.3.5.2, p13: follows proposed resolution of lwg issue 186
bitset& set (_RWSTD_SIZE_T, bool = true);
// 23.3.5.2, p17
bitset& reset () _THROWS (()) {
return 1 == _C_nelems ? (void)(_C_bits [0] = 0)
: (void)_RWSTD_MEMSET (_C_bits, 0, sizeof (_C_bits)), *this;
}
// 23.3.5.2, p19
bitset& reset (_RWSTD_SIZE_T __pos) {
return set (__pos, false);
}
// 23.3.5.2, p23
bitset operator~ () const _THROWS (()) {
return bitset (*this).flip ();
}
// 23.3.5.2, p25
bitset& flip () _THROWS (()) {
for (_RWSTD_SIZE_T __i = 0; __i != _C_nelems; __i++)
_C_bits [__i] = ~_C_bits [__i];
_C_bits [_C_nelems - !!_C_nelems] &=
_RWSTD_ULONG_MAX >> (_C_elembits - _Size % _C_elembits) % _C_elembits;
return *this;
}
// 23.3.5.2, p27
bitset& flip (_RWSTD_SIZE_T __pos) {
_RWSTD_REQUIRES (_C_valid_pos (__pos),
(_RWSTD_ERROR_OUT_OF_RANGE,
_RWSTD_FUNC ("bitset::flip(size_t)"),
__pos, _C_nelems));
_C_bits [__pos / _C_elembits] ^= 1UL << __pos % _C_elembits;
return *this;
}
// 23.3.5.2, p??
bool operator[] (_RWSTD_SIZE_T __pos) const _THROWS (()) {
_RWSTD_ASSERT (_C_valid_pos (__pos));
return !!(_C_bits [__pos / _C_elembits] & (1UL << __pos % _C_elembits));
}
// 23.3.5.2, p??
reference operator[] (_RWSTD_SIZE_T __pos) _THROWS (()) {
_RWSTD_ASSERT (_C_valid_pos (__pos));
return reference (*this, __pos);
}
// 23.3.5.2, p31
unsigned long to_ulong () const;
#if !defined (_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE)
// 23.3.5.2, p33
template <class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
to_string (_CharT = '0', _CharT = '1') const;
# define _RWSTD_BITSET_TO_STRING(charT, Traits) \
template to_string<charT, Traits, allocator <charT> >()
# ifndef _RWSTD_NO_EXT_BITSET_TO_STRING
// convenience extensions
template <class _CharT, class _Traits>
basic_string<_CharT, _Traits, allocator<_CharT> >
to_string (_CharT __b0 = '0', _CharT __b1 = '1') const {
return to_string<_CharT, _Traits, allocator<_CharT> >(__b0, __b1);
}
template <class _CharT>
basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
to_string (_CharT __b0 = '0', _CharT __b1 = '1') const {
return to_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
(__b0, __b1);
}
basic_string<char, char_traits<char>, allocator<char> >
to_string (char __b0 = '0', char __b1 = '1') const {
return to_string<char, char_traits<char>, allocator<char> >
(__b0, __b1);
}
# endif // !_NO_EXT_BITSET_TO_STRING
#else // if _NO_TEMPLATE_ON_RETURN_TYPE
// 23.3.5.2, p33
string to_string (char = '0', char = '1') const;
# define _RWSTD_BITSET_TO_STRING(ign1, ign2) to_string ()
#endif // !_NO_TEMPLATE_ON_RETURN_TYPE
// 23.3.5.2, p35
_RWSTD_SIZE_T count () const _THROWS (()) {
return _Size ? _RW::__rw_bit_count (_C_bits, _C_nelems) : 0;
}
// 23.3.5.2, p36
_RWSTD_SIZE_T size () const _THROWS (()) {
return _Size;
}
// 23.3.5.2, p37
bool operator== (const bitset& __rhs) const _THROWS (()) {
for (_RWSTD_SIZE_T __i = 0; __i != _C_nelems; ++__i)
if (_C_bits [__i] != __rhs._C_bits [__i])
return false;
return true;
}
// 23.3.5.2, p38
bool operator!= (const bitset& __rhs) const _THROWS (()) {
return !(*this == __rhs);
}
// 23.3.5.2, p39
bool test (_RWSTD_SIZE_T __pos) const {
_RWSTD_REQUIRES (_C_valid_pos (__pos),
(_RWSTD_ERROR_OUT_OF_RANGE,
_RWSTD_FUNC ("bitset::test(size_t) const"),
__pos, _C_nelems));
return !!(_C_bits [__pos / _C_elembits] & (1UL << __pos % _C_elembits));
}
// 23.3.5.2, p42
bool any () const _THROWS (()) {
for (_RWSTD_SIZE_T __i = 0; __i != _C_nelems; ++__i)
if (_C_bits [__i])
return true;
return false;
}
// 23.3.5.2, p43
bool none () const _THROWS (()) {
return !any ();
}
// 23.3.5.2, p44
bitset operator<< (_RWSTD_SIZE_T __pos) const _THROWS (()) {
return bitset (*this) <<= __pos;
}
// 23.3.5.2, p45
bitset operator>> (_RWSTD_SIZE_T __pos) const _THROWS (()) {
return bitset (*this) >>= __pos;
}
};
// 23.3.5.2, p11
template <_RWSTD_SIZE_T _Size>
inline bitset<_Size>&
bitset<_Size>::set () _THROWS (())
{
if (_C_nelems == 1)
_C_bits [0] = _RWSTD_ULONG_MAX;
else
_RWSTD_MEMSET (_C_bits, -1, sizeof _C_bits);
_C_bits [_C_nelems - !!_C_nelems] >>=
(_C_elembits - _Size % _C_elembits) % _C_elembits;
return *this;
}
// 23.3.5.2, p13
template <_RWSTD_SIZE_T _Size>
inline bitset<_Size>&
bitset<_Size>::set (_RWSTD_SIZE_T __pos, bool __val)
{
_RWSTD_REQUIRES (_C_valid_pos (__pos),
(_RWSTD_ERROR_OUT_OF_RANGE,
_RWSTD_FUNC ("bitset::set(size_t, bool)"),
__pos, _C_nelems));
if (__val)
_C_bits [__pos / _C_elembits] |= (1UL << __pos % _C_elembits);
else
_C_bits [__pos / _C_elembits] &= ~(1UL << __pos % _C_elembits);
return *this;
}
// 23.3.5.2, p7
template <_RWSTD_SIZE_T _Size>
inline bitset<_Size>&
bitset<_Size>::operator<<= (_RWSTD_SIZE_T __n) _THROWS (())
{
if (_Size >= _C_elembits)
_RW::__rw_shl (_C_bits, _C_nelems, __n);
else
// prevent shifting by sizeof (_C_bits) * CHAR_BIT (undefined)
_C_bits [0] <<= __n;
// clear bits shifted past the MSB
if (_Size % _C_elembits) {
// prevent warnings about shifting too far
_C_bits [_C_nelems - !!_C_nelems] &=
_RWSTD_ULONG_MAX >> (_C_elembits - _Size % _C_elembits) % _C_elembits;
}
return *this;
}
// 23.3.5.2, p9
template <_RWSTD_SIZE_T _Size>
inline bitset<_Size>&
bitset<_Size>::operator>>= (_RWSTD_SIZE_T __n) _THROWS (())
{
if (_Size >= _C_elembits)
_RW::__rw_shr (_C_bits, _C_nelems, __n);
else
// prevent shifting by sizeof (_C_bits) * CHAR_BIT (undefined)
_C_bits [0] >>= __n;
return *this;
}
// 23.3.5.2, p31
template <_RWSTD_SIZE_T _Size>
inline unsigned long
bitset<_Size>::to_ulong () const
{
// add 1 to prevent warnings about pointless comparison with 0
for (_RWSTD_SIZE_T __i = 1; __i + 1 < _C_nelems + 1; ++__i)
_RWSTD_REQUIRES (!_C_bits[__i],
(_RWSTD_ERROR_OVERFLOW_ERROR,
_RWSTD_FUNC ("bitset::to_ulong() const")));
return _C_bits [0];
}
#if !defined (_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE)
// 23.3.5.2, p33
template <_RWSTD_SIZE_T _Size>
template <class _CharT, class _Traits, class _Allocator>
inline basic_string<_CharT, _Traits, _Allocator>
bitset<_Size>::
to_string (_CharT __b0 /* = '0' */, _CharT __b1 /* = '1' */) const
{
// extension: allocate but do not initialize
basic_string<_CharT, _Traits, _Allocator> __s ((_CharT*)0, _Size);
for (_RWSTD_SIZE_T __i = 0; __i != _Size; ++__i)
_Traits::assign (__s [_Size - 1 - __i], (*this)[__i] ? __b1 : __b0);
return __s;
}
#else // _NO_TEMPLATE_ON_RETURN_TYPE
// 23.3.5.2, p33
template <_RWSTD_SIZE_T _Size>
inline string
bitset<_Size>::
to_string (char __b0 /* = '0' */, char __b1 /* = '1' */) const
{
// extension: allocate but do not initialize
string __s ((char*)0, _Size);
for (_RWSTD_SIZE_T __i = 0; __i != _Size; ++__i)
__s [_Size - 1 - __i] = (*this)[__i] ? __b1 : __b0;
return __s;
}
#endif // !_NO_TEMPLATE_ON_RETURN_TYPE
// 23.3.5.3, p1
template <_RWSTD_SIZE_T _Size>
inline bitset<_Size>
operator& (const bitset<_Size>& __lhs, const bitset<_Size>& __rhs) _THROWS (())
{
return bitset<_Size>(__lhs) &= __rhs;
}
// 23.3.5.3, p2
template <_RWSTD_SIZE_T _Size>
inline bitset<_Size>
operator| (const bitset<_Size>& __lhs, const bitset<_Size>& __rhs) _THROWS (())
{
return bitset<_Size>(__lhs) |= __rhs;
}
// 23.3.5.3, p3
template <_RWSTD_SIZE_T _Size>
inline bitset<_Size>
operator^ (const bitset<_Size>& __lhs, const bitset<_Size>& __rhs) _THROWS (())
{
return bitset<_Size>(__lhs) ^= __rhs;
}
} // namespace std
_RWSTD_NAMESPACE (__rw) {
_EXPORT
template <_RWSTD_SIZE_T _Size, class _CharT, class _Traits>
_STD::basic_istream<_CharT, _Traits>&
__rw_extract_bitset (_STD::basic_istream<_CharT, _Traits>&,
_STD::bitset<_Size>&);
} // namespace __rw
#if !defined (_MSC_VER) || _MSC_VER > 1300
_RWSTD_NAMESPACE (std) {
// 23.3.5.3, p8
template <class _CharT, class _Traits, _RWSTD_SIZE_T _Size>
inline basic_ostream<_CharT, _Traits>&
operator<< (basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
{
return __os << __x._RWSTD_BITSET_TO_STRING (_CharT, _Traits);
}
// 23.3.5.3, p4
template <class _CharT, class _Traits, _RWSTD_SIZE_T _Size>
inline basic_istream<_CharT, _Traits>&
operator>> (basic_istream<_CharT, _Traits>& __strm, bitset<_Size>& __x)
{
return _RW::__rw_extract_bitset (__strm, __x);
}
} // namespace std
#else // if defined (_MSC_VER) && _MSC_VER <= 1300
# include <ostream>
_RWSTD_NAMESPACE (std) {
// MSVC 6.0 fails to compile (and with a fix to generate code) for the call
// to extract_bitset below if `Size' is the last template parameter
typedef _RWSTD_SIZE_T _Size_t; // prevent an MSVC 6.0 ICE
template <_Size_t _Size, class _CharT, class _Traits>
inline basic_istream<_CharT, _Traits>&
operator>> (basic_istream<_CharT, _Traits>& __strm, bitset<_Size>& __x)
{
return _RW::__rw_extract_bitset (__strm, __x);
}
template <_Size_t _Size>
inline ostream& operator<< (ostream &__strm, const bitset<_Size>& __x)
{
return __strm << __x._RWSTD_BITSET_TO_STRING (char, char_traits<char>);
}
template <_Size_t _Size>
inline wostream& operator<< (wostream &__strm, const bitset<_Size>& __x)
{
const string __s = __x._RWSTD_BITSET_TO_STRING (char, char_traits<char>);
wstring __tmp (0, __s.length ()); // extension: allocate uninitialzed
for (string::size_type __i = 0; __i != __tmp.size (); ++__i)
__tmp [__i] = __s [__i];
return __strm << __tmp;
}
} // namespace std
#endif // !defined (_MSC_VER) || _MSC_VER > 1300
#ifdef _RWSTD_NO_IMPLICIT_INCLUSION
# include <bitset.cc>
#endif
#endif // _RWSTD_BITSET_INCLUDED