MAl_Readonly Class Reference

#include <mal_readonly.h>

Collaboration diagram for MAl_Readonly:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 MAl_Readonly (size_t bufsize, std::set< db_recno_t > &recnolist, TrapperDoc *pdoc)
virtual ~MAl_Readonly ()
void print_info (size_t ID)
size_t get_num_seq ()
std::string get_name (size_t ID)
std::string get_header (size_t ID)
std::string get_seq (size_t ID)
std::string get_strand (size_t ID)
size_t get_len (size_t ID)
void select_read (size_t ID, bool status)
size_t get_seq_row (size_t ID)
size_t get_seq_begin (size_t ID)
size_t get_seq_begin_global (size_t ID)
size_t get_seq_end (size_t ID)
size_t get_seq_end_global (size_t ID)
size_t get_beginGood (size_t ID)
size_t get_beginGood_global (size_t ID)
size_t get_endGood (size_t ID)
size_t get_endGood_global (size_t ID)
base_t get_base (size_t ID, size_t index)
base_t get_base_global (size_t ID, size_t index)
qual_t get_qual (size_t ID, size_t index)
qual_t get_qual_global (size_t ID, size_t index)
bool is_DNP (size_t ID, size_t index)
bool is_DNP_global (size_t ID, size_t index)
int get_DNP_ID (size_t ID, size_t index)
int get_DNP_ID_global (size_t ID, size_t index)
int get_DNP_type (size_t ID, size_t index)
int get_DNP_type_global (size_t ID, size_t index)
double get_max_expression (size_t ID)
size_t get_num_expression_points (size_t ID)
double get_expression (size_t ID, size_t expression_index)

Protected Member Functions

size_t get_buffID (size_t ID)
size_t next_buffID ()
virtual void flush_buffer (size_t buffID)
void read_from_db (size_t buffID, size_t ID)
void read_seq_from_db (db_recno_t recno, size_t buffID)
void read_feat_from_db (db_recno_t recno, size_t buffID, const string &data_type_name)
base_t comp_base (const char &base)

Protected Attributes

size_t buff_size
size_t num_seq
TrapperDoc * doc
std::set< db_recno_t > & selectedReads
std::vector< std::vector<
base_t > > 		seqs
std::vector< std::vector<
qual_t > > 		quals
std::vector< std::vector<
dnp_struct > > 		DNPs
std::vector< std::multimap<
size_t, tag_struct > > 		tags
std::vector< std::vector<
double > > 		time_course
std::vector< std::string > names
std::vector< std::string > headers
std::vector< std::string > mates
std::vector< std::string > strands
std::vector< size_t > seq_rows
std::vector< size_t > seq_begin_global
std::vector< size_t > seq_end_global
std::vector< size_t > seq_beginGood
std::vector< size_t > seq_endGood
std::vector< size_t > mate_lengths
vector< db_recno_t > ID_to_dbID
vector< size_t > ID_to_buffID
vector< db_recno_t > buffID_to_dbID
vector< db_recno_t > buffID_to_ID
vector< bool > put_in_db

Friends

class MAlWrapper

Classes

struct  dnp_struct
struct  tag_struct

Detailed Description

Definition at line 42 of file mal_readonly.h.

Constructor & Destructor Documentation

MAl_Readonly::MAl_Readonly ( size_t  bufsize,
std::set< db_recno_t > &  recnolist,
TrapperDoc *  pdoc 
)

MAl_Readonly::~MAl_Readonly (  )  [virtual]

Definition at line 83 of file mal_readonly.cc.

00084 {
00085   //Nothing to be done here...
00086 }

Member Function Documentation

void MAl_Readonly::print_info ( size_t  ID  )  [inline]

Definition at line 52 of file mal_readonly.h.

References get_len(), get_seq_begin_global(), and get_seq_end_global().

00052                              {
00053     cerr << "mal_readonly: print_info: ID = " << ID << endl;
00054     cerr << "get_seq_begin_global( ID ) = " << get_seq_begin_global( ID ) << endl;
00055     cerr << "get_seq_end_global( ID ) = " << get_seq_end_global( ID ) << endl;
00056     cerr << "get_len( ID ) = " << get_len( ID ) << endl;
00057   }

size_t MAl_Readonly::get_num_seq (  ) 

Definition at line 91 of file mal_readonly.cc.

References num_seq.

Referenced by StrandsAlgo::start().

00092 {
00093   return num_seq;
00094 }

std::string MAl_Readonly::get_name ( size_t  ID  ) 

Definition at line 96 of file mal_readonly.cc.

References get_buffID(), and names.

00097 {
00098   ID = get_buffID( ID );
00099   
00100   assert( ID < names.size() );
00101   
00102   return names[ ID ];
00103   
00104 }

std::string MAl_Readonly::get_header ( size_t  ID  ) 

Definition at line 106 of file mal_readonly.cc.

References get_buffID(), and headers.

00107 {
00108   ID = get_buffID( ID );
00109   
00110   assert( ID < headers.size() );
00111   
00112   return headers[ ID ];
00113   
00114 }

std::string MAl_Readonly::get_seq ( size_t  ID  ) 

Definition at line 116 of file mal_readonly.cc.

References get_buffID(), and seqs.

00117 {
00118   ID = get_buffID( ID );
00119   
00120   assert( ID < seqs.size() );
00121   
00122 //   return seqs[ ID ];
00123   return string(seqs[ ID ].begin(), seqs[ ID ].end());
00124   
00125 }

string MAl_Readonly::get_strand ( size_t  ID  ) 

Definition at line 127 of file mal_readonly.cc.

References get_buffID(), and strands.

00128 {
00129   ID = get_buffID( ID );
00130   
00131   assert( ID < strands.size() );
00132   
00133   return strands[ ID ];
00134   
00135 }

size_t MAl_Readonly::get_len ( size_t  ID  ) 

Definition at line 137 of file mal_readonly.cc.

References get_buffID(), and seqs.

Referenced by print_info().

00138 {
00139   ID = get_buffID( ID );
00140   
00141   assert( ID < seqs.size() );
00142   
00143   return seqs[ ID ].size();
00144   
00145 }

void MAl_Readonly::select_read ( size_t  ID,
bool  status 
)

Definition at line 147 of file mal_readonly.cc.

References ID_to_dbID, and selectedReads.

Referenced by StrandsAlgo::start().

00148 {
00149   
00150   assert( ID < ID_to_dbID.size() );
00151   
00152   db_recno_t recno = ID_to_dbID[ ID ];
00153   if ( recno == 0 ) return;
00154 
00155   set<db_recno_t>::iterator pos;
00156   if ( status == true )
00157     selectedReads.insert( recno );
00158   else if ( ( pos = selectedReads.find( recno )) != selectedReads.end() ) {
00159     selectedReads.erase( pos );
00160   }
00161   
00162   
00163 }

size_t MAl_Readonly::get_seq_row ( size_t  ID  ) 

Definition at line 168 of file mal_readonly.cc.

References get_buffID(), and seq_rows.

00169 {
00170   ID = get_buffID( ID );
00171 
00172   assert( ID < seq_rows.size() );
00173   
00174   return seq_rows[ ID ];
00175   
00176 }

size_t MAl_Readonly::get_seq_begin ( size_t  ID  ) 

size_t MAl_Readonly::get_seq_begin_global ( size_t  ID  ) 

Definition at line 179 of file mal_readonly.cc.

References get_buffID(), and seq_begin_global.

Referenced by get_base_global(), get_beginGood_global(), get_DNP_ID_global(), get_DNP_type_global(), get_endGood_global(), get_qual_global(), get_seq_end(), is_DNP_global(), and print_info().

00181 {
00182   ID = get_buffID( ID );
00183 
00184   assert( ID < seq_begin_global.size() );
00185   
00186   return seq_begin_global[ ID ];
00187                            
00188 }

size_t MAl_Readonly::get_seq_end ( size_t  ID  ) 

Definition at line 191 of file mal_readonly.cc.

References get_seq_begin_global(), and get_seq_end_global().

00192 {
00193   
00194   return get_seq_end_global( ID ) - get_seq_begin_global( ID );
00195 }

size_t MAl_Readonly::get_seq_end_global ( size_t  ID  ) 

Definition at line 197 of file mal_readonly.cc.

References get_buffID(), and seq_end_global.

Referenced by get_seq_end(), and print_info().

00198 {
00199   ID = get_buffID( ID );
00200 
00201   assert( ID < seq_end_global.size() );
00202   
00203   return seq_end_global[ ID ];
00204   
00205 }

size_t MAl_Readonly::get_beginGood ( size_t  ID  ) 

Definition at line 208 of file mal_readonly.cc.

References get_buffID(), and seq_beginGood.

Referenced by get_beginGood_global().

00209 {
00210   ID = get_buffID( ID );
00211 
00212   assert( ID < seq_beginGood.size() );
00213   
00214   return seq_beginGood[ ID ];
00215 }

size_t MAl_Readonly::get_beginGood_global ( size_t  ID  ) 

Definition at line 217 of file mal_readonly.cc.

References get_beginGood(), and get_seq_begin_global().

00218 {
00219   return get_beginGood( ID ) + get_seq_begin_global( ID );
00220   
00221 }

size_t MAl_Readonly::get_endGood ( size_t  ID  ) 

Definition at line 224 of file mal_readonly.cc.

References get_buffID(), and seq_endGood.

Referenced by get_endGood_global().

00225 {
00226   ID = get_buffID( ID );
00227 
00228   assert( ID < seq_endGood.size() );
00229   
00230   return seq_endGood[ ID ];
00231   
00232 }

size_t MAl_Readonly::get_endGood_global ( size_t  ID  ) 

Definition at line 234 of file mal_readonly.cc.

References get_endGood(), and get_seq_begin_global().

00235 {
00236   return get_endGood( ID ) + get_seq_begin_global( ID );
00237 }

base_t MAl_Readonly::get_base ( size_t  ID,
size_t  index 
)

Definition at line 239 of file mal_readonly.cc.

References get_buffID(), and seqs.

Referenced by get_base_global().

00240 {
00241   
00242   ID = get_buffID( ID );
00243   
00244   assert( ID < seqs.size() );
00245 
00246   if (index >= seqs[ ID ].size() ) {
00247     cout << flush;
00248     cerr << "index (local) = " << index << ", seqs[ ID ].size() = " << seqs[ ID ].size() << endl;
00249 
00250   }
00251   assert( index < seqs[ ID ].size() );
00252   
00253   base_t tmp = seqs[ ID ][ index ];
00254   if (tmp == '*') {
00255     tmp = '-';
00256   }
00257   
00258   return tmp;
00259 //  return seqs[ ID ][ index ];
00260 }

base_t MAl_Readonly::get_base_global ( size_t  ID,
size_t  index 
)

Definition at line 262 of file mal_readonly.cc.

References get_base(), and get_seq_begin_global().

00263 {
00264   return get_base( ID, index - get_seq_begin_global( ID ) );
00265   
00266 }

qual_t MAl_Readonly::get_qual ( size_t  ID,
size_t  index 
)

Definition at line 268 of file mal_readonly.cc.

References get_buffID(), and quals.

Referenced by get_qual_global().

00269 {
00270   ID = get_buffID( ID );
00271   
00272   assert( ID < quals.size() );
00273   assert( index < quals[ ID ].size() );
00274   
00275   return quals[ ID ][ index ];
00276   
00277 }

qual_t MAl_Readonly::get_qual_global ( size_t  ID,
size_t  index 
)

Definition at line 279 of file mal_readonly.cc.

References get_qual(), and get_seq_begin_global().

00280 {
00281   
00282   return get_qual( ID, index - get_seq_begin_global( ID ) );
00283   
00284 }

bool MAl_Readonly::is_DNP ( size_t  ID,
size_t  index 
)

Definition at line 287 of file mal_readonly.cc.

References DNPs, and get_buffID().

Referenced by is_DNP_global().

00288 {
00289   ID = get_buffID( ID );
00290 
00291   if ( index >= DNPs[ ID ].size() ) {
00292     
00293   }
00294 
00295   assert( ID < DNPs.size() );
00296   assert( index < DNPs[ ID ].size() );
00297   
00298   return DNPs[ ID ][ index ].isDNP;
00299 }

bool MAl_Readonly::is_DNP_global ( size_t  ID,
size_t  index 
)

Definition at line 301 of file mal_readonly.cc.

References get_seq_begin_global(), and is_DNP().

00302 {
00303 
00304   return is_DNP( ID, index - get_seq_begin_global( ID ) );
00305 }

int MAl_Readonly::get_DNP_ID ( size_t  ID,
size_t  index 
)

Definition at line 307 of file mal_readonly.cc.

References DNPs, and get_buffID().

Referenced by get_DNP_ID_global().

00308 {
00309   ID = get_buffID( ID );
00310 
00311   assert( ID < DNPs.size() );
00312   assert( index < DNPs[ ID ].size() );
00313   
00314   return DNPs[ ID ][ index ].ID;  
00315 }

int MAl_Readonly::get_DNP_ID_global ( size_t  ID,
size_t  index 
)

Definition at line 317 of file mal_readonly.cc.

References get_DNP_ID(), and get_seq_begin_global().

00318 {
00319   return get_DNP_ID( ID, index - get_seq_begin_global( ID ) ); 
00320 }

int MAl_Readonly::get_DNP_type ( size_t  ID,
size_t  index 
)

Definition at line 322 of file mal_readonly.cc.

References DNPs, and get_buffID().

Referenced by get_DNP_type_global().

00323 {
00324   ID = get_buffID( ID );
00325 
00326   assert( ID < DNPs.size() );
00327   assert( index < DNPs[ ID ].size() );
00328   
00329   return DNPs[ ID ][ index ].type;
00330 }

int MAl_Readonly::get_DNP_type_global ( size_t  ID,
size_t  index 
)

Definition at line 332 of file mal_readonly.cc.

References get_DNP_type(), and get_seq_begin_global().

00333 {
00334   return get_DNP_type( ID, index - get_seq_begin_global( ID ) );  
00335 }

double MAl_Readonly::get_max_expression ( size_t  ID  ) 

Definition at line 533 of file mal_readonly.cc.

References get_buffID(), and time_course.

00534 {
00535   ID = get_buffID( ID );
00536 
00537   assert( ID < time_course.size() );
00538   
00539   double tc_max(0.000001);
00540   bool maxfound(false);
00541 //   cerr<<names[ ID ]<<endl;
00542   
00543   for( size_t i = 0; i < time_course[ID].size(); i++ ) {
00544     if ( time_course[ID][i] > tc_max ) {
00545       tc_max = time_course[ID][i];
00546       maxfound = true;
00547     }
00548   }
00549   if ( maxfound ) {
00550 //     cerr<<"yo, tc_max: "<<tc_max<<endl;
00551     return tc_max;
00552   }
00553 
00554   return 0.0;
00555 }

size_t MAl_Readonly::get_num_expression_points ( size_t  ID  ) 

Definition at line 557 of file mal_readonly.cc.

References get_buffID(), and time_course.

00558 {
00559   ID = get_buffID( ID );
00560 
00561   assert( ID < time_course.size() );
00562 
00563   return time_course[ID].size();
00564 }

double MAl_Readonly::get_expression ( size_t  ID,
size_t  expression_index 
)

Definition at line 566 of file mal_readonly.cc.

References get_buffID(), and time_course.

00567 {
00568   ID = get_buffID( ID );
00569 
00570   assert( ID < time_course.size() );
00571   assert( expression_index < time_course[ID].size() );
00572 
00573   return time_course[ID][expression_index];
00574 }

size_t MAl_Readonly::get_buffID ( size_t  ID  )  [protected]

Definition at line 340 of file mal_readonly.cc.

References flush_buffer(), ID_to_buffID, next_buffID(), put_in_db, and read_from_db().

Referenced by get_base(), get_beginGood(), get_DNP_ID(), get_DNP_type(), get_endGood(), get_expression(), get_header(), get_len(), get_max_expression(), get_name(), get_num_expression_points(), get_qual(), get_seq(), get_seq_begin_global(), get_seq_end_global(), get_seq_row(), get_strand(), and is_DNP().

00341 {
00342   
00343 
00344   assert( ID < ID_to_buffID.size() );
00345   size_t buffID = ID_to_buffID[ ID ];
00346 
00347   if ( buffID == 0 ) {
00348     //Seq is not present in buffer and thus has to be read into buffer,
00349     //OR a new seq is being created
00350     buffID = next_buffID();
00351 
00352     if ( buffID >= put_in_db.size() ) {
00353       cerr<<"buffID: "<<buffID<<endl;
00354       cerr<<"put_in_db.size(): "<<put_in_db.size()<<endl;
00355     }
00356     
00357     assert( buffID < put_in_db.size() );
00358     
00359     if ( put_in_db[ buffID ] ) {
00360       
00361       flush_buffer( buffID );
00362     }
00363     
00364     //If dbID is 0, a new seq is being created and nothing has to be read from DB
00365     //This is taken care of in read_from_db()
00366 
00367     read_from_db( buffID, ID );
00368 
00369     
00370   }
00371   assert( buffID != 0 );
00372   return buffID;
00373 
00374 }

size_t MAl_Readonly::next_buffID (  )  [protected]

Definition at line 376 of file mal_readonly.cc.

Referenced by get_buffID().

00377 {
00378 //   static size_t curr_buffID(static_cast<size_t>(-1));//Have to check this, but should work although size_t is unsigned
00379   static size_t curr_buffID(0);//ID == 0 is unused...
00380   ++curr_buffID;
00381   
00382   if ( curr_buffID == buff_size ) curr_buffID = 1;
00383   
00384   return curr_buffID;
00385   
00386 }

void MAl_Readonly::flush_buffer ( size_t  buffID  )  [protected, virtual]

Definition at line 388 of file mal_readonly.cc.

Referenced by get_buffID().

00389 {
00390   //Not implemented in read only MAl
00391   
00392 }

void MAl_Readonly::read_from_db ( size_t  buffID,
size_t  ID 
) [protected]

Definition at line 394 of file mal_readonly.cc.

References buffID_to_dbID, buffID_to_ID, ID_to_buffID, ID_to_dbID, put_in_db, read_feat_from_db(), and read_seq_from_db().

Referenced by get_buffID().

00395 {
00396 
00397   db_recno_t recno = ID_to_dbID[ ID ];
00398 
00399   if ( recno != 0 ) {
00400 
00401     //NB: EXTREMELY important that DNP features and other features
00402     //that appear more than once on reads are read AFTER DnaStrData!!!
00403 
00404     read_seq_from_db( recno, buffID );
00405     read_feat_from_db( recno, buffID, "ReadMetaData");//Metadata
00406     read_feat_from_db( recno, buffID, "DnaStrData");//The seq
00407     read_feat_from_db( recno, buffID, "QualityData");//The qual
00408     read_feat_from_db( recno, buffID, "DnpData");//The dnps
00409     read_feat_from_db( recno, buffID, "TagData");//General tags
00410     
00411     
00412     /*
00413       read_feat_from_db( recno, buffID, "beginGood");//Maybe this should be added as data in the seq class...
00414       read_feat_from_db( recno, buffID, "endGood");//Ditto
00415       read_feat_from_db( recno, buffID, "name");//Ditto
00416       read_feat_from_db( recno, buffID, "header");//Ditto
00417       read_feat_from_db( recno, buffID, "strand");//Ditto
00418       
00419     */
00420     
00421   }
00422   
00423 
00424   ID_to_buffID[ ID ] = buffID;
00425   buffID_to_dbID[ buffID ] = recno;
00426   buffID_to_ID[ buffID ] = ID;
00427   put_in_db[ buffID ] = true;
00428 }

void MAl_Readonly::read_seq_from_db ( db_recno_t  recno,
size_t  buffID 
) [protected]

Definition at line 430 of file mal_readonly.cc.

References Database::PrimaryIterator< T >::answer(), doc, ReadData::endPos(), ReadData::row(), seq_begin_global, seq_end_global, seq_rows, Database::PrimaryIterator< T >::setFromRecno(), and ReadData::startPos().

Referenced by read_from_db().

00431 {
00432 
00433   Database::PrimaryIterator<ReadData> read_it(doc, "ReadData");
00434 
00435   int ret_read = read_it.setFromRecno(recno);
00436   ReadData* r_test = (ret_read != DB_NOTFOUND) ? read_it.answer() : 0;
00437   assert( r_test );
00438 
00439   seq_begin_global[ buffID ] = r_test->startPos();
00440   seq_end_global[ buffID ] = r_test->endPos() + 1;//Index annoyance...
00441   seq_rows[ buffID ] = r_test->row();
00442 //   names[ buffID ] = r_test->name();
00443 //   mates[ buffID ] = r_test->mate();
00444 //   strands[ buffID ] = r_test->strand();
00445 //   seq_beginGood[ buffID ] = r_test->beginGood();
00446 //   seq_endGood[ buffID ] = r_test->endGood() + 1;
00447 //   mate_lengths[ buffID ] = r_test->mateLength();
00448 //   time_course[ buffID ] = r_test->tc_vec.stlVector();
00449   
00450 //   cerr<<"Reading seq: "<<endl;
00451 //   cerr<<"recno: "<<recno<<endl;
00452 //   cerr<<"r_test->startPos(): "<<r_test->startPos()<<endl;
00453 //   cerr<<"r_test->endPos(): "<<r_test->endPos()<<endl;
00454 
00455 }

void MAl_Readonly::read_feat_from_db ( db_recno_t  recno,
size_t  buffID,
const string &  data_type_name 
) [protected]

Definition at line 457 of file mal_readonly.cc.

References Database::SecondaryIterator< T >::answer(), DNPs, doc, Database::SecondaryIterator< T >::key(), mate_lengths, mates, names, Database::SecondaryIterator< T >::nextdup(), quals, seq_beginGood, seq_endGood, seqs, Database::SecondaryIterator< T >::set(), FeatureData::setReadRecno(), strands, tags, and time_course.

Referenced by read_from_db().

00458 {
00459   Database::SecondaryIterator<FeatureData> feat_it("readRecno", doc, data_type_name);
00460   
00461   feat_it.key()->setReadRecno( recno );
00462 
00463   if ( feat_it.set() != 0 ) {
00464 
00465     return;
00466   }
00467 
00468   
00469   if ( DnaStrData* data = dynamic_cast<DnaStrData*>(feat_it.answer()) ) {
00470     seqs[buffID] = data->dnaVector.stlVector();
00471     //Have to init DNPs here to assert that DNP vec is of same size...
00472     DNPs[buffID] = vector<dnp_struct>(seqs[buffID].size(), dnp_struct());
00473   }
00474   else if ( QualityData* data = dynamic_cast<QualityData*>(feat_it.answer()) ) {
00475     quals[buffID] = data->qualityVector.stlVector();
00476   }
00477   else if ( DnpData* data = dynamic_cast<DnpData*>(feat_it.answer()) ) {
00478     
00479     do {
00480 
00481       DNPs[buffID][ data->startPos() ].isDNP = true;
00482       DNPs[buffID][ data->startPos() ].recno = data->getRecno();
00483       DNPs[buffID][ data->startPos() ].ID = data->get_dnpID();      
00484       DNPs[buffID][ data->startPos() ].type = data->get_dnp_type();      
00485 
00486     } while ( (feat_it.nextdup() == 0) && (data = dynamic_cast<DnpData*>(feat_it.answer())) );
00487   }
00488   else if ( TagData* data = dynamic_cast<TagData*>(feat_it.answer()) ) {
00489     do {
00490       ostringstream os;
00491       os << data->getScore() <<" "<< data->getInfo();
00492       tags[buffID].insert( pair<size_t, tag_struct>( data->endPos() + 1, tag_struct(data->startPos(), data->endPos() + 1, data_type_name, os.str(), data->getRecno()) ) );
00493       
00494     } while ( (feat_it.nextdup() == 0) && (data = dynamic_cast<TagData*>(feat_it.answer())) );
00495   }
00496   else if (ReadMetaData* data = dynamic_cast<ReadMetaData*>(feat_it.answer()) ) {
00497     
00498     names[ buffID ] = data->name();
00499     mates[ buffID ] = data->mate();
00500     strands[ buffID ] = data->strand();
00501     seq_beginGood[ buffID ] = data->beginGood();
00502     seq_endGood[ buffID ] = data->endGood() + 1;
00503     mate_lengths[ buffID ] = data->mateLength();
00504     time_course[ buffID ] = data->tc_vec.stlVector();
00505     
00506   }
00507   
00508 }

base_t MAl_Readonly::comp_base ( const char &  base  )  [protected]

Definition at line 513 of file mal_readonly.cc.

00514 {
00515   char tmp = toupper(base);
00516   if ( tmp == 'A') {
00517     return base + 19;
00518   }
00519   else if ( tmp == 'T' ) {
00520     return base - 19;    
00521   }
00522   else if ( tmp == 'G' ) {
00523     return base - 4;    
00524   }
00525   else if ( tmp == 'C' ) {
00526     return base + 4;    
00527   }
00528   else {
00529     return base;
00530   }
00531 }

Friends And Related Function Documentation

friend class MAlWrapper [friend]

Definition at line 109 of file mal_readonly.h.

Member Data Documentation

size_t MAl_Readonly::buff_size [protected]

Definition at line 150 of file mal_readonly.h.

size_t MAl_Readonly::num_seq [protected]

Definition at line 151 of file mal_readonly.h.

Referenced by get_num_seq().

TrapperDoc* MAl_Readonly::doc [protected]

Definition at line 152 of file mal_readonly.h.

Referenced by read_feat_from_db(), and read_seq_from_db().

std::set<db_recno_t>& MAl_Readonly::selectedReads [protected]

Definition at line 153 of file mal_readonly.h.

Referenced by select_read().

std::vector<std::vector<base_t> > MAl_Readonly::seqs [protected]

Definition at line 157 of file mal_readonly.h.

Referenced by get_base(), get_len(), get_seq(), and read_feat_from_db().

std::vector<std::vector<qual_t> > MAl_Readonly::quals [protected]

Definition at line 158 of file mal_readonly.h.

Referenced by get_qual(), and read_feat_from_db().

std::vector<std::vector<dnp_struct> > MAl_Readonly::DNPs [protected]

Definition at line 159 of file mal_readonly.h.

Referenced by get_DNP_ID(), get_DNP_type(), is_DNP(), and read_feat_from_db().

std::vector<std::multimap<size_t, tag_struct> > MAl_Readonly::tags [protected]

Definition at line 160 of file mal_readonly.h.

Referenced by read_feat_from_db().

std::vector<std::vector<double> > MAl_Readonly::time_course [protected]

Definition at line 161 of file mal_readonly.h.

Referenced by get_expression(), get_max_expression(), get_num_expression_points(), and read_feat_from_db().

std::vector<std::string> MAl_Readonly::names [protected]

Definition at line 163 of file mal_readonly.h.

Referenced by get_name(), and read_feat_from_db().

std::vector<std::string> MAl_Readonly::headers [protected]

Definition at line 164 of file mal_readonly.h.

Referenced by get_header().

std::vector<std::string> MAl_Readonly::mates [protected]

Definition at line 165 of file mal_readonly.h.

Referenced by read_feat_from_db().

std::vector<std::string> MAl_Readonly::strands [protected]

Definition at line 166 of file mal_readonly.h.

Referenced by get_strand(), and read_feat_from_db().

std::vector<size_t> MAl_Readonly::seq_rows [protected]

Definition at line 168 of file mal_readonly.h.

Referenced by get_seq_row(), and read_seq_from_db().

std::vector<size_t> MAl_Readonly::seq_begin_global [protected]

Definition at line 169 of file mal_readonly.h.

Referenced by get_seq_begin_global(), and read_seq_from_db().

std::vector<size_t> MAl_Readonly::seq_end_global [protected]

Definition at line 170 of file mal_readonly.h.

Referenced by get_seq_end_global(), and read_seq_from_db().

std::vector<size_t> MAl_Readonly::seq_beginGood [protected]

Definition at line 171 of file mal_readonly.h.

Referenced by get_beginGood(), and read_feat_from_db().

std::vector<size_t> MAl_Readonly::seq_endGood [protected]

Definition at line 172 of file mal_readonly.h.

Referenced by get_endGood(), and read_feat_from_db().

std::vector<size_t> MAl_Readonly::mate_lengths [protected]

Definition at line 173 of file mal_readonly.h.

Referenced by read_feat_from_db().

vector<db_recno_t> MAl_Readonly::ID_to_dbID [protected]

Definition at line 176 of file mal_readonly.h.

Referenced by read_from_db(), and select_read().

vector<size_t> MAl_Readonly::ID_to_buffID [protected]

Definition at line 177 of file mal_readonly.h.

Referenced by get_buffID(), and read_from_db().

vector<db_recno_t> MAl_Readonly::buffID_to_dbID [protected]

Definition at line 178 of file mal_readonly.h.

Referenced by read_from_db().

vector<db_recno_t> MAl_Readonly::buffID_to_ID [protected]

Definition at line 179 of file mal_readonly.h.

Referenced by read_from_db().

vector<bool> MAl_Readonly::put_in_db [protected]

Definition at line 180 of file mal_readonly.h.

Referenced by get_buffID(), and read_from_db().

The documentation for this class was generated from the following files:
Generated on Fri Jul 17 20:19:49 2009 for ngsview by  doxygen 1.5.1