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

na_nmer_overlap_stream.hpp

00001 #include <iostream>
00002 #include "bio_bit_traits.h"
00003 
00004 namespace std
00005 {
00006   template<class _CharT, class _Traits, size_t __Nb>
00007   basic_istream<_CharT, _Traits>&
00008   operator>>(basic_istream<_CharT, _Traits>& __is, basic_string<bitset<__Nb>, bioinfo::na_nmer_overlap<__Nb> >& __x) {
00009     // for now let's do this super hoky style
00010     typedef typename _Traits::char_type char_type;
00011     static typename _Traits::int_type __eof = _Traits::eof();
00012     const std::size_t char_size = bioinfo::na_nmer_overlap<__Nb>::bit_size();
00013     const std::size_t left_bit_idx = (__Nb-1);
00014     bitset<__Nb> curr_bits;
00015     typename basic_istream<_CharT, _Traits>::sentry __sentry(__is);
00016     if (__sentry) {
00017       basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
00018         std::size_t pos = 0;
00019         bool dirty = false;
00020         for(;;) {
00021           typename _Traits::int_type __c1 = __buf->sbumpc();
00022           if (_Traits::eq_int_type(__c1, __eof)) {
00023             __is.setstate(ios_base::eofbit);
00024             break;
00025           } else {
00026             char_type __c2 = _Traits::to_char_type(__c1);
00027             char_type __c  = __is.narrow(__c2, '*');
00028             if(bioinfo::na_nmer_overlap<__Nb>::valid_code(__c)) {
00029               dirty = true;
00030               bitset<__Nb> tmp_bits = bioinfo::na_nmer_overlap<__Nb>::bit_code(__c);
00031               if( pos > left_bit_idx ) {
00032                 curr_bits=curr_bits<<char_size;
00033               } else {
00034                 size_t shift_width = left_bit_idx - pos - (char_size-1);
00035                 tmp_bits=tmp_bits<<shift_width;
00036               }
00037               curr_bits |= tmp_bits;
00038             } else if (_Traits::eq_int_type(__buf->sputbackc(__c2),__eof)) { 
00039               __is.setstate(ios_base::failbit);
00040               break;
00041             } else {
00042               //__buf->sputbackc(__c2);
00043               break;
00044             }
00045           }
00046           if(pos <= left_bit_idx)
00047             pos += bioinfo::na_nmer_overlap<__Nb>::bit_size();
00048           if( pos > left_bit_idx ) {
00049             dirty = false;
00050             __x.push_back(curr_bits);
00051           }
00052         }
00053         if( dirty ) {
00054           __x.push_back(curr_bits);
00055         }
00056         // do I need to check if something got read?
00057         if(  __x.empty() ) {
00058           __is.setstate(ios_base::failbit);
00059         }
00060     }
00061     return __is;
00062   }
00063 
00064   template <class _CharT, class _Traits, size_t _Nb>
00065     basic_ostream<_CharT, _Traits>&
00066     operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<bitset<_Nb>, bioinfo::na_nmer_overlap<_Nb> >& __x)
00067     {
00068       //const std::size_t char_size = bioinfo::na_nmer_overlap<_Nb>::bit_size();
00069       //const std::size_t left_bit_idx = (_Nb-1);
00070       for(unsigned i = 0; i < __x.size(); ++i) {
00071         const bitset<_Nb>& bits = __x[i];
00072         // warning this restricts _Nb < 8&sizeof(unsigned long)
00073         // will probably need a better alternative here.
00074         __os<<bits.to_ulong(); 
00075         if( i < __x.size()-1 )
00076           __os<<" ";
00077         //cout<<"i: "<<i<<" bits: "<<bits<<endl;
00078 #if 0
00079         for(std::size_t pos = 0; pos < _Nb; pos += char_size) {
00080           size_t shift_width = left_bit_idx - pos - (char_size-1);
00081           bitset<_Nb> mask = (bits>>shift_width);
00082           //cout<<"mask: "<<mask<<endl;
00083           __os<<na_nmer_overlap<_Nb>::char_code(mask);
00084         }
00085 #endif
00086       }
00087       return __os;
00088     }
00089 
00090   template<size_t __Nb>
00091   bool
00092     operator==(const basic_string<bitset<__Nb>, bioinfo::na_nmer_overlap<__Nb> >& __x,
00093              const string& str) {
00094     const std::size_t char_size = bioinfo::na_nmer_overlap<__Nb>::bit_size();
00095     const std::size_t left_bit_idx = (__Nb-1);
00096     bitset<__Nb> curr_bits;
00097     std::size_t pos = 0;
00098     bool dirty = false;
00099     unsigned biter = 0;
00100     for(unsigned i = 0; i < str.size();  ++i) {
00101       char __c = str[i];
00102       if(bioinfo::na_nmer_overlap<__Nb>::valid_code(__c)) {
00103         dirty = true;
00104         bitset<__Nb> tmp_bits = bioinfo::na_nmer_overlap<__Nb>::bit_code(__c);
00105         if( pos > left_bit_idx ) {
00106           curr_bits=curr_bits<<char_size;
00107         } else {
00108           size_t shift_width = left_bit_idx - pos - (char_size-1);
00109           tmp_bits=tmp_bits<<shift_width;
00110         }
00111         curr_bits |= tmp_bits;
00112       } else {
00113         return false;
00114       }
00115       if(pos <= left_bit_idx)
00116         pos += bioinfo::na_nmer_overlap<__Nb>::bit_size();
00117       if( pos > left_bit_idx ) {
00118         dirty = false;
00119         // we've got a word, copmare
00120         if( __x[biter] != curr_bits ) {
00121           return false;
00122         }
00123         ++biter;
00124       }
00125     }
00126     if( dirty ) {
00127       if( __x[biter] != curr_bits ) {
00128         return false;
00129       }
00130       ++biter;
00131     }
00132     return true;
00133   }
00134 
00135 
00136 }