gnFragmentSpec.cpp Source File

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

# gnFragmentSpec.cpp

Go to the documentation of this file.

    00001
    00002 // File:            gnFragmentSpec.cpp
    00003 // Purpose:         implements gnMultiSpec for sequence fragments
    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
    00014 #include "gn/gnFragmentSpec.h"
    00015 #include <string>
    00016
    00017 gnFragmentSpec::gnFragmentSpec()
    00018 {
    00019         Clear();
    00020 }
    00021
    00022 gnFragmentSpec::gnFragmentSpec( const gnFragmentSpec& s )
    00023 {
    00024         m_sourceName = s.m_sourceName;
    00025         m_name = s.m_name;
    00026         m_reverseComplement = s.m_reverseComplement;
    00027         m_circular = s.m_circular;
    00028         //copy the header list.
    00029         uint32 list_size =  s.m_headerList.size();
    00030         m_headerList.reserve(list_size);
    00031         for(uint32 i=0; i < list_size; i++)
    00032                 m_headerList.push_back(s.m_headerList[i]->Clone());
    00033         //copy the contig list.
    00034         list_size =  s.m_SpecList.size();
    00035         m_SpecList.reserve(list_size);
    00036         uint32 i=0;
    00037         for(; i < list_size; i++)
    00038                 m_SpecList.push_back(s.m_SpecList[i]->Clone());
    00039         //copy the feature list
    00040         list_size =  s.m_featureList.size();
    00041         m_featureList.reserve(list_size);
    00042         for(i=0; i < list_size; i++)
    00043                 m_featureList.push_back(s.m_featureList[i]->Clone());
    00044 }
    00045 gnFragmentSpec::~gnFragmentSpec()
    00046 {
    00047         Clear();
    00048 }
    00049 // Clone
    00050 void gnFragmentSpec::Clear()
    00051 {
    00052         uint32 list_size =  m_SpecList.size();
    00053         for(uint32 i=0; i < list_size; i++)
    00054                 delete m_SpecList[i];
    00055         m_SpecList.clear();
    00056         list_size =  m_featureList.size();
    00057         for(uint32 i=0; i < list_size; i++)
    00058                 delete m_featureList[i];
    00059         m_featureList.clear();
    00060         gnMultiSpec::Clear();
    00061 }
    00062 //Fragment
    00063 void gnFragmentSpec::GetContainedFeatures(const gnLocation& lt, vector<gnBaseFeature*>& feature_vector, vector<uint32>& index_vector) const{
    00064         for(uint32 i=0; i < m_featureList.size(); i++){
    00065                 if(m_featureList[i]->IsContainedBy(lt))
    00066                         feature_vector.push_back(m_featureList[i]->Clone());
    00067                         index_vector.push_back(i);
    00068         }
    00069 }
    00070 void gnFragmentSpec::GetIntersectingFeatures(const gnLocation& lt, vector<gnBaseFeature*>& feature_vector, vector<uint32>& index_vector) const{
    00071         for(uint32 i=0; i < m_featureList.size(); i++){
    00072                 if(m_featureList[i]->Intersects(lt))
    00073                         feature_vector.push_back(m_featureList[i]->Clone());
    00074                         index_vector.push_back(i);
    00075         }
    00076 }
    00077 void gnFragmentSpec::GetBrokenFeatures(const gnLocation& lt, vector<gnBaseFeature*>& feature_vector) const{
    00078         for(uint32 i=0; i < m_featureList.size(); i++)
    00079                 if(m_featureList[i]->IsBroken() && m_featureList[i]->IsContainedBy(lt))
    00080                         feature_vector.push_back(m_featureList[i]->Clone());
    00081 }
    00082
    00083 //do feature cropping... done
    00084 void gnFragmentSpec::CropStart( gnSeqI cropLen ){
    00085         uint32 flen = m_featureList.size();
    00086         for(uint32 featureI = 0; featureI < flen; featureI++){
    00087                 m_featureList[featureI]->CropStart(cropLen);
    00088         }
    00089         gnMultiSpec::CropStart(cropLen);
    00090 }
    00091
    00092 void gnFragmentSpec::CropEnd( gnSeqI cropLen ){
    00093         uint32 flen = m_featureList.size();
    00094         for(uint32 featureI = 0; featureI < flen; featureI++){
    00095                 m_featureList[featureI]->CropEnd(cropLen);
    00096         }
    00097         gnMultiSpec::CropEnd(cropLen);
    00098 }
    00099
    00100 gnFragmentSpec* gnFragmentSpec::CloneRange( const gnSeqI startI, const gnSeqI len ) const{
    00101         if(len == 0)
    00102                 return new gnFragmentSpec();
    00103
    00104         //find the valid range of specs to copy
    00105         uint32 firstSpec = GetSpecIndexByBase(startI);
    00106         gnSeqI total_copylen = len;
    00107         uint32 endSpec;
    00108         if(len != GNSEQI_END){
    00109                 endSpec = GetSpecIndexByBase(startI + len - 1);
    00110         }else{
    00111                 endSpec = GetSpecListLength() - 1;
    00112                 total_copylen = GetLength() - startI;
    00113         }
    00114
    00115         //find their starting and ending bases
    00116         gnSeqI firstBase = startI - GetSpecStartBase(firstSpec);
    00117         gnSeqI firstSpecLen = GetSpec(firstSpec)->GetLength();
    00118         boolean spans_specs = true;
    00119         gnSeqI firstCopyLen = firstSpecLen - firstBase;
    00120         if(firstCopyLen >= total_copylen){
    00121                 spans_specs = false;
    00122                 firstCopyLen = total_copylen;
    00123         }
    00124         gnFragmentSpec* destSpec = new gnFragmentSpec();
    00125         gnContigSpec* newSpec = m_SpecList[firstSpec]->CloneRange(firstBase, firstCopyLen);
    00126         destSpec->AddSpec( newSpec );
    00127
    00128         gnSeqI cur_copylen = firstCopyLen;
    00129         //add all the completely covered specs in the middle
    00130         for(uint32 specI = firstSpec + 2; specI <= endSpec; specI++){
    00131                 destSpec->AddSpec(GetSpec(specI-1)->Clone());
    00132                 cur_copylen += GetSpec(specI-1)->GetLength();
    00133         }
    00134         //add the last spec if necessary
    00135         if(spans_specs){
    00136                 newSpec = m_SpecList[endSpec]->CloneRange( 0, total_copylen - cur_copylen);
    00137                 destSpec->AddSpec(newSpec);
    00138         }
    00139
    00140         //now clone all the appropriate features
    00141         gnLocation lt;
    00142         vector<gnBaseFeature*> feature_vector;
    00143         vector<uint32> index_vector;
    00144         lt.SetStart(startI);
    00145         lt.SetEnd(startI + total_copylen);
    00146         GetIntersectingFeatures(lt, destSpec->m_featureList, index_vector);
    00147
    00148         return destSpec;
    00149 }
    00150
    00151 /*IMPLEMENT ME!!  ADD FEATURE Manipulation*/
    00152 void gnFragmentSpec::SetReverseComplement( const boolean value )
    00153 {
    00154         if(value == m_reverseComplement)
    00155                 return;
    00156         //reverse the spec list entries
    00157         vector<gnContigSpec*> tmp_spec_list;
    00158         for(uint32 i=0; i < GetSpecListLength(); i++){
    00159                 //transmit rev_comp down the tree
    00160                 GetSpec(i)->SetReverseComplement(!GetSpec(i)->IsReverseComplement());
    00161                 tmp_spec_list.insert(tmp_spec_list.begin(), GetSpec(i));
    00162         }
    00163         m_SpecList = tmp_spec_list;
    00164         m_reverseComplement = value;
    00165 }