---

gnRAWSource.cpp

Go to the documentation of this file.

// File:            gnRAWSource.h
// Purpose:         Implements gnBaseSource for raw data files
// Description:     
// Changes:        
// Version:         libGenome 0.1.0 
// Author:          Aaron Darling 
// Last Edited:     April 15, 2001, 11:13:00pm 
// Modified by:     
// Copyright:       (c) Aaron Darling 
// Licenses:        Proprietary 
#include "gn/gnFilter.h"
#include "gn/gnRAWSource.h"
#include "gn/gnGenomeSpec.h"
#include "gn/gnFragmentSpec.h"
#include "gn/gnSourceSpec.h"
#include "gn/gnStringTools.h"
#include "gn/gnDebug.h"

gnRAWSource::gnRAWSource()
{
        m_openString = "";
        m_contig = NULL;
}

gnRAWSource::gnRAWSource( const gnRAWSource& s ) : gnFileSource(s)
{
        if(m_contig != NULL)
                m_contig = s.m_contig->Clone();
}

gnRAWSource::~gnRAWSource()
{
        m_ifstream.close();
        delete m_contig;
}

boolean gnRAWSource::HasContig( const string& name ) const
{
        if( name.length() == 0 )
                return true;
        return false;
}

uint32 gnRAWSource::GetContigID( const string& name ) const
{
        return ALL_CONTIGS;
}

string gnRAWSource::GetContigName( const uint32 i ) const
{
        return "";
}

gnSeqI gnRAWSource::GetContigSeqLength( const uint32 i ) const
{
        if( m_contig && (i == 0 || i == ALL_CONTIGS))
                return m_contig->GetSeqLength();
        return GNSEQI_ERROR;
}

boolean gnRAWSource::SeqRead( const gnSeqI start, char* buf, uint32& bufLen, const uint32 contigI ){
        return Read( start, buf, bufLen );
}

gnGenomeSpec *gnRAWSource::GetSpec() const{
        return m_spec->Clone();
}

boolean gnRAWSource::Write(gnSequence& seq, const string& filename){
        ofstream m_ofstream(filename.c_str(), ios::out | ios::binary);
        if(!m_ofstream.is_open())
                return false;

        gnSeqC buf[BUFFER_SIZE + 1];
        buf[BUFFER_SIZE] = 0;
        gnSeqI readOffset = 0;
        gnSeqI readLength = seq.length();

        while(readLength > 0){  //buffer the read/writes
                gnSeqI writeLen = readLength < BUFFER_SIZE ? readLength : BUFFER_SIZE;
                
                if(!seq.ToArray(buf, writeLen, readOffset))
                        return false;
                m_ofstream << buf;
                readLength -= writeLen;
                readOffset += writeLen;
        }
        return true;
}

gnFileContig* gnRAWSource::GetFileContig( const uint32 contigI ) const{
        if(contigI > 0)
                return NULL;
        return m_contig;
}

//File parsing access routine
boolean gnRAWSource::ParseStream( istream& fin )
{
        // init variables
        uint64 streamPos = 0;
        uint64 bufReadLen = 0;
        char* buf = new char[BUFFER_SIZE];
        gnSeqI seqLength = 0;
        
        m_contig->SetRepeatSeqGap(true);
        m_contig->SetSectStart(gnContigSequence, 0);

        while( !fin.eof() )
        {
                  // read chars
                fin.read( buf , BUFFER_SIZE );
                bufReadLen = fin.gcount();
                
                for( uint32 i=0 ; i < bufReadLen ; i++ )
                {
                        if(m_pFilter->IsValid(buf[i]))
                                seqLength++;
                        else
                                m_contig->SetRepeatSeqGap(false);
                        break;
                }
                streamPos += bufReadLen;
        }
        m_contig->SetSectEnd(gnContigSequence, streamPos);
        m_contig->SetSeqLength(seqLength);
        m_spec = new gnGenomeSpec();
        gnFragmentSpec* fragspec = new gnFragmentSpec();
        gnSourceSpec* sspec = new gnSourceSpec(this);
        sspec->SetSourceName(m_openString);
        m_spec->AddSpec(fragspec);
        fragspec->AddSpec(sspec);

        m_ifstream.clear();
        delete[] buf;
        return true;
}

---