Main Page   Modules   Namespace List   Class Hierarchy   Compound List   File List   Namespace Members   Compound Members  

bit_string_stream.h

00001 #include <istream>
00002 #include <ostream>
00003 
00004 namespace std
00005 {
00007 
00019   template<class _CharT, class _Traits, class _BitTraits, size_t _Nb>
00020   basic_istream<_CharT, _Traits>&
00021   operator>>(basic_istream<_CharT, _Traits>& __is, basic_string<bitset<_Nb>, _BitTraits>& __x) {
00022     // for now let's do this super hoky style
00023     typedef typename _Traits::char_type char_type;
00024     static typename _Traits::int_type __eof = _Traits::eof();
00025     const std::size_t char_size = _BitTraits::bit_size();
00026     const std::size_t left_bit_idx = (_Nb-1);
00027     bitset<_Nb> curr_bits;
00028     typename basic_istream<_CharT, _Traits>::sentry __sentry(__is);
00029     if (__sentry) {
00030       basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
00031         std::size_t pos = 0;
00032         bool dirty = false;
00033         for(;;) {
00034           typename _Traits::int_type __c1 = __buf->sbumpc();
00035           if (_Traits::eq_int_type(__c1, __eof)) {
00036             __is.setstate(ios_base::eofbit);
00037             break;
00038           } else {
00039             char_type __c2 = _Traits::to_char_type(__c1);
00040             char_type __c  = __is.narrow(__c2, '*');
00041             if(_BitTraits::valid_code(__c)) {
00042               dirty = true;
00043               bitset<_Nb> tmp_bits = _BitTraits::bit_code(__c);
00044               size_t shift_width = left_bit_idx - pos - (char_size-1);
00045               tmp_bits=tmp_bits<<shift_width;
00046               curr_bits |= tmp_bits; //(_BitTraits::bit_code(__c)<<(pos-bs));
00047             } else if (_Traits::eq_int_type(__buf->sputbackc(__c2),__eof)) { 
00048               __is.setstate(ios_base::failbit);
00049               break;
00050             } else {
00051               //__buf->sputbackc(__c2);
00052               break;
00053             }
00054           }
00055           pos += _BitTraits::bit_size();
00056           //signed state = pos - (static_cast<signed>(_BitTraits::bit_size()) - 1);
00057           if( pos > left_bit_idx ) {
00058             dirty = false;
00059             pos = 0;
00060             __x.push_back(curr_bits);
00061             curr_bits.reset();
00062           }
00063         }
00064         if( dirty ) {
00065           __x.push_back(curr_bits);
00066         }
00067         // do I need to check if something got read?
00068         if(  __x.empty() ) {
00069           __is.setstate(ios_base::failbit);
00070         }
00071     }
00072     return __is;
00073   }
00074 
00075   template <class _CharT, class _Traits, typename _BitTraits, size_t _Nb>
00076     basic_ostream<_CharT, _Traits>&
00077     operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<bitset<_Nb>, _BitTraits>& __x)
00078     {
00079       const std::size_t char_size = _BitTraits::bit_size();
00080       const std::size_t left_bit_idx = (_Nb-1);
00081       //const signed bsize = static_cast<signed>(_BitTraits::bit_size());
00082       for(unsigned i = 0; i < __x.size(); ++i) {
00083         const bitset<_Nb>& bits = __x[i];
00084         //cout<<"i: "<<i<<" bits: "<<bits<<endl;
00085         for(std::size_t pos = 0; pos < _Nb; pos += char_size) {
00086           size_t shift_width = left_bit_idx - pos - (char_size-1);
00087           bitset<_Nb> mask = (bits>>shift_width);
00088           //cout<<"mask: "<<mask<<endl;
00089           __os<<_BitTraits::char_code(mask);
00090         }
00091       }
00092       return __os;
00093     }
00095 
00096 }