gnSourceFactory.cpp Source File

Main Page Namespace List Class Hierarchy Alphabetical List Compound List File List Compound Members File Members

# gnSourceFactory.cpp

Go to the documentation of this file.

    00001
    00002 // File:            gnSourceFactory.cpp
    00003 // Purpose:         Source Factory for all Sources
    00004 // Description:
    00005 // Changes:
    00006 // Version:         libGenome 0.1.0
    00007 // Author:          Aaron Darling
    00008 // Last Edited:     April 15, 2001, 11:13:00pm
    00009 // Modified by:
    00010 // Copyright:       (c) Aaron Darling
    00011 // Licenses:        Proprietary
    00013 #ifdef GN_GUI
    00014 // For compilers that support precompilation, includes "wx/wx.h".
    00015 #include "wx/wxprec.h"
    00016
    00017 #ifdef __BORLANDC__
    00018     #pragma hdrstop
    00019 #endif
    00020
    00021 // for all others, include the necessary headers (this file is usually all you
    00022 // need because it includes almost all "standard" wxWindows headers)
    00023 #ifndef WX_PRECOMP
    00024     #include "wx/wx.h"
    00025 #endif
    00026 #include "wx/url.h"
    00027 #endif //GN_GUI
    00028
    00029 #include "gn/gnSourceFactory.h"
    00030 #include "gn/gnBaseSource.h"
    00031 #include "gn/gnStringTools.h"
    00032 #include "gn/gnFASSource.h"
    00033 #include "gn/gnDNXSource.h"
    00034 #include "gn/gnGBKSource.h"
    00035 #include "gn/gnSEQSource.h"
    00036 #include "gn/gnRAWSource.h"
    00037 #include "gn/gnException.h"
    00038 #include <unistd.h>
    00039
    00040 gnSourceFactory::gnSourceFactory()
    00041 {
    00042         m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".fas", new gnFASSource()));
    00043         m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".FAS", new gnFASSource()));
    00044         m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".dnx", new gnDNXSource()));
    00045         m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".DNX", new gnDNXSource()));
    00046         m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".seq", new gnSEQSource()));
    00047         m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".SEQ", new gnSEQSource()));
    00048         m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".gbk", new gnGBKSource()));
    00049         m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".GBK", new gnGBKSource()));
    00050         m_pDefaultSourceClass = new gnRAWSource();
    00051 }
    00052
    00053 gnSourceFactory::~gnSourceFactory()
    00054 {
    00055         vector< gnBaseSource* >::iterator iter = m_sourceList.begin();
    00056         for(; iter != m_sourceList.end(); ++iter )
    00057         {
    00058                 delete *iter;
    00059         }
    00060
    00061         map< string, gnBaseSource* >::iterator cIter = m_sourceClassList.begin();
    00062         for(; cIter != m_sourceClassList.end(); ++cIter )
    00063         {
    00064                 delete cIter->second;
    00065         }
    00066 }
    00067
    00068 boolean gnSourceFactory::DelSourceClass( const string& ext ){
    00069         map< string, gnBaseSource* >::iterator iter = m_sourceClassList.find( ext );
    00070         if( iter != m_sourceClassList.end() ){
    00071                 m_sourceClassList.erase( iter );
    00072                 return true;
    00073         }
    00074         return false;
    00075 }
    00076 gnBaseSource* gnSourceFactory::GetSourceClass( const string& ext ) const{
    00077         map< string, gnBaseSource* >::const_iterator iter = m_sourceClassList.find( ext );
    00078         if( iter != m_sourceClassList.end() ){
    00079                 return iter->second;
    00080         }
    00081         return m_pDefaultSourceClass;
    00082 }
    00083 gnBaseSource* gnSourceFactory::MatchSourceClass( const string& sourceStr ) const{
    00084         string::size_type dot_loc = sourceStr.rfind('.');
    00085         if(dot_loc != string::npos){
    00086                 string ext = sourceStr.substr(dot_loc, sourceStr.length() - dot_loc);
    00087                 return GetSourceClass(ext);
    00088         }
    00089         return m_pDefaultSourceClass;
    00090 }
    00091 boolean gnSourceFactory::HasSourceClass( const string& ext ) const{
    00092         if( m_sourceClassList.find(ext) != m_sourceClassList.end() ){
    00093                 return true;
    00094         }
    00095         return false;
    00096 }
    00097 boolean gnSourceFactory::SetSourceClass( const string& ext, const gnBaseSource& source ){
    00098         map< string, gnBaseSource* >::iterator iter = m_sourceClassList.find( ext );
    00099         if( iter == m_sourceClassList.end() ){
    00100                 m_sourceClassList.insert(
    00101                         map< string, gnBaseSource* >::value_type( ext, source.Clone() ) );
    00102         }else{
    00103                 iter->second = source.Clone();
    00104         }
    00105         return true;
    00106 }
    00107 boolean gnSourceFactory::AddPath( const string& path ){
    00108         if( PathExists( path ) && !HasPath(path) )
    00109         {
    00110                 m_pathList.push_back( path );
    00111                 return true;
    00112         }
    00113         return false;
    00114 }
    00115 boolean gnSourceFactory::DelPath( uint32 i ){
    00116         if( i < m_pathList.size() ){
    00117                 vector<string>::iterator iter = m_pathList.begin() + i;
    00118                 m_pathList.erase( iter );
    00119                 return true;
    00120         }
    00121         return false;
    00122 }
    00123 boolean gnSourceFactory::InsPath( const string& path, uint32 i ){
    00124         if( (i < m_pathList.size()) && PathExists( path ) )
    00125         {
    00126                 vector<string>::iterator iter = m_pathList.begin() + i;
    00127                 m_pathList.insert( iter, path );
    00128                 return true;
    00129         }
    00130         return false;
    00131 }
    00132 string gnSourceFactory::GetPath( uint32 i ) const{
    00133         if( i < m_pathList.size() ){
    00134                 return m_pathList[i];
    00135         }
    00136         return "";
    00137 }
    00138 boolean gnSourceFactory::HasPath( string path ) const{
    00139         standarizePathString( path );
    00140         for( uint32 i = 0; i < m_pathList.size(); ++i ){
    00141                 if( m_pathList[i] == path )
    00142                         return true;
    00143         }
    00144         return false;
    00145 }
    00146
    00147 /*boolean gnSourceFactory::FtpGet( string& urlStr, string& localFile ){
    00148         if(sourceStr.substr(0, 6) == "ftp://")
    00149                 openStr = urlStr.substr(6);
    00150         else
    00151                 return false;
    00152         ofstream outfile(localFile.c_str(), ios::binary);
    00153         if(!outfile.is_open())
    00154                 return false;
    00155
    00156         string username = "ftp";
    00157         string password = "ftp@ftp.com";
    00158         string::position at_pos = openStr.rfind("@");
    00159         if(at_pos = string::npos){
    00160                 username = openStr.substr(0, at_pos);
    00161                 openStr = openStr.substr(at_pos + 1, openStr.length());
    00162                 string::position colon_pos = username.find(":");
    00163                 if(colon_pos = string::npos){
    00164                         password = username.substr(colon_pos + 1, username.length());
    00165                         username = username.substr(0, colon_pos);
    00166                 }else
    00167                         password = "";
    00168         }
    00169         string::position slash_pos = openStr.find("/");
    00170         string hostname = openStr.substr(0, slash_pos);
    00171         string::position slash2_pos = openStr.rfind("/");
    00172         string pathname = openStr.substr(slash_pos, slash2_pos - slash_pos);
    00173         string fname = openStr.substr(slash2_pos);
    00174         wxFTP m_ftp;
    00175         wxInputStream *in_stream;
    00176         m_ftp.Connect(hostname.c_str());
    00177         if(pathname.length() > 0)
    00178                 m_ftp.ChDir(pathname.c_str());
    00179         in_stream = ftp.GetInputStream(fname.c_str());
    00180
    00181         char *buf = new char[BUFFER_SIZE];
    00182         uint32 streamSize = in_stream->StreamSize();
    00183         uint32 streamPos = 0;
    00184         while(streamPos < streamSize){
    00185                 uint32 readSize = streamSize - streamPos > BUFFER_SIZE ? streamSize - streamPos : BUFFER_SIZE;
    00186                 in_stream->Read(buf, readSize);
    00187                 if (in_stream->LastError() != wxStream_NOERROR) {    // Do something.
    00188                         delete buf;
    00189                         delete in_stream;
    00190                         m_ftp.Close();
    00191                         return false;
    00192                 }
    00193                 outfile.write(buf, readSize);
    00194         }
    00195         delete buf;
    00196         delete in_stream;
    00197         m_ftp.Close();
    00198         return true;
    00199 }
    00200 */
    00201 boolean gnSourceFactory::GetURL( const string& urlStr, string& localFile ){
    00202 #ifdef GN_GUI
    00203         wxURL m_url(urlStr.c_str());
    00204         if(m_url.GetError() != wxURL_NOERR )
    00205                 return false;
    00206         ofstream outfile(localFile.c_str(), ios::binary);
    00207         if(!outfile.is_open())
    00208                 return false;
    00209
    00210         wxInputStream *in_stream = m_url.GetInputStream();
    00211         char *buf = new char[BUFFER_SIZE];
    00212         uint32 streamSize = in_stream->StreamSize();
    00213
    00214         uint32 streamPos = 0;
    00215         while(streamPos < streamSize){
    00216                 uint32 readSize = streamSize - streamPos > BUFFER_SIZE ? streamSize - streamPos : BUFFER_SIZE;
    00217                 in_stream->Read(buf, readSize);
    00218                 if (in_stream->LastError() != wxStream_NOERROR) {    // Do something.
    00219                         delete buf;
    00220                         delete in_stream;
    00221                         return false;
    00222                 }
    00223                 outfile.write(buf, readSize);
    00224         }
    00225         delete buf;
    00226         delete in_stream;
    00227         return true;
    00228 #else
    00229         return false;
    00230 #endif //GN_GUI
    00231 }
    00232   // Sources
    00233 gnBaseSource* gnSourceFactory::AddSource( const string& sourceStr, boolean searchPaths )
    00234 {
    00235         string openStr = sourceStr;
    00236         // Check if Exists
    00237         gnBaseSource* source = HasSource( sourceStr, false );
    00238         if( source != 0 )
    00239                 return source;
    00240         // Check if File Present and valid
    00241         gnBaseSource* newSource = MatchSourceClass( sourceStr )->Clone();
    00242         if(newSource == NULL)
    00243                 return NULL;
    00244
    00245         // Check the URL to see if we need to cache the file locally
    00246         if(sourceStr.substr(0, 7) == "http://"){
    00247 #ifdef GN_GUI
    00248                 wxString tmpfile = wxGetTempFileName("gnhttp");
    00249                 openStr = tmpfile.c_str();
    00250                 GetURL(sourceStr, openStr);
    00251 #else
    00252                 ErrorMsg("Sorry, no HTTP support without wxWindows.\n");
    00253                 return NULL;
    00254 #endif
    00255         }else if(sourceStr.substr(0, 6) == "ftp://"){
    00256 #ifdef GN_GUI
    00257                 wxString tmpfile = wxGetTempFileName("gnftp");
    00258                 openStr = tmpfile.c_str();
    00259                 GetURL(sourceStr, openStr);
    00260 #else
    00261                 ErrorMsg("Sorry, no FTP support without wxWindows.\n");
    00262                 return NULL;
    00263 #endif
    00264         }else if(sourceStr.substr(0, 8) == "file:///")
    00265                 openStr = sourceStr.substr(8);
    00266
    00267         // Now try to open the local file
    00268         try{
    00269                 newSource->Open( openStr );
    00270                 m_sourceList.push_back( newSource );
    00271                 return newSource;
    00272         }catch(gnException& e){
    00273                 if(e.GetCode() != FileNotOpened()){
    00274                         delete newSource;
    00275                         e.AddCaller(__PRETTY_FUNCTION__);
    00276                         throw e;
    00277                 }
    00278         }
    00279
    00280         if( searchPaths )
    00281         {
    00282                 // Check other paths for Exists or Presents/valid
    00283                 string file = getFileString( openStr );
    00284                 vector< string >::iterator iter = m_pathList.begin();
    00285                 for( ; iter != m_pathList.end(); ++iter )
    00286                 {
    00287                         string newSourceStr = *iter + file;
    00288                         // Check if Exists
    00289                         source = HasSource( newSourceStr, false );
    00290                         if( source != 0 )
    00291                         {
    00292                                 delete newSource;
    00293                                 return source;
    00294                         }
    00295                         // Check if File Present and valid
    00296                         try{
    00297                                 newSource->Open( newSourceStr );
    00298                                 m_sourceList.push_back( newSource );
    00299                                 return newSource;
    00300                         }catch(gnException& e){
    00301                                 if(e.GetCode() != FileNotOpened()){
    00302                                         delete newSource;
    00303                                         e.AddCaller(__PRETTY_FUNCTION__);
    00304                                         throw e;
    00305                                 }
    00306                         }
    00307                 }
    00308         }
    00309         // Cannot find a valid source
    00310         delete newSource;
    00311         Throw_gnEx(FileNotOpened());
    00312 }
    00313 gnBaseSource* gnSourceFactory::GetSource( uint32 i ) const{
    00314         if( i < m_sourceList.size() ){
    00315                 return *(m_sourceList.begin() + i);
    00316         }
    00317         return 0;
    00318 }
    00319 void gnSourceFactory::DelSource( uint32 i ){
    00320         if( i >= m_sourceList.size() )
    00321                 Throw_gnEx(IndexOutOfBounds());
    00322         vector< gnBaseSource* >::iterator iter = m_sourceList.begin() + i;
    00323         gnBaseSource* source = *iter;
    00324         try{
    00325                 source->Close();
    00326                 m_sourceList.erase(iter);
    00327                 delete source;
    00328         }catch(gnException& e){
    00329                 e.AddCaller(__PRETTY_FUNCTION__);
    00330                 throw e;
    00331         }
    00332 }
    00333
    00334 boolean gnSourceFactory::DelSource( const gnBaseSource* source ){
    00335         vector< gnBaseSource* >::iterator iter = m_sourceList.begin();
    00336         for( ; iter != m_sourceList.end(); ++iter ){
    00337                 if( *iter == source ){
    00338                         gnBaseSource* source = *iter;
    00339                         try{
    00340                                 source->Close();
    00341                                 m_sourceList.erase(iter);
    00342                                 delete source;
    00343                                 return true;
    00344                         }catch(gnException& e){
    00345                                 e.AddCaller(__PRETTY_FUNCTION__);
    00346                                 throw e;
    00347                         }
    00348                 }
    00349         }
    00350         return false;
    00351 }
    00352 gnBaseSource* gnSourceFactory::HasSource( string sourceStr, boolean searchPaths ) const{
    00353         standarizePathString( sourceStr );
    00354         vector< gnBaseSource* >::const_iterator iter1 = m_sourceList.begin();
    00355         for( ; iter1 != m_sourceList.end(); ++iter1 )
    00356         {
    00357                 if( (*iter1)->GetOpenString() == sourceStr )
    00358                         return *iter1;
    00359         }
    00360
    00361         if( searchPaths )
    00362         {
    00363                 string file = getFileString( sourceStr );
    00364                 vector< string >::const_iterator iter2 = m_pathList.begin();
    00365                 for( ; iter2 != m_pathList.end(); ++iter2 )
    00366                 {
    00367                         iter1 = m_sourceList.begin();
    00368                         for( ; iter1 != m_sourceList.end(); ++iter1 )
    00369                         {
    00370                                 if( (*iter1)->GetOpenString() == (*iter2 + file) )
    00371                                         return *iter1;
    00372                         }
    00373                 }
    00374         }
    00375         return 0;
    00376 }
    00377
    00378 // private:
    00379 boolean gnSourceFactory::PathExists( string path ) const{
    00380         standarizePathString( path );
    00381         char folder[FILENAME_MAX];
    00382         getcwd( folder, FILENAME_MAX );
    00383
    00384         if( chdir( path.c_str() ) ){
    00385                 return false;
    00386         }
    00387         chdir( folder );
    00388         return true;
    00389 }
    00390