---

gnMultiSpec.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
// File:            gnMultiSpec.cpp
// Purpose:         abstract Spec class
// Description:     Defines a basic interface for all specs
// Changes:        
// Version:         libGenome 0.5.1 
// Author:          Aaron Darling 
// Modified by:     
// Copyright:       (c) Aaron Darling 
// Licenses:        See COPYING file for details
/////////////////////////////////////////////////////////////////////////////

#include "gn/gnDefs.h"

#include <string>
#include <vector>
#include "gn/gnMultiSpec.h"
#include "gn/gnBaseSource.h"
#include "gn/gnBaseFeature.h"
#include "gn/gnDebug.h"
#include "gn/gnException.h"

void gnMultiSpec::Clear()
{
        gnBaseSpec::Clear();
        uint32 list_size = m_headerList.size();
        for(uint32 i=0; i < list_size; i++)
                delete m_headerList[i];
        m_headerList.clear();
}

gnSeqI gnMultiSpec::GetLength() const
{
        gnSeqI subLen = 0;      //aggregate the lower levels.
        for(uint32 i=0; i < GetSpecListLength(); i++)
                subLen += GetSpec(i)->GetLength();
        return subLen;
}

//Return the index of the subspec which contains the base in question
uint32 gnMultiSpec::GetSpecIndexByBase( const gnSeqI baseI ) const{
        gnSeqI cur_length = 0;
        for(uint32 i=0; i < GetSpecListLength(); i++){
                cur_length += GetSpec(i)->GetLength();
                if(baseI < cur_length)
                        return i;
        }
        //if we made it here then the base was out of bounds
        Throw_gnEx(SeqIndexOutOfBounds());
}

uint32 gnMultiSpec::GetSpecIndexByName( const string& name ) const{
        for(uint32 i=0; i < GetSpecListLength(); i++){
                if(name == GetSpec(i)->GetName())
                        return i;
        }
        Throw_gnEx(SpecIndexOutOfBounds());
}

//returns the starting base pair index of the given subspec.
gnSeqI gnMultiSpec::GetSpecStartBase( const uint32 specI ) const{
        uint32 i;
        if(specI >= GetSpecListLength())
                Throw_gnEx(SpecIndexOutOfBounds());
        
        gnSeqI start_base = 0;
        for(i=0; i < specI; i++){
                start_base += GetSpec(i)->GetLength();
        }
        return start_base;
}

gnSeqI gnMultiSpec::GetSpecEndBase( const uint32 specI ) const{
        uint32 i;
        if(specI >= GetSpecListLength())
                Throw_gnEx(SpecIndexOutOfBounds());
        
        gnSeqI end_base = 0;
        for(i=0; i <= specI; i++){
                end_base += GetSpec(i)->GetLength();
        }
        return end_base;
}

void gnMultiSpec::CropStart( gnSeqI cropLen ){
        gnSeqI curbase = 0;
        for(uint32 specI = 0; specI < GetSpecListLength(); specI++){
                curbase += GetSpec(specI)->GetLength();
                if(curbase <= cropLen){
                        //delete the spec completely
                        gnBaseSpec *tmp_spec = GetSpec(specI);
                        RemoveSpec(specI);
                        delete tmp_spec;
                        specI--;
                }else{
                        //recurse and break
                        gnSeqI sub_len = cropLen - (curbase - GetSpec(specI)->GetLength());
                        GetSpec(specI)->CropStart(sub_len);
                        break;
                }
        }
}

void gnMultiSpec::CropEnd( gnSeqI cropLen ){
        gnSeqI curbase = 0;
        gnSeqI cropbase = GetLength() - cropLen;  //last base to keep
        boolean trash_the_rest = false;
        for(uint32 specI = 0; specI < GetSpecListLength(); specI++){
                curbase += GetSpec(specI)->GetLength();         
                if(trash_the_rest){
                        //delete the spec entirely
                        gnBaseSpec *tmp_spec = GetSpec(specI);
                        RemoveSpec(specI);
                        delete tmp_spec;
                        specI--;
                        continue;
                }else if(curbase > cropbase){
                        GetSpec(specI)->CropEnd(curbase - cropbase);
                        trash_the_rest = true;
                }else if(curbase == cropbase)
                        trash_the_rest = true;
        }
}

void gnMultiSpec::AddHeader( gnBaseHeader* head, const uint32 i) 
{
        uint32 index = i == UINT32_MAX ? m_headerList.size() : i;
        m_headerList.insert(m_headerList.begin() + index, head);
}

gnBaseHeader* gnMultiSpec::GetHeader( const string& name, uint32& i) const{
        for(; i < m_headerList.size(); i++){
                if( m_headerList[i]->GetHeaderName() == name)
                        return m_headerList[i];
        }
        Throw_gnEx(HeaderIndexOutOfBounds());
}

void gnMultiSpec::RemoveHeader( uint32 i) 
{
        if(i <= m_headerList.size()){
                m_headerList.erase(m_headerList.begin() + i);
        }
        Throw_gnEx(HeaderIndexOutOfBounds());
}

boolean gnMultiSpec::SeqRead(const gnSeqI start, gnSeqC* buf, uint32& bufLen, const uint32 contigI ) const{
        if( bufLen == 0 )
                return true;
        if(contigI == ALL_CONTIGS){
                gnSeqI curpos = 0;
                uint32 readBytes = 0;
                uint32 remainingBytes = bufLen;
                uint32 curSpecI = 0;
                //seek to start spec.
                for(curSpecI=0; curSpecI < GetSpecListLength(); curSpecI++){
                        curpos += GetSpec(curSpecI)->GetLength();
                        if(curpos > start)
                                break;
                }
                if(curpos <= start)
                        Throw_gnEx(SeqIndexOutOfBounds());
                //read until we're done;
                while((remainingBytes > 0) && (curSpecI < GetSpecListLength())) {
                        gnSeqI readable = GetSpec(curSpecI)->GetLength();
                        //check for circular
                        uint32 start_pos = readBytes == 0 ? start - (curpos - readable) : 0;
                        uint32 to_read = readable - start_pos >= remainingBytes ? remainingBytes : readable - start_pos;
                        boolean success = GetSpec(curSpecI)->SeqRead(start_pos, buf+readBytes, to_read, contigI);

                        readBytes += to_read;
                        remainingBytes -= to_read;
                        if(!success)
                                break;
                        curSpecI++;
                }
                bufLen = readBytes;
                return true;
        }else{  //read from the specified contig.
                if(contigI < GetSpecListLength())
                        return GetSpec(contigI)->SeqRead(start, buf, bufLen, ALL_CONTIGS);
                else
                        Throw_gnEx(SpecIndexOutOfBounds());
        }
        return false;
}

---