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
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;
00046 } else if (_Traits::eq_int_type(__buf->sputbackc(__c2),__eof)) {
00047 __is.setstate(ios_base::failbit);
00048 break;
00049 } else {
00050
00051 break;
00052 }
00053 }
00054 pos += _BitTraits::bit_size();
00055
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
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
00081 for(unsigned i = 0; i < __x.size(); ++i) {
00082 const bitset<_Nb>& bits = __x[i];
00083
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
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
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;
00124 } else if (_Traits::eq_int_type(__buf->sputbackc(__c2),__eof)) {
00125 __is.setstate(ios_base::failbit);
00126 break;
00127 } else {
00128
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
00147 if( __x.empty() ) {
00148 __is.setstate(ios_base::failbit);
00149 }
00150 }
00151 return __is;
00152 }
00153 #endif
00154
00155 }