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

bit_string_stream.hpp

00001 #include <istream>
00002 #include <ostream>
00003 
00004 namespace std
00005 {
00006 
00018   template<class _CharT, class _Traits, class _BitTraits, size_t _Nb>
00019   basic_istream<_CharT, _Traits>&
00020   operator>>(basic_istream<_CharT, _Traits>& __is, basic_string<bitset<_Nb>, _BitTraits>& __x) {
00021     // for now let's do this super hoky style
00022     typedef typename _Traits::char_type char_type;
00023     static typename _Traits::int_type __eof = _Traits::eof();
00024     const std::size_t char_size = _BitTraits::bit_size();
00025     const std::size_t left_bit_idx = (_Nb-1);
00026     bitset<_Nb> curr_bits;
00027     typename basic_istream<_CharT, _Traits>::sentry __sentry(__is);
00028     if (__sentry) {
00029       basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
00030         std::size_t pos = 0;
00031         bool dirty = false;
00032         for(;;) {
00033           typename _Traits::int_type __c1 = __buf->sbumpc();
00034           if (_Traits::eq_int_type(__c1, __eof)) {
00035             __is.setstate(ios_base::eofbit);
00036             break;
00037           } else {
00038             char_type __c2 = _Traits::to_char_type(__c1);
00039             char_type __c  = __is.narrow(__c2, '*');
00040             if(_BitTraits::valid_code(__c)) {
00041               dirty = true;
00042               bitset<_Nb> tmp_bits = _BitTraits::bit_code(__c);
00043               size_t shift_width = left_bit_idx - pos - (char_size-1);
00044               tmp_bits=tmp_bits<<shift_width;
00045               curr_bits |= tmp_bits; //(_BitTraits::bit_code(__c)<<(pos-bs));
00046             } else if (_Traits::eq_int_type(__buf->sputbackc(__c2),__eof)) { 
00047               __is.setstate(ios_base::failbit);
00048               break;
00049             } else {
00050               //__buf->sputbackc(__c2);
00051               break;
00052             }
00053           }
00054           pos += _BitTraits::bit_size();
00055           //signed state = pos - (static_cast<signed>(_BitTraits::bit_size()) - 1);
00056           if( pos > left_bit_idx ) {
00057             dirty = false;
00058             pos = 0;
00059             __x.push_back(curr_bits);
00060             curr_bits.reset();
00061           }
00062         }
00063         if( dirty ) {
00064           __x.push_back(curr_bits);
00065         }
00066         // do I need to check if something got read?
00067         if(  __x.empty() ) {
00068           __is.setstate(ios_base::failbit);
00069         }
00070     }
00071     return __is;
00072   }
00073 
00074   template <class _CharT, class _Traits, typename _BitTraits, size_t _Nb>
00075     basic_ostream<_CharT, _Traits>&
00076     operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<bitset<_Nb>, _BitTraits>& __x)
00077     {
00078       const std::size_t char_size = _BitTraits::bit_size();
00079       const std::size_t left_bit_idx = (_Nb-1);
00080       //const signed bsize = static_cast<signed>(_BitTraits::bit_size());
00081       for(unsigned i = 0; i < __x.size(); ++i) {
00082         const bitset<_Nb>& bits = __x[i];
00083         //cout<<"i: "<<i<<" bits: "<<bits<<endl;
00084         for(std::size_t pos = 0; pos < _Nb; pos += char_size) {
00085           size_t shift_width = left_bit_idx - pos - (char_size-1);
00086           bitset<_Nb> mask = (bits>>shift_width);
00087           //cout<<"mask: "<<mask<<endl;
00088           __os<<_BitTraits::char_code(mask);
00089         }
00090       }
00091       return __os;
00092     }
00093 
00094 #if 0
00095   template<class _CharT, class _Traits, class _BitTraits, size_t _Nb>
00096   basic_istream<_CharT, _Traits>&
00097   operator>>(basic_istream<_CharT, _Traits>& __is, basic_string<bitset<_Nb>, _BitTraits>& __x) {
00098     // for now let's do this super hoky style
00099     typedef typename _Traits::char_type char_type;
00100     static typename _Traits::int_type __eof = _Traits::eof();
00101     const std::size_t char_size = _BitTraits::bit_size();
00102     const std::size_t left_bit_idx = (_Nb-1);
00103     bitset<_Nb> curr_bits;
00104     typename basic_istream<_CharT, _Traits>::sentry __sentry(__is);
00105     if (__sentry) {
00106       basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
00107         std::size_t pos = 0;
00108         bool dirty = false;
00109         for(;;) {
00110           typename _Traits::int_type __c1 = __buf->sbumpc();
00111           if (_Traits::eq_int_type(__c1, __eof)) {
00112             __is.setstate(ios_base::eofbit);
00113             break;
00114           } else {
00115             char_type __c2 = _Traits::to_char_type(__c1);
00116             char_type __c  = __is.narrow(__c2, '*');
00117             cout<<"here's.....johnny: ["<<__c<<"]"<<endl;
00118             if(_BitTraits::valid_code(__c)) {
00119               dirty = true;
00120               bitset<_Nb> tmp_bits = _BitTraits::bit_code(__c);
00121               size_t shift_width = pos > left_bit_idx ? (char_size-1) : left_bit_idx - pos - (char_size-1);
00122               tmp_bits=tmp_bits<<shift_width;
00123               curr_bits |= tmp_bits; //(_BitTraits::bit_code(__c)<<(pos-bs));
00124             } else if (_Traits::eq_int_type(__buf->sputbackc(__c2),__eof)) { 
00125               __is.setstate(ios_base::failbit);
00126               break;
00127             } else {
00128               //__buf->sputbackc(__c2);
00129               break;
00130             }
00131           }
00132           if(pos <= left_bit_idx)
00133             pos += _BitTraits::bit_size();
00134           if( pos > left_bit_idx ) {
00135             dirty = false;
00136             cout<<"bingo! "<<curr_bits<<endl;
00137             __x.push_back(curr_bits);
00138             cout<<"here i am: "<<__x<<endl;
00139             curr_bits.reset();
00140           }
00141         }
00142         if( dirty ) {
00143           __x.push_back(curr_bits);
00144           cout<<"here i am: "<<__x<<endl;
00145         }
00146         // do I need to check if something got read?
00147         if(  __x.empty() ) {
00148           __is.setstate(ios_base::failbit);
00149         }
00150     }
00151     return __is;
00152   }
00153 #endif
00154 
00155 }