ngsview: featuredata.cpp Source File

00001 /*******************************************************************************
00002  *                                                                             *
00003  *   Copyright (C) 2003  Erik Sjolund,  (<html>Erik Sj&ouml;lund</html>)       *
00004  *                       Center for Genomics and Bioinformatics,               *
00005  *                       Karolinska Institutet,                                *
00006  *                       Stockholm,                                            *
00007  *                       Sweden                                                *
00008  *                                                                             *
00009  *  Author: Erik Sjolund                                                       *
00010  *  Email: erik.sjolund@adivo.se                                               *
00011  *                                                                             *
00012  *******************************************************************************
00013  */
00014 
00015 #include "featuredata.h"
00016 #include <qdatastream.h>
00017 #include <qstring.h>
00018 #include <iostream>
00019 
00020 using namespace std;
00021 
00022 class Dbt;
00023 
00024 FeatureData::FeatureData( db_recno_t readRec) : GeneralData()
00025 {
00026   readRecno_ = readRec;
00027   m_gui = NULL;
00028   m_info = NULL;
00029 }
00030 
00031 FeatureData::~FeatureData() 
00032 {
00033   delete m_gui;
00034   delete m_info;
00035 }
00036 
00037 FeatureGui * FeatureData::gui()
00038 {
00039   
00040   if ( !m_gui )
00041     m_gui = makeGui();
00042   
00043   return m_gui;
00044 }
00045 
00046 FeatureInfo * FeatureData::info()
00047 {
00048   
00049   if ( !m_info )
00050     m_info = makeInfo();
00051   
00052   return m_info;
00053 }
00054 
00055 
00056 TrDb::IndexMap FeatureData::getIndexMap()
00057 {
00058   TrDb::IndexMap iMap;
00059   TrDb::Index i = {
00060     &FeatureData::bt_compare_seqRecNo,
00061     &FeatureData::getSeqRecNo,
00062     QString("readRecno"),
00063     NULL
00064   };
00065   iMap.insert( make_pair( i.name.ascii(), i ) );//Have to use ascii function since call is otherwise ambigous...
00066   return iMap;
00067 }
00068 
00069 int FeatureData::bt_compare_seqRecNo( DB * , const DBT *dbt1, const DBT *dbt2)
00070 {
00071     /* order after row and then after end position */
00072     db_recno_t * recno1  = ( db_recno_t *) dbt1->data;
00073     db_recno_t * recno2  = ( db_recno_t *) dbt2->data;
00074     if ( *recno1 > *recno2 )
00075         return 1;
00076     if ( *recno1 < *recno2 )
00077         return -1;
00078     if ( *recno1 == *recno2 )
00079         return 0;
00080     /* should never reach this point */
00081     return 0;
00082 }
00083 
00084 int FeatureData::getSeqRecNo( Db * /* dbp */ , const Dbt *  /* pkey */, const Dbt *pdata, Dbt *skey)
00085 {
00086     memset(skey, 0, sizeof(Dbt));
00087     db_recno_t * data = ( db_recno_t * ) pdata->get_data();
00088     skey->set_data( data );
00089     skey->set_size(sizeof( db_recno_t ));
00090     return(0);
00091 }
00092 
00093 void FeatureData::writeStream( QDataStream & stream )
00094 {
00095   QIODevice * dev = stream.device();
00096   Q_ASSERT( dev );
00097   if ( ! ( IO_WriteOnly & dev->mode() ) )
00098     {
00099       cerr << "data stream should be writeonly" << endl;
00100       exit(1);
00101     }
00102   //     stream.writeRawBytes( ( char * ) &s, sizeof ( StorageData ) );
00103   stream<<readRecno_;
00104 }
00105 
00106 void FeatureData::readStream( QDataStream & stream )
00107 {
00108   QIODevice * dev = stream.device();
00109   Q_ASSERT( dev );
00110 //   stream.readRawBytes( ( char * ) &s, sizeof ( StorageData ) );
00111   stream>>readRecno_;
00112 }
00113 
00114 void FeatureData::readAttributes( const QXmlAttributes& attr )
00115 {
00116   
00117 }
00118 void FeatureData::writeXml( ostream& stream )
00119 {
00120   stream<<'<'<<uniqueName()<<' ';
00121 }
00122 
00123 void FeatureData::print_debug_info()
00124 {
00125   cerr<<"readRecno: "<<readRecno_<<endl;
00126 }
00127 
00128 
00129 SpatialFeatureData::SpatialFeatureData( db_recno_t readRec, TR_DNA start, TR_DNA end) : FeatureData(readRec)
00130 {
00131     startPos_ = start;
00132     endPos_ = end;
00133 }
00134 
00135 SpatialFeatureData::~SpatialFeatureData() 
00136 {
00137 }
00138 
00139 void SpatialFeatureData::readStream( QDataStream & stream )
00140 {
00141   FeatureData::readStream(stream);
00142   stream>>startPos_;
00143   stream>>endPos_;
00144 }
00145 
00146 void SpatialFeatureData::writeStream( QDataStream & stream )
00147 {
00148   FeatureData::writeStream(stream);
00149   stream<<startPos_;
00150   stream<<endPos_;  
00151 }
00152 
00153 void SpatialFeatureData::readAttributes( const QXmlAttributes& attr )
00154 {
00155   FeatureData::readAttributes(attr);
00156   if ( attr.value("startPos") != "" ) {
00157     QString startPosStr = attr.value("startPos");
00158     long startPosLong = startPosStr.toLong();
00159     // is long the same thing as Q_INT64 ?
00160     startPos_ = startPosLong;
00161   }
00162   if ( attr.value("endPos") != "" ) {  
00163     QString endPosStr = attr.value("endPos");
00164     ulong endPosLong = endPosStr.toLong();
00165     endPos_ = endPosLong;
00166   }
00167 }
00168 void SpatialFeatureData::writeXml( ostream& stream )
00169 {
00170   FeatureData::writeXml(stream);
00171   stream<<"startPos=\""<<startPos_<<"\" "
00172         <<"endPos=\""<<endPos_<<"\"";
00173 }
00174 
00175 void SpatialFeatureData::print_debug_info()
00176 {
00177   FeatureData::print_debug_info();
00178   cerr<<"startPos: "<<startPos_<<endl;
00179   cerr<<"endPos: "<<endPos_<<endl;
00180 }
00181 
00182 FeatureInfo * SpatialFeatureData::makeInfo()
00183 {
00184   return new FeatureInfo(this);
00185 }
00186 
00187 
00188 DnpData::DnpData( db_recno_t readRecno, TR_DNA startPos, TR_DNA endPos )
00189   : SpatialFeatureData( readRecno, startPos, endPos ), dnpID(-1), type(-1)
00190 {}
00191 
00192 void DnpData::readStream( QDataStream & stream )
00193 {
00194   SpatialFeatureData::readStream( stream );
00195   stream>>dnpID>>type;
00196 }
00197 
00198 void DnpData::writeStream( QDataStream & str )
00199 {
00200     SpatialFeatureData::writeStream( str );
00201     str<<dnpID<<type;
00202 }
00203 
00204 void DnpData::writeDom( QDomElement & elem )
00205 {
00206     SpatialFeatureData::writeDom( elem );
00207     elem.setAttribute("dnp", "11" );
00208 }
00209 
00210 void DnpData::readDom( QDomElement & elem )
00211 {
00212     SpatialFeatureData::readDom( elem );
00213 }
00214 
00215 void DnpData::readAttributes( const QXmlAttributes& attr )
00216 {
00217     SpatialFeatureData::readAttributes( attr );
00218     if ( attr.value("dnpID") != "" ) {
00219       dnpID = attr.value("dnpID").toInt();
00220     }
00221     if ( attr.value("type") != "" ) {
00222       type = attr.value("type").toInt();
00223     }
00224     
00225 }
00226 void DnpData::writeXml( ostream& stream )
00227 {
00228   SpatialFeatureData::writeXml(stream);
00229   stream<<" dnpID=\""<<dnpID<<"\""
00230         <<" type=\""<<type<<"\"";
00231   stream<<"/>\n";
00232 }
00233 
00234 
00235 void DnpData::set_dnpID(int id)
00236 {
00237   dnpID = id;
00238 }
00239 
00240 int DnpData::get_dnpID()
00241 {
00242   return dnpID;
00243 }
00244 
00245 void DnpData::set_dnp_type(int t)
00246 {
00247   type = t;
00248 }
00249 
00250 int DnpData::get_dnp_type()
00251 {
00252   return type;
00253 }
00254 
00255 void DnaStrData::writeStream( QDataStream & stream )
00256 {
00257     SpatialFeatureData::writeStream( stream );
00258     stream << dnaVector;
00259 }
00260 
00261 
00262 DnaStrData::DnaStrData(  db_recno_t readRecno, TR_DNA startPos, TR_DNA endPos )
00263         : SpatialFeatureData( readRecno, startPos, endPos )
00264 {}
00265 
00266 void DnaStrData::readStream( QDataStream & stream )
00267 {
00268     SpatialFeatureData::readStream( stream );
00269     stream >> dnaVector;
00270 }
00271 
00272 
00273 
00274 void DnaStrData::writeDom( QDomElement & elem )
00275 {
00276     SpatialFeatureData::writeDom( elem );
00277     dnaVector.writeDom( elem );
00278 }
00279 
00280 void DnaStrData::readDom( QDomElement & elem )
00281 {
00282     SpatialFeatureData::readDom( elem );
00283     dnaVector.readDom( elem );
00284 }
00285 
00286 void DnaStrData::readAttributes(const QXmlAttributes& attr)
00287 {
00288     SpatialFeatureData::readAttributes(attr);
00289     dnaVector.readAttributes(attr);
00290 }
00291 
00292 void DnaStrData::writeXml( ostream& stream )
00293 {
00294   SpatialFeatureData::writeXml(stream);
00295   stream<<" trappervector=\"";
00296   for( size_t i = 0; i < dnaVector.stlVector().size(); i++ ) {
00297     stream<<dnaVector.stlVector()[i];
00298   }
00299   stream<<"\"/>\n";
00300 }
00301 
00302 
00303 DnaStrData::~DnaStrData()
00304 {
00305 }
00306 
00307 void QualityData::readStream( QDataStream & stream )
00308 {
00309     SpatialFeatureData::readStream( stream );
00310     stream >> qualityVector;
00311 }
00312 
00313 void QualityData::writeStream( QDataStream & stream )
00314 {
00315     SpatialFeatureData::writeStream( stream );
00316     stream << qualityVector;
00317 }
00318 
00319 void QualityData::writeDom( QDomElement & elem )
00320 {
00321     SpatialFeatureData::writeDom( elem );
00322     qualityVector.writeDom( elem );
00323 }
00324 
00325 void QualityData::readDom( QDomElement & elem )
00326 {
00327     SpatialFeatureData::readDom( elem );
00328     qualityVector.readDom( elem );
00329 }
00330 
00331 void QualityData::readAttributes(const QXmlAttributes& attr)
00332 {
00333     SpatialFeatureData::readAttributes(attr);
00334     qualityVector.readAttributes(attr);
00335 }
00336 
00337 void QualityData::writeXml( ostream& stream )
00338 {
00339   SpatialFeatureData::writeXml(stream);
00340   stream<<" trappervector=\"";
00341   for( size_t i = 0; i < qualityVector.stlVector().size(); i++ ) {
00342     stream<<' '<<qualityVector.stlVector()[i];
00343   }
00344   stream<<"\"/>\n";
00345 }
00346 
00347 ChromatData::ChromatData( db_recno_t readRecno, TR_DNA startPos, TR_DNA endPos ):
00348   SpatialFeatureData( readRecno, startPos, endPos ), cagt_vec(4)
00349 {}
00350 
00351 void ChromatData::readStream( QDataStream & str )
00352 {
00353   SpatialFeatureData::readStream( str );
00354   for( size_t i = 0; i < 4; i++ ) {
00355     str>>cagt_vec[i];
00356   }
00357   str>>phd_vec;
00358   str>>gap_vec;
00359 }
00360 
00361 void ChromatData::writeStream( QDataStream & str )
00362 {
00363   SpatialFeatureData::writeStream( str );
00364   for( size_t i = 0; i < 4; i++ ) {
00365     str<<cagt_vec[i];
00366   }
00367   str<<phd_vec;
00368   str<<gap_vec;
00369 }
00370 
00371 void ChromatData::writeDom( QDomElement & elem )
00372 {
00373     SpatialFeatureData::writeDom( elem );
00374     elem.setAttribute("cc", "11" );
00375 }
00376 
00377 void ChromatData::readDom( QDomElement & elem )
00378 {
00379     SpatialFeatureData::readDom( elem );
00380     //     tVector.readDom( elem );
00381 }
00382 void ChromatData::readAttributes(const QXmlAttributes& attr)
00383 {
00384     SpatialFeatureData::readAttributes(attr);
00385     //Order is c, a, g, t
00386     if ( attr.value("c_vector") != "" ) {
00387       QString str = attr.value("c_vector");
00388       cagt_vec[0].readString(str);
00389 
00390     }
00391     if ( attr.value("a_vector") != "" ) {
00392       QString str = attr.value("a_vector");
00393       cagt_vec[1].readString(str);
00394 
00395     }
00396     if ( attr.value("g_vector") != "" ) {
00397       QString str = attr.value("g_vector");
00398       cagt_vec[2].readString(str);
00399 
00400     }
00401     if ( attr.value("t_vector") != "" ) {
00402       QString str = attr.value("t_vector");
00403       cagt_vec[3].readString(str);
00404 
00405     }
00406     if ( attr.value("phd") != "" ) {
00407       QString str = attr.value("phd");
00408       phd_vec.readString(str);
00409 
00410     }
00411     if ( attr.value("gap") != "" ) {
00412       QString str = attr.value("gap");
00413       gap_vec.readString(str);
00414 
00415     }
00416     
00417 }
00418 void ChromatData::writeXml( ostream& stream )
00419 {
00420   SpatialFeatureData::writeXml(stream);
00421   if ( cagt_vec[0].stlVector().size() > 0 ) {
00422     stream<<" c_vector=\"";
00423     for( size_t i = 0; i < cagt_vec[0].stlVector().size(); i++ ) {
00424       stream<<' '<<cagt_vec[0].stlVector()[i];
00425     }
00426     stream<<"\"";
00427   }
00428   if ( cagt_vec[1].stlVector().size() > 0 ) {
00429     stream<<" a_vector=\"";
00430     for( size_t i = 0; i < cagt_vec[1].stlVector().size(); i++ ) {
00431       stream<<' '<<cagt_vec[1].stlVector()[i];
00432     }
00433     stream<<"\"";
00434   }
00435   if ( cagt_vec[2].stlVector().size() > 0 ) {
00436     stream<<" g_vector=\"";
00437     for( size_t i = 0; i < cagt_vec[2].stlVector().size(); i++ ) {
00438       stream<<' '<<cagt_vec[2].stlVector()[i];
00439     }
00440     stream<<"\"";
00441   }
00442   if ( cagt_vec[3].stlVector().size() > 0 ) {
00443     stream<<" t_vector=\"";
00444     for( size_t i = 0; i < cagt_vec[3].stlVector().size(); i++ ) {
00445       stream<<' '<<cagt_vec[3].stlVector()[i];
00446     }
00447     stream<<"\"";
00448   }
00449   if ( phd_vec.stlVector().size() > 0 ) {
00450     stream<<" phd=\"";
00451     for( size_t i = 0; i < phd_vec.stlVector().size(); i++ ) {
00452       stream<<' '<<phd_vec.stlVector()[i];
00453     }
00454     stream<<"\"";
00455   }
00456   if ( gap_vec.stlVector().size() > 0 ) {
00457     stream<<" gap=\"";
00458     for( size_t i = 0; i < gap_vec.stlVector().size(); i++ ) {
00459       stream<<' '<<gap_vec.stlVector()[i];
00460     }
00461     stream<<"\"";
00462   }
00463   
00464   stream<<"/>\n";
00465 }
00466 
00467 QualityData::QualityData( db_recno_t readRecno, TR_DNA startPos, TR_DNA endPos):
00468   SpatialFeatureData( readRecno, startPos, endPos )
00469 {}
00470 
00471 
00472 TagData::TagData( db_recno_t readRecno, TR_DNA startPos, TR_DNA endPos )
00473   : SpatialFeatureData( readRecno, startPos, endPos )
00474 {}
00475 
00476 void TagData::readStream( QDataStream & stream )
00477 {
00478   SpatialFeatureData::readStream( stream );
00479   stream>> score;
00480   QString tmp;
00481   stream>>tmp;
00482   info = tmp.ascii();
00483 }
00484 
00485 void TagData::writeStream( QDataStream & str )
00486 {
00487   SpatialFeatureData::writeStream( str );
00488   str<<score;
00489   QString tmp;
00490   tmp = info;
00491   str<<tmp;
00492 
00493 }
00494 
00495 void TagData::writeDom( QDomElement & elem )
00496 {
00497     SpatialFeatureData::writeDom( elem );
00498 }
00499 
00500 void TagData::readDom( QDomElement & elem )
00501 {
00502     SpatialFeatureData::readDom( elem );
00503 }
00504 
00505 void TagData::readAttributes( const QXmlAttributes& attr )
00506 {
00507   SpatialFeatureData::readAttributes( attr );
00508   if ( attr.value("info") != "" ) {
00509     info = attr.value("info").ascii();
00510   }
00511   if ( attr.value("score") != "" ) {
00512     score = attr.value("score").toDouble();
00513   }
00514 
00515 }
00516 
00517 void TagData::writeXml( ostream& stream )
00518 {
00519   SpatialFeatureData::writeXml(stream);
00520   stream<<" info=\""<< info <<"\"";
00521   stream<<" score=\""<< score <<"\"";
00522   stream<<"/>\n";
00523 }
00524 
00525 void TagData::setInfo(const std::string& inf)
00526 {
00527   info = inf;
00528 }
00529 
00530 std::string TagData::getInfo()
00531 {
00532   return info;
00533 }
00534 
00535 void TagData::setScore(const double& s)
00536 {
00537   score = s;
00538 }
00539 
00540 double TagData::getScore()
00541 {
00542   return score;
00543 }
00544 
00545 TrDb::IndexMap TagData::getIndexMap()
00546 {
00547   TrDb::IndexMap iMap = FeatureData::getIndexMap();
00548   TrDb::Index i1 = {
00549     &TagData::bt_compare_info,
00550     &TagData::getInfoAssoc,
00551     QString("info"),
00552     NULL
00553   };
00554   iMap.insert( make_pair( i1.name.ascii(), i1 ) );
00555   
00556   TrDb::Index i2 = {
00557     &TagData::bt_compare_score,
00558     &TagData::getScoreAssoc,
00559     QString("score"),
00560     NULL
00561   };
00562   iMap.insert( make_pair( i2.name.ascii(), i2 ) );
00563 
00564   return iMap;
00565 }
00566 
00567 int TagData::getInfoAssoc(Db *dbp, const Dbt *pkey, const Dbt *pdata, Dbt *skey)
00568 {
00569   memset(skey, 0, sizeof(Dbt));
00570   
00571   
00572   TagData tmp;
00573   Database::setFromDbt(pdata, &tmp);
00574   char* info = (char*)malloc(sizeof(char)*(tmp.getInfo().length() + 1));
00575   strcpy(info, tmp.getInfo().c_str());
00576   assert( info[ tmp.getInfo().length() ] == '\0' );
00577   skey->set_flags( DB_DBT_APPMALLOC );
00578   skey->set_data( (void*)info ); 
00579   skey->set_size(sizeof(char)*(strlen(info) + 1) );
00580   
00581 
00582   return 0;
00583 
00584 
00585 }
00586 
00587 int TagData::getScoreAssoc(Db *dbp, const Dbt *pkey, const Dbt *pdata, Dbt *skey)
00588 {
00589   memset(skey, 0, sizeof(Dbt));
00590   
00591   TagData tmp;
00592   Database::setFromDbt(pdata, &tmp);
00593   double * data = (double*)malloc(sizeof(double));
00594   *data = tmp.getScore();
00595   skey->set_flags( DB_DBT_APPMALLOC );
00596   skey->set_data( (void*)data );
00597   skey->set_size(sizeof( double ));
00598 
00599   return 0;
00600 
00601 }
00602 
00603 int TagData::bt_compare_info( DB * db, const DBT *dbt1, const DBT *dbt2)
00604 {
00605   char* infoData1 = ( char* ) dbt1->data;
00606   char* infoData2 = ( char* ) dbt2->data;
00607 
00608   
00609   return strcmp(infoData1, infoData2);
00610 
00611 }
00612 
00613 int TagData::bt_compare_score( DB * db, const DBT *dbt1, const DBT *dbt2)
00614 {
00615     double* score1  = ( double*) dbt1->data;
00616     double* score2  = ( double*) dbt2->data;
00617     if ( *score1 > *score2 )
00618         return 1;
00619     if ( *score1 < *score2 )
00620         return -1;
00621     if ( *score1 == *score2 )
00622         return 0;
00623     /* should never reach this point */
00624     return 0;
00625 }
00626 
00627 
00628 void ReadMetaData::print_debug_info()
00629 {
00630   FeatureData::print_debug_info();
00631   cerr<<"readRecno: "<<readRecno_<<endl;
00632   cerr<<"name: "<<name_<<endl;
00633 }
00634 
00635 void ReadMetaData::readStream( QDataStream & stream )
00636 {
00637   QIODevice * dev = stream.device();
00638   Q_ASSERT( dev );
00639 //   stream.readRawBytes( ( char * ) &s, sizeof ( StorageData ) );  
00640 
00641   stream>>readRecno_;
00642   QString tmp;
00643   stream>>tmp;
00644   name_ = tmp.ascii();
00645   stream>>tmp;
00646   mate_ = tmp.ascii();
00647   stream>>matelen_;
00648   stream>>tmp;
00649   strand_ = tmp.ascii();
00650   stream>>beginGood_;
00651   stream>>endGood_;
00652   tc_vec.stlVector().clear();
00653   stream>>tc_vec;
00654 }
00655 
00656 void ReadMetaData::writeStream( QDataStream & stream )
00657 {
00658   QIODevice * dev = stream.device();
00659   Q_ASSERT( dev );
00660   if ( ! ( IO_WriteOnly & dev->mode() ) )
00661     {
00662       cerr << "data stream should be writeonly" << endl;
00663       exit(1);
00664     }
00665 //   stream.writeRawBytes( ( char * ) &s, sizeof ( StorageData ) );
00666   stream<<readRecno_;
00667 
00668   QString tmp;
00669   tmp = name_;
00670   stream<<tmp;
00671   tmp = mate_;
00672   stream<<tmp;
00673   stream<<matelen_;
00674   tmp = strand_;
00675   stream<<tmp;
00676   stream<<beginGood_;
00677   stream<<endGood_;
00678   stream<<tc_vec;
00679 }
00680 
00681 void ReadMetaData::readAttributes( const QXmlAttributes& attr )
00682 {
00683   if ( attr.value("name") != "" ) {
00684     name_ = attr.value("name").ascii();
00685   }
00686   if ( attr.value("mate") != "" ) {
00687     mate_ = attr.value("mate").ascii();
00688   }
00689   if ( attr.value("matelen") != "" ) {
00690     matelen_ = attr.value("matelen").toInt();
00691   }
00692   if ( attr.value("strand") != "" ) {
00693     strand_ = attr.value("strand").ascii();
00694   }
00695   if ( attr.value("beginGood") != "" ) {
00696     beginGood_ = attr.value("beginGood").toInt();
00697   }
00698   if ( attr.value("endGood") != "" ) {
00699     endGood_ = attr.value("endGood").toInt();
00700   }
00701   if ( attr.value("tc") != "" ) {
00702     QString str = attr.value("tc");
00703     tc_vec.readString(str);
00704   }
00705 
00706 }
00707 
00708 void ReadMetaData::writeXml( ostream& stream )
00709 {
00710   stream<<"<ReadMetaData "
00711         <<"name=\""<<name_<<"\" "
00712         <<"mate=\""<<mate_<<"\" "
00713         <<"matelen=\""<<matelen_<<"\" "
00714         <<"strand=\""<<strand_<<"\" "
00715         <<"beginGood=\""<<beginGood_<<"\" "
00716         <<"endGood=\""<<endGood_<<"\"";
00717   if ( tc_vec.stlVector().size() > 0 ) {
00718     stream<<" tc=\"";
00719     for( size_t i = 0; i < tc_vec.stlVector().size(); i++ ) {
00720       stream<<' '<<tc_vec.stlVector()[i];
00721     }
00722     stream<<"\"";
00723   }
00724   stream<<">\n";
00725 }
00726 
00727 TrDb::IndexMap ReadMetaData::getIndexMap()
00728 {
00729 
00730   TrDb::IndexMap iMap = FeatureData::getIndexMap();
00731   TrDb::Index i1 = {
00732     &ReadMetaData::bt_compare_name,
00733     &ReadMetaData::getName,
00734     QString("name"),
00735     NULL
00736   };
00737   iMap.insert( make_pair( i1.name.ascii(), i1 ) );
00738   
00739   return iMap;
00740 }
00741 
00742 int ReadMetaData::bt_compare_name( DB * /* not used */, const DBT *dbt1, const DBT *dbt2)
00743 {
00744   /* order after end position */
00745   
00746   char* seqData1 = ( char* ) dbt1->data;
00747   char* seqData2 = ( char* ) dbt2->data;
00748 
00749 //   cerr<<seqData1<<'\t'<<seqData2<<'\t'<<strcmp(seqData1, seqData2)<<endl;
00750   
00751   return strcmp(seqData1, seqData2);
00752 }
00753 
00754 int ReadMetaData::getName(Db * /* not used */, const Dbt * /* not used */,
00755                         const Dbt *pdata, Dbt *skey)
00756 {
00757   
00758   memset(skey, 0, sizeof(Dbt));
00759 
00760   
00761   ReadMetaData tmp;
00762   Database::setFromDbt(pdata, &tmp);
00763   char* name = (char*)malloc(sizeof(char)*(tmp.name().length() + 1));
00764   strcpy(name, tmp.name().c_str());
00765   assert( name[ tmp.name().length() ] == '\0' );
00766   skey->set_flags( DB_DBT_APPMALLOC );
00767   skey->set_data( (void*)name ); 
00768   skey->set_size(sizeof(char)*(strlen(name) + 1) );
00769   
00770 
00771   return 0;
00772 }