home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 May / PCFMay2001.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / bitset.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  17.3 KB  |  587 lines
  1. #ifndef __BITSET_H
  2. #define __BITSET_H
  3. #pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
  4. // -*- C++ -*-
  5. #ifndef __STD_BITS
  6. #define __STD_BITS
  7.  
  8. /***************************************************************************
  9.  *
  10.  * bitset - class bitset declaration
  11.  *
  12.  ***************************************************************************
  13.  *
  14.  * Copyright (c) 1994-1999 Rogue Wave Software, Inc.  All Rights Reserved.
  15.  *
  16.  * This computer software is owned by Rogue Wave Software, Inc. and is
  17.  * protected by U.S. copyright laws and other laws and by international
  18.  * treaties.  This computer software is furnished by Rogue Wave Software,
  19.  * Inc. pursuant to a written license agreement and may be used, copied,
  20.  * transmitted, and stored only in accordance with the terms of such
  21.  * license and with the inclusion of the above copyright notice.  This
  22.  * computer software or any other copies thereof may not be provided or
  23.  * otherwise made available to any other person.
  24.  *
  25.  * U.S. Government Restricted Rights.  This computer software is provided
  26.  * with Restricted Rights.  Use, duplication, or disclosure by the
  27.  * Government is subject to restrictions as set forth in subparagraph (c)
  28.  * (1) (ii) of The Rights in Technical Data and Computer Software clause
  29.  * at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
  30.  * Commercial Computer Software รป Restricted Rights at 48 CFR 52.227-19,
  31.  * as applicable.  Manufacturer is Rogue Wave Software, Inc., 5500
  32.  * Flatiron Parkway, Boulder, Colorado 80301 USA.
  33.  *
  34.  **************************************************************************/
  35.  
  36. #include <stdcomp.h>
  37. #include <rw/stddefs.h> 
  38. #include <rw/rwstderr.h>
  39.  
  40. #ifndef _RWSTD_NO_NEW_HEADER
  41. #include <climits>
  42. #include <cstddef>
  43. #else
  44. #include <limits.h>
  45. #include <stddef.h>
  46. #endif
  47.  
  48. #ifdef _RW_STD_IOSTREAM
  49. #ifdef _HPACC_
  50. #include <iostream>
  51. #else
  52. #include <iosfwd>
  53. #endif
  54. #else
  55. class  ostream;
  56. class  istream;
  57. #endif
  58.  
  59. #ifndef _RWSTD_NO_EXCEPTIONS
  60. #ifdef _RW_STD_EXCEPT
  61. #include <stdexcept>
  62. #endif
  63. #endif
  64.  
  65. #include <string>
  66. #ifndef _RWSTD_BC5_ENUM_BUG
  67. #define _NELEMENTS NumOfElems
  68. #else
  69. #define _NELEMENTS NumOfElems()
  70. #endif /*_RWSTD_BC5_ENUM_BUG*/
  71.  
  72. #ifndef _RWSTD_NO_NAMESPACE 
  73. namespace __rwstd {
  74. #endif
  75. //
  76. // Exception error messages.
  77. //
  78. #ifdef _RWSTD_LOCALIZED_ERRORS
  79.   extern const unsigned int _RWSTDExport __rw_bitset_InvalidPosition;
  80.   extern const unsigned int _RWSTDExport __rw_bitset_InvalidCtorArgument;
  81.   extern const unsigned int _RWSTDExport __rw_bitset_ConversionOverflow;
  82. #else
  83.   extern const char _RWSTDExportFunc(*) __rw_bitset_InvalidPosition;
  84.   extern const char _RWSTDExportFunc(*) __rw_bitset_InvalidCtorArgument;
  85.   extern const char _RWSTDExportFunc(*) __rw_bitset_ConversionOverflow;
  86. #endif//_RWSTD_LOCALIZED_ERRORS
  87.  
  88. #ifndef _RWSTD_NO_NAMESPACE 
  89. } namespace std {
  90. #endif
  91.  
  92.   template <size_t N>
  93.   class _RWSTDExportTemplate bitset
  94.   {
  95.   private:
  96.     //
  97.     // The type of array in which we store the bits.
  98.     //
  99.     typedef unsigned int VectorType;
  100.     //
  101.     // Number of bits in an array element.
  102.     //
  103.     enum { BitsPerChunk = CHAR_BIT*sizeof(unsigned int) };
  104.     //
  105.     // Number of array elements.
  106.     //
  107. #ifndef _RWSTD_BC5_ENUM_BUG
  108.     enum { NumOfElems = N == 0 ? 1 : 1 + ((N - 1) / BitsPerChunk) };
  109. #else
  110.     size_t NumOfElems () const
  111.     {
  112.       return N == 0 ? 1 : 1 + ((N - 1) / BitsPerChunk);
  113.     }
  114. #endif /*_RWSTD_BC5_ENUM_BUG*/
  115.     //
  116.     // Number of bits in an unsigned long.
  117.     //
  118.     enum { BitsInUnsignedLong = CHAR_BIT*sizeof(unsigned long) };
  119.     //
  120.     // The array of bits.
  121.     //
  122. #ifndef _RWSTD_BC5_ENUM_BUG
  123.     VectorType bits[_NELEMENTS];
  124. #else
  125.     VectorType* bits;
  126. #endif /*_RWSTD_BC5_ENUM_BUG*/
  127.  
  128.   protected:
  129.     //
  130.     // Is pos a valid bitset position?
  131.     //
  132.     bool valid_position (size_t pos) const _RWSTD_THROW_SPEC_NULL
  133.     {
  134.       return N > pos ? true : false;
  135.     }
  136.     //
  137.     // Given a bit position `pos', returns the index into the appropriate
  138.     // chunk in bits[] such that 0 <= index < BitsPerChunk.
  139.     //
  140.     unsigned long index (size_t pos) const _RWSTD_THROW_SPEC_NULL
  141.     {
  142. #if UINT_MAX == 256
  143.       return 7 & pos;
  144. #elif UINT_MAX == 65535
  145.       return 15 & pos;
  146. #elif UINT_MAX == 4294967295
  147.       return 31 & pos;
  148. #elif UINT_MAX == 18446744073709551615
  149.       return 63 & pos;
  150. #else
  151.       return pos % BitsPerChunk;
  152. #endif
  153.     }
  154.  
  155.   public:
  156.  
  157.     typedef bool element_type;
  158. #ifdef _RWSTD_MSC22_STATIC_INIT_BUG
  159.     const size_t bitset_size;
  160. #else
  161. #ifndef _RWSTD_NO_STI_TEMPLATE
  162.     static const size_t bitset_size = N;
  163. #else
  164.     static const size_t bitset_size;
  165. #endif
  166. #endif
  167.  
  168.     //
  169.     // bit reference
  170.     //
  171.     class reference
  172.     {
  173.       friend class bitset<N>;
  174.     private:
  175.       bitset<N>& ref;
  176.       size_t     pos;
  177.       reference (bitset<N>& r, size_t p) _RWSTD_THROW_SPEC_NULL
  178.       : ref(r), pos(p) {}
  179.     public:
  180.       //
  181.       // for b[i] = x;
  182.       //
  183.       reference& operator= (bool val) _RWSTD_THROW_SPEC_NULL
  184.       {
  185.         ref.set(pos, val); return *this;
  186.       }
  187.       //
  188.       // for b[i] = b[j];
  189.       //
  190.       reference& operator= (const reference& rhs) _RWSTD_THROW_SPEC_NULL
  191.       {
  192.         ref.set(pos, rhs.ref.test(rhs.pos)); return *this;
  193.       }
  194.       //
  195.       // for x = ~b[i];
  196.       //
  197.       bool operator~ () const _RWSTD_THROW_SPEC_NULL { return !ref.test(pos);}
  198.       //
  199.       // for x = b[i];
  200.       //
  201.       operator bool () const _RWSTD_THROW_SPEC_NULL { return ref.test(pos); }
  202.       reference& flip() _RWSTD_THROW_SPEC_NULL { ref.flip(pos); return *this;}
  203.     };
  204.     //
  205.     // constructors
  206.     //
  207.     bitset () _RWSTD_THROW_SPEC_NULL
  208. #ifdef _RWSTD_MSC22_STATIC_INIT_BUG
  209.       : bitset_size(N)
  210. #endif
  211.     {
  212. #ifndef _RWSTD_BC5_ENUM_BUG
  213.       memset(bits, 0, sizeof(bits));
  214. #else
  215.       bits = new VectorType[_NELEMENTS];
  216.       memset(bits, 0, _NELEMENTS*sizeof(VectorType));
  217. #endif /*_RWSTD_BC5_ENUM_BUG*/
  218.     }
  219.     bitset (unsigned long val) _RWSTD_THROW_SPEC_NULL
  220. #ifdef _RWSTD_MSC22_STATIC_INIT_BUG
  221.       : bitset_size(N)
  222. #endif
  223.     {
  224.       //
  225.       // Initialize first M bit positions to the corresponding
  226.       // bit values in val. M is the smaller of N and the value
  227.       // CHAR_BIT * sizeof(unsigned long).
  228.       //
  229. #ifndef _RWSTD_BC5_ENUM_BUG
  230.       memset(bits, 0, sizeof(bits));
  231. #else
  232.       bits = new VectorType[_NELEMENTS];
  233.       memset(bits, 0, _NELEMENTS*sizeof(VectorType));
  234. #endif /*_RWSTD_BC5_ENUM_BUG*/
  235.       size_t M = N < BitsInUnsignedLong ? N : BitsInUnsignedLong;
  236.       for (size_t i = 0; i < M; i++)
  237.         if (val & (1UL << i))
  238.           set(i);
  239.     }
  240.  
  241. #ifndef _RWSTD_NO_MEMBER_TEMPLATES
  242.     template <class charT, class traits, class Allocator>
  243.     _EXPLICIT bitset (const basic_string<charT,traits,Allocator>&,
  244.                       _TYPENAME basic_string<charT,traits,Allocator>::size_type=0,
  245.                       _TYPENAME basic_string<charT,traits,Allocator>::size_type=
  246.                       std::template basic_string<charT,traits,Allocator>::npos) // RW_BUG
  247. /*    _EXPLICIT bitset (const basic_string<charT,traits,Allocator>,
  248.                       _TYPENAME basic_string<charT,traits,Allocator>::size_type=0,
  249.                       _TYPENAME basic_string<charT,traits,Allocator>::size_type=
  250.                       basic_string<charT,traits,Allocator>::npos)
  251. */
  252. #else
  253.       _EXPLICIT bitset (const string& str,
  254.                         size_t pos = 0,
  255.                         size_t n = (size_t) -1)
  256. #endif // _RWSTD_NO_MEMBER_TEMPLATES
  257.       _RWSTD_THROW_SPEC((out_of_range, invalid_argument));
  258.  
  259.       // We _EXPLICITly defined the copy constructor, though
  260.       // WP 23.3.5 allows us to use the default generated one.
  261.       //
  262.       bitset (const bitset<N>& rhs) _RWSTD_THROW_SPEC_NULL
  263. #ifdef _RWSTD_MSC22_STATIC_INIT_BUG
  264.         : bitset_size(N)
  265. #endif
  266.     {
  267. #ifndef _RWSTD_BC5_ENUM_BUG
  268.       memcpy(bits, rhs.bits, sizeof(bits));
  269. #else
  270.       bits = new VectorType[_NELEMENTS];
  271.       memcpy(bits, rhs.bits, _NELEMENTS*sizeof(VectorType));
  272. #endif /*_RWSTD_BC5_ENUM_BUG*/
  273.     }
  274.     //
  275.     // We _EXPLICITly defined the assignment, though
  276.     // WP 23.3.5 allows us to use the default generated one.
  277.     //
  278.     bitset<N>& operator= (const bitset<N>& rhs) _RWSTD_THROW_SPEC_NULL
  279.     {
  280.       if (!(this == &rhs))
  281. #ifndef _RWSTD_BC5_ENUM_BUG
  282.         memcpy(bits, rhs.bits, sizeof(bits));
  283. #else
  284.       memcpy(bits, rhs.bits, _NELEMENTS*sizeof(VectorType));
  285. #endif /*_RWSTD_BC5_ENUM_BUG*/
  286.       return *this;
  287.     }
  288. #ifdef _RWSTD_BC5_ENUM_BUG
  289.     ~bitset () _RWSTD_THROW_SPEC_NULL { delete [] bits; }
  290. #endif
  291.     //
  292.     // bitset operations
  293.     //
  294.     bitset<N>& operator&= (const bitset<N>& rhs) _RWSTD_THROW_SPEC_NULL
  295.     {
  296.       for (size_t i = 0; i < _NELEMENTS; i++)
  297.         bits[i] &= rhs.bits[i];
  298.       return *this;
  299.     }
  300.     bitset<N>& operator|= (const bitset<N>& rhs) _RWSTD_THROW_SPEC_NULL
  301.     {
  302.       for (size_t i = 0; i < _NELEMENTS; i++)
  303.         bits[i] |= rhs.bits[i];
  304.       return *this;
  305.     }
  306.     bitset<N>& operator^= (const bitset<N>& rhs) _RWSTD_THROW_SPEC_NULL
  307.     {
  308.       for (size_t i = 0; i < _NELEMENTS; i++)
  309.         bits[i] ^= rhs.bits[i];
  310.       return *this;
  311.     }
  312.     //
  313.     // Replaces bit at position I with a value determined as follows:
  314.     //
  315.     //   If (I <  pos) the new value is 0
  316.     //   If (I >= pos) the new value is the previous value at position I - pos
  317.     //
  318.     bitset<N>& operator<<= (size_t pos) _RWSTD_THROW_SPEC_NULL
  319.     {
  320.       if (pos)
  321.         for (long i = N - 1; i >= 0 ; --i)
  322.           set(i, i <(long)pos || test(i - pos) == 0 ? 0 : 1);
  323.       return *this;
  324.     }
  325.     //
  326.     // Replaces bit at position I with a value determined as follows:
  327.     //
  328.     //   If (pos >= N-i) the new value is zero
  329.     //   If (pos <  N-i) the new value is the previous value at position I + pos
  330.     //
  331.     bitset<N>& operator>>= (size_t pos) _RWSTD_THROW_SPEC_NULL
  332.     {
  333.       if (pos)
  334.         for (size_t i = 0; i < N; i++)
  335.           set(i, pos >= N - i || test(i + pos) == 0 ? 0 : 1);
  336.       return *this;
  337.     }
  338.     bitset<N>& set () _RWSTD_THROW_SPEC_NULL
  339.     {
  340.       for (size_t i = 0; i < _NELEMENTS; i++)
  341.         bits[i] = ~0;
  342.       return *this;
  343.     }
  344.     bitset<N>& set (size_t pos, int val = 1) _RWSTD_THROW_SPEC((out_of_range))
  345.     {
  346.       _RWSTD_THROW(!valid_position(pos),out_of_range,
  347.                    __RWSTD::except_msg_string(__RWSTD::__rw_bitset_InvalidPosition,
  348.                                               "bitset::set(size_t,int )",pos).msgstr());
  349.  
  350.       if (val)
  351.         bits[pos / BitsPerChunk] |=  (1UL << index(pos));
  352.       else
  353.         bits[pos / BitsPerChunk] &= ~(1UL << index(pos));
  354.       return *this;
  355.     }
  356.     bitset<N>& reset () _RWSTD_THROW_SPEC_NULL
  357.     {
  358.       memset(bits, 0, sizeof(bits)); return *this;
  359.     }
  360.     bitset<N>& reset (size_t pos) _RWSTD_THROW_SPEC((out_of_range))
  361.     {
  362.       return set(pos, 0);
  363.     }
  364.     bitset<N> operator~ () const _RWSTD_THROW_SPEC_NULL
  365.     {
  366.       bitset<N> tmp(*this); return tmp.flip();
  367.     }
  368.     bitset<N>& flip () _RWSTD_THROW_SPEC_NULL
  369.     {
  370.       for (size_t i = 0; i < _NELEMENTS; i++) 
  371.         bits[i] = ~bits[i];
  372.       return *this;
  373.     }
  374.     bitset<N>& flip (size_t pos) _RWSTD_THROW_SPEC((out_of_range))
  375.     {
  376.       _RWSTD_THROW(!valid_position(pos),out_of_range,
  377.                    __RWSTD::except_msg_string(__RWSTD::__rw_bitset_InvalidPosition,
  378.                                               "bitset::flip(size_t)",pos).msgstr());
  379.  
  380.       bits[pos / BitsPerChunk] ^= (1UL << index(pos));
  381.       return *this;
  382.     }
  383.     //
  384.     // element access
  385.     //
  386.     reference operator[] (size_t pos) _RWSTD_THROW_SPEC((out_of_range))
  387.     {
  388.       //
  389.       // We check that pos is valid here so that NONE of the reference
  390.       // member functions need check.  This way ALL the reference member
  391.       // functions can have empty throw specifications.
  392.       //
  393.       _RWSTD_THROW(!valid_position(pos),out_of_range,
  394.                    __RWSTD::except_msg_string(__RWSTD::__rw_bitset_InvalidPosition,
  395.                                               "bitset::operator[](size_t)",pos).msgstr());
  396.  
  397.       reference r(*this, pos); return r;
  398.     }
  399.     //
  400.     // conversion functions
  401.     //
  402.     unsigned long  to_ulong  () const _RWSTD_THROW_SPEC((overflow_error));
  403.  
  404. #if !defined ( _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE) && !defined (_HPACC_)  && !defined(_RWSTD_NO_EXPLICIT_ARGS) 
  405.     template <class charT, class traits, class Allocator>
  406.     basic_string<charT,traits,Allocator>   to_string () const;
  407. #else
  408.     string         to_string () const;
  409. #endif
  410.     //
  411.     // miscellaneous member functions
  412.     //
  413.     size_t count () const _RWSTD_THROW_SPEC_NULL;
  414.     size_t size  () const _RWSTD_THROW_SPEC_NULL { return N; }
  415.     bool operator== (const bitset<N>& rhs) const _RWSTD_THROW_SPEC_NULL
  416.     {
  417.       for (size_t i = 0; i+1 < _NELEMENTS; i++)
  418.         if (!(bits[i] == rhs.bits[i]))
  419.           return false;
  420.       for (size_t j = (_NELEMENTS-1)*BitsPerChunk; j < N; j++)
  421.         if (!(test(j) == rhs.test(j)))
  422.           return false;
  423.       return true;
  424.     }
  425.     bool operator!= (const bitset<N>& rhs) const _RWSTD_THROW_SPEC_NULL
  426.     {
  427.       return !(*this == rhs);
  428.     }
  429.     bool test (size_t pos) const _RWSTD_THROW_SPEC((out_of_range))
  430.     {
  431.       _RWSTD_THROW(!valid_position(pos),out_of_range,
  432.                    __RWSTD::except_msg_string(__RWSTD::__rw_bitset_InvalidPosition,
  433.                                               "bitset::test(size_t) const",pos).msgstr());
  434.  
  435.       return (bits[pos / BitsPerChunk] & (1UL << index(pos))) != 0;
  436.     }
  437.     bool any () const _RWSTD_THROW_SPEC_NULL
  438.     {
  439.       bool flag = false;
  440.       for (size_t i = 0; i+1 <= _NELEMENTS && !flag; i++)
  441.         if (bits[i])
  442.           flag = true;
  443.       return flag;
  444.     }
  445.     bool none () const _RWSTD_THROW_SPEC_NULL
  446.     {
  447.       bool flag = true;
  448.       for (size_t i = 0; i+1 <= _NELEMENTS && flag; i++)
  449.         if (bits[i])
  450.           flag = false;
  451.       return flag;
  452.     }
  453.     bitset<N> operator<< (size_t pos) const _RWSTD_THROW_SPEC_NULL
  454.     {
  455.       bitset<N> tmp(*this); tmp <<= pos; return tmp;
  456.     }
  457.     bitset<N> operator>> (size_t pos) const _RWSTD_THROW_SPEC_NULL
  458.     {
  459.       bitset<N> tmp(*this); tmp >>= pos; return tmp;
  460.     }
  461.   };
  462. #ifndef _RWSTD_NO_NONTYPE_ARGS
  463.   template<size_t N>
  464.   inline bitset<N>  operator& (const bitset<N>& lhs,
  465.                                const bitset<N>& rhs) _RWSTD_THROW_SPEC_NULL
  466.   {
  467.     bitset<N> tmp(lhs); tmp &= rhs; return tmp;
  468.   }
  469.  
  470.   template<size_t N>
  471.   inline bitset<N>  operator| (const bitset<N>& lhs,
  472.                                const bitset<N>& rhs) _RWSTD_THROW_SPEC_NULL
  473.   {
  474.     bitset<N> tmp(lhs); tmp |= rhs; return tmp;
  475.   }
  476.  
  477.   template<size_t N>
  478.   inline bitset<N>  operator^ (const bitset<N>& lhs,
  479.                                const bitset<N>& rhs) _RWSTD_THROW_SPEC_NULL
  480.   {
  481.     bitset<N> tmp(lhs); tmp ^= rhs; return tmp;
  482.   }
  483.  
  484. #ifdef _RW_STD_IOSTREAM
  485.   template<class charT, class traits, size_t N> 
  486.   inline basic_ostream<charT,traits>&  
  487.   operator<< (basic_ostream<charT,traits>& os, const bitset<N>& x)
  488.   {
  489. #if !defined ( _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE) && !defined (_HPACC_)  && !defined(_RWSTD_NO_EXPLICIT_ARGS) 
  490.     return os << x.to_string<charT,traits,allocator<charT> >();
  491. #else
  492.     return os << x.to_string();
  493. #endif
  494.   }
  495.  
  496.   template<class charT, class traits, size_t N> 
  497.   inline basic_istream<charT,traits>&  
  498.   operator>> (basic_istream<charT,traits>& is, bitset<N>& x)
  499.   {
  500.     string str(N, '0');
  501.  
  502.     for (size_t count = 0; count < N && !is.eof(); )
  503.     {
  504. #if !defined(_RWSTD_NO_NONTYPE_ARGS) && defined(_RW_STD_IOSTREAM)
  505.       charT c = 0;   
  506. #else
  507.       char c = 0;
  508. #endif
  509.       is >> c;
  510.       if (c == '1' || c == '0')
  511.       { 
  512.         str.append(1, c);
  513.         count++; 
  514.       }
  515.       else
  516.       {
  517.         is.putback(c);
  518.         break;
  519.       }
  520.     }
  521.  
  522.     if (str.size() == 0)
  523.       is.setstate(ios::failbit);
  524.  
  525. #ifdef __TURBOC__
  526.     x = bitset<N>(str, (string::size_type) 0, (string::size_type) string::npos);
  527. #else
  528.     x = bitset<N>(str);
  529. #endif
  530.  
  531.     return is;
  532.   }
  533.  
  534. #else
  535.   template<size_t N> 
  536.   inline ostream&  
  537.   operator<< (ostream& os, const bitset<N>& x)
  538.   {
  539. #if !defined(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE) && !defined(_RWSTD_NO_EXPLICIT_ARGS) && !defined(_HPACC_)
  540.     return os << x.to_string<char,char_traits<char>,allocator<char> >();
  541. #else
  542.     return os << x.to_string();
  543. #endif
  544.   }
  545.  
  546.   template<size_t N> 
  547.   istream&  
  548.   operator>> (istream& is, bitset<N>& x);
  549. #endif //  _RW_STD_IOSTREAM
  550. #endif  /* _RWSTD_NO_NONTYPE_ARGS */
  551.  
  552. #undef _NELEMENTS
  553.  
  554. #ifndef _RWSTD_NO_NAMESPACE
  555. } 
  556. #endif
  557.  
  558. #if defined(_RWSTD_NO_DESTROY_BUILTIN) || defined(_RWSTD_NO_DESTROY_NONBUILTIN)
  559. #ifndef _RWSTD_NO_NONTYPE_ARGS
  560.  
  561. #ifndef _RWSTD_NO_NAMESPACE
  562. namespace __rwstd {
  563. #endif
  564. //
  565. // Specializations of STL destroy for bitset.
  566. //
  567.   template <size_t N> inline void __destroy (bitset<N>**)   {;}
  568.   template <size_t N> inline void __destroy (bitset<N>***)  {;}
  569.   template <size_t N> inline void __destroy (bitset<N>****) {;}
  570.  
  571. #ifndef _RWSTD_NO_NAMESPACE
  572. } 
  573. #endif
  574. #endif
  575. #endif
  576. #ifdef _RWSTD_NO_TEMPLATE_REPOSITORY
  577. #include <bitset.cc>
  578. #endif
  579. #endif /*__STD_BITS*/
  580.  
  581. #ifndef __USING_STD_NAMES__
  582.   using namespace std;
  583. #endif
  584.  
  585. #pragma option pop
  586. #endif /* __BITSET_H */
  587.