---

gnSourceFactory.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
// File:            gnSourceFactory.cpp
// Purpose:         Source Factory for all Sources
// Description:     
// Changes:        
// Version:         libGenome 0.5.1 
// Author:          Aaron Darling 
// Modified by:     
// Copyright:       (c) Aaron Darling 
// Licenses:        See COPYING file for details
/////////////////////////////////////////////////////////////////////////////
#ifdef GN_GUI
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWindows headers)
#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif
#include "wx/url.h"
#endif //GN_GUI

#include "gn/gnSourceFactory.h"
#include "gn/gnBaseSource.h"
#include "gn/gnStringTools.h"
#include "gn/gnFASSource.h"
#include "gn/gnDNXSource.h"
#include "gn/gnGBKSource.h"
#include "gn/gnSEQSource.h"
#include "gn/gnRAWSource.h"
#include "gn/gnException.h"
#include <unistd.h>

gnSourceFactory::gnSourceFactory()
{
        m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".fas", new gnFASSource()));
        m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".FAS", new gnFASSource()));
        m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".dnx", new gnDNXSource()));
        m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".DNX", new gnDNXSource()));
        m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".seq", new gnSEQSource()));
        m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".SEQ", new gnSEQSource()));
        m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".gbk", new gnGBKSource()));
        m_sourceClassList.insert( map< string, gnBaseSource* >::value_type(".GBK", new gnGBKSource()));
        m_pDefaultSourceClass = new gnRAWSource();
}

gnSourceFactory::~gnSourceFactory()
{
        vector< gnBaseSource* >::iterator iter = m_sourceList.begin();
        for(; iter != m_sourceList.end(); ++iter )
        {
                delete *iter;
        }

        map< string, gnBaseSource* >::iterator cIter = m_sourceClassList.begin();
        for(; cIter != m_sourceClassList.end(); ++cIter )
        {
                delete cIter->second;
        }
}

boolean gnSourceFactory::DelSourceClass( const string& ext ){
        map< string, gnBaseSource* >::iterator iter = m_sourceClassList.find( ext );
        if( iter != m_sourceClassList.end() ){
                m_sourceClassList.erase( iter );
                return true;
        }
        return false;
}
gnBaseSource* gnSourceFactory::GetSourceClass( const string& ext ) const{
        map< string, gnBaseSource* >::const_iterator iter = m_sourceClassList.find( ext );
        if( iter != m_sourceClassList.end() ){
                return iter->second;
        }
        return m_pDefaultSourceClass;
}
gnBaseSource* gnSourceFactory::MatchSourceClass( const string& sourceStr ) const{
        string::size_type dot_loc = sourceStr.rfind('.');
        if(dot_loc != string::npos){
                string ext = sourceStr.substr(dot_loc, sourceStr.length() - dot_loc);
                return GetSourceClass(ext);
        }
        return m_pDefaultSourceClass;
}
boolean gnSourceFactory::HasSourceClass( const string& ext ) const{
        if( m_sourceClassList.find(ext) != m_sourceClassList.end() ){
                return true;
        }
        return false;
}
boolean gnSourceFactory::SetSourceClass( const string& ext, const gnBaseSource& source ){
        map< string, gnBaseSource* >::iterator iter = m_sourceClassList.find( ext );
        if( iter == m_sourceClassList.end() ){
                m_sourceClassList.insert( 
                        map< string, gnBaseSource* >::value_type( ext, source.Clone() ) );
        }else{
                iter->second = source.Clone();
        }
        return true;
}
boolean gnSourceFactory::AddPath( const string& path ){
        if( PathExists( path ) && !HasPath(path) )
        {
                m_pathList.push_back( path );   
                return true;
        }
        return false;
}
boolean gnSourceFactory::DelPath( uint32 i ){
        if( i < m_pathList.size() ){
                vector<string>::iterator iter = m_pathList.begin() + i;
                m_pathList.erase( iter );
                return true;
        }
        return false;
}
boolean gnSourceFactory::InsPath( const string& path, uint32 i ){
        if( (i < m_pathList.size()) && PathExists( path ) )
        {
                vector<string>::iterator iter = m_pathList.begin() + i;
                m_pathList.insert( iter, path );
                return true;
        }
        return false;
}
string gnSourceFactory::GetPath( uint32 i ) const{
        if( i < m_pathList.size() ){
                return m_pathList[i];
        }
        return "";
}
boolean gnSourceFactory::HasPath( string path ) const{
        standarizePathString( path );
        for( uint32 i = 0; i < m_pathList.size(); ++i ){
                if( m_pathList[i] == path )
                        return true;
        }
        return false;
}

/*boolean gnSourceFactory::FtpGet( string& urlStr, string& localFile ){
        if(sourceStr.substr(0, 6) == "ftp://")
                openStr = urlStr.substr(6);
        else
                return false;
        ofstream outfile(localFile.c_str(), ios::binary);
        if(!outfile.is_open())
                return false;

        string username = "ftp";
        string password = "ftp@ftp.com";
        string::position at_pos = openStr.rfind("@");
        if(at_pos = string::npos){
                username = openStr.substr(0, at_pos);
                openStr = openStr.substr(at_pos + 1, openStr.length());
                string::position colon_pos = username.find(":");
                if(colon_pos = string::npos){
                        password = username.substr(colon_pos + 1, username.length());
                        username = username.substr(0, colon_pos);
                }else
                        password = "";
        }
        string::position slash_pos = openStr.find("/");
        string hostname = openStr.substr(0, slash_pos);
        string::position slash2_pos = openStr.rfind("/");
        string pathname = openStr.substr(slash_pos, slash2_pos - slash_pos);
        string fname = openStr.substr(slash2_pos);
        wxFTP m_ftp;
        wxInputStream *in_stream;
        m_ftp.Connect(hostname.c_str());
        if(pathname.length() > 0)
                m_ftp.ChDir(pathname.c_str());
        in_stream = ftp.GetInputStream(fname.c_str());

        char *buf = new char[BUFFER_SIZE];
        uint32 streamSize = in_stream->StreamSize();
        uint32 streamPos = 0;
        while(streamPos < streamSize){
                uint32 readSize = streamSize - streamPos > BUFFER_SIZE ? streamSize - streamPos : BUFFER_SIZE;
                in_stream->Read(buf, readSize);
                if (in_stream->LastError() != wxStream_NOERROR) {    // Do something.  
                        delete buf;
                        delete in_stream;
                        m_ftp.Close();
                        return false;
                }
                outfile.write(buf, readSize);
        }
        delete buf;
        delete in_stream;
        m_ftp.Close();
        return true;
}
*/
boolean gnSourceFactory::GetURL( const string& urlStr, string& localFile ){
#ifdef GN_GUI
        wxURL m_url(urlStr.c_str());
        if(m_url.GetError() != wxURL_NOERR )
                return false;
        ofstream outfile(localFile.c_str(), ios::binary);
        if(!outfile.is_open())
                return false;

        wxInputStream *in_stream = m_url.GetInputStream();
        char *buf = new char[BUFFER_SIZE];
        uint32 streamSize = in_stream->StreamSize();

        uint32 streamPos = 0;
        while(streamPos < streamSize){
                uint32 readSize = streamSize - streamPos > BUFFER_SIZE ? streamSize - streamPos : BUFFER_SIZE;
                in_stream->Read(buf, readSize);
                if (in_stream->LastError() != wxStream_NOERROR) {    // Do something.  
                        delete buf;
                        delete in_stream;
                        return false;
                }
                outfile.write(buf, readSize);
        }
        delete buf;
        delete in_stream;
        return true;
#else
        return false;
#endif //GN_GUI
}
  // Sources
gnBaseSource* gnSourceFactory::AddSource( const string& sourceStr, boolean searchPaths )
{
        string openStr = sourceStr;
        // Check if Exists
        gnBaseSource* source = HasSource( sourceStr, false );
        if( source != 0 )
                return source;
        // Check if File Present and valid
        gnBaseSource* newSource = MatchSourceClass( sourceStr )->Clone();
        if(newSource == NULL)
                return NULL;

        // Check the URL to see if we need to cache the file locally
        if(sourceStr.substr(0, 7) == "http://"){
#ifdef GN_GUI
                wxString tmpfile = wxGetTempFileName("gnhttp");
                openStr = tmpfile.c_str();
                GetURL(sourceStr, openStr);
#else
                ErrorMsg("Sorry, no HTTP support without wxWindows.\n");
                return NULL;
#endif
        }else if(sourceStr.substr(0, 6) == "ftp://"){
#ifdef GN_GUI
                wxString tmpfile = wxGetTempFileName("gnftp");
                openStr = tmpfile.c_str();
                GetURL(sourceStr, openStr);
#else
                ErrorMsg("Sorry, no FTP support without wxWindows.\n");
                return NULL;
#endif
        }else if(sourceStr.substr(0, 8) == "file:///")
                openStr = sourceStr.substr(8);

        // Now try to open the local file
        try{
                newSource->Open( openStr );
                m_sourceList.push_back( newSource );
                return newSource;
        }catch(gnException& e){
                if(e.GetCode() != FileNotOpened()){
                        delete newSource;
                        e.AddCaller(__PRETTY_FUNCTION__);
                        throw e;
                }
        }
        
        if( searchPaths )
        {
                // Check other paths for Exists or Presents/valid
                string file = getFileString( openStr );
                vector< string >::iterator iter = m_pathList.begin();
                for( ; iter != m_pathList.end(); ++iter )
                {
                        string newSourceStr = *iter + file;
                        // Check if Exists
                        source = HasSource( newSourceStr, false );
                        if( source != 0 )
                        {
                                delete newSource;
                                return source;
                        }
                        // Check if File Present and valid
                        try{
                                newSource->Open( newSourceStr );
                                m_sourceList.push_back( newSource );
                                return newSource;
                        }catch(gnException& e){
                                if(e.GetCode() != FileNotOpened()){
                                        delete newSource;
                                        e.AddCaller(__PRETTY_FUNCTION__);
                                        throw e;
                                }
                        }
                }
        }
        // Cannot find a valid source
        delete newSource;
        Throw_gnEx(FileNotOpened());
}
gnBaseSource* gnSourceFactory::GetSource( uint32 i ) const{
        if( i < m_sourceList.size() ){
                return *(m_sourceList.begin() + i);
        }
        return 0;
}
void gnSourceFactory::DelSource( uint32 i ){
        if( i >= m_sourceList.size() )
                Throw_gnEx(IndexOutOfBounds());
        vector< gnBaseSource* >::iterator iter = m_sourceList.begin() + i;
        gnBaseSource* source = *iter;
        try{
                source->Close();
                m_sourceList.erase(iter);
                delete source;
        }catch(gnException& e){
                e.AddCaller(__PRETTY_FUNCTION__);
                throw e;
        }
}

boolean gnSourceFactory::DelSource( const gnBaseSource* source ){
        vector< gnBaseSource* >::iterator iter = m_sourceList.begin();
        for( ; iter != m_sourceList.end(); ++iter ){
                if( *iter == source ){
                        gnBaseSource* source = *iter;
                        try{
                                source->Close();
                                m_sourceList.erase(iter);
                                delete source;
                                return true;
                        }catch(gnException& e){
                                e.AddCaller(__PRETTY_FUNCTION__);
                                throw e;
                        }
                }
        }
        return false;
}
gnBaseSource* gnSourceFactory::HasSource( string sourceStr, boolean searchPaths ) const{
        standarizePathString( sourceStr );
        vector< gnBaseSource* >::const_iterator iter1 = m_sourceList.begin();
        for( ; iter1 != m_sourceList.end(); ++iter1 )
        {
                if( (*iter1)->GetOpenString() == sourceStr )
                        return *iter1;
        }
        
        if( searchPaths )
        {
                string file = getFileString( sourceStr );
                vector< string >::const_iterator iter2 = m_pathList.begin();
                for( ; iter2 != m_pathList.end(); ++iter2 )
                {
                        iter1 = m_sourceList.begin();
                        for( ; iter1 != m_sourceList.end(); ++iter1 )
                        {
                                if( (*iter1)->GetOpenString() == (*iter2 + file) )
                                        return *iter1;
                        }
                }
        }
        return 0;
}
        
// private:
boolean gnSourceFactory::PathExists( string path ) const{
        standarizePathString( path );
        char folder[FILENAME_MAX];
        getcwd( folder, FILENAME_MAX );
        
        if( chdir( path.c_str() ) ){
                return false;
        }
        chdir( folder );
        return true;
}

---