---

gnBaseFeature.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
// File:            gnBaseFeature.cpp
// Purpose:         implements the gnBaseFeature
// Description:     
// Changes:        
// Version:         libGenome 0.5.1 
// Author:          Aaron Darling 
// Modified by:     
// Copyright:       (c) Aaron Darling 
// Licenses:        See COPYING file for details
/////////////////////////////////////////////////////////////////////////////
#include "gn/gnBaseFeature.h"
#include "gn/gnLocation.h"
#include "gn/gnStringQualifier.h"
#include "gn/gnDebug.h"
#include <list>

gnBaseFeature::gnBaseFeature( )
{
        m_id = 0;
        m_name = "";
        m_locationType = gnLocation::LT_Nothing;
        m_broken = false;
        m_spec = NULL;
}
gnBaseFeature::gnBaseFeature( string& name, uint32 id, gnFragmentSpec* spec, gnLocation::gnLocationType lt, boolean broken )
{
        m_id = id;
        m_name = name;
        m_locationType = lt;
        m_broken = broken;
        m_spec = NULL;
}
gnBaseFeature::~gnBaseFeature()
{
        for( uint32 i=0; i < m_qualifierList.size(); i++)
                delete m_qualifierList[i];
}
// Clone
// Location Modification methods
boolean gnBaseFeature::MovePositive( const gnSeqI i )
{
        boolean still_valid = true;
        for(uint32 locationI=0; locationI< m_locationList.size(); locationI++){
                still_valid = still_valid && m_locationList[locationI].MovePositive(i);
        }
        return still_valid;
}
boolean gnBaseFeature::MoveNegative( const gnSeqI i )
{
        boolean still_valid = true;
        for(uint32 locationI=0; locationI< m_locationList.size(); locationI++){
                still_valid = still_valid && m_locationList[locationI].MoveNegative(i);
        }
        return still_valid;
}
//delete everything bigger than i
boolean gnBaseFeature::CropEnd( const gnSeqI i )
{
        boolean still_valid = true;
        for(uint32 locationI=0; locationI< m_locationList.size(); locationI++){
                still_valid = still_valid && m_locationList[locationI].CropEnd(i);
        }
        return still_valid;
}
//delete everything less than i
boolean gnBaseFeature::CropStart( const gnSeqI i ){
        boolean still_valid = true;
        for(uint32 locationI=0; locationI< m_locationList.size(); locationI++){
                still_valid = still_valid && m_locationList[locationI].CropStart(i);
        }
        return still_valid;
}
uint32 gnBaseFeature::FirstIndexOfQualifier( const string& name, uint32 listI ) const{
        if(listI >= m_qualifierList.size())
                return GNSEQI_END;
        
        uint32 i=listI;
        for(; i < m_qualifierList.size(); i++){
                string qname = m_qualifierList[i]->GetName();
                if(qname == name)
                        break;
        }
        return i;
}
uint32 gnBaseFeature::LastIndexOfQualifier( const string& name, uint32 listI ) const{
        if(listI >= m_qualifierList.size())
                return GNSEQI_END;
        
        uint32 i=m_qualifierList.size()-1;
        for(; i >= listI; i--)
                if(m_qualifierList[i]->GetName() == name)
                        break;
        return i;
}
boolean gnBaseFeature::RemoveQualifier( uint32 listI ){
        if(listI < m_qualifierList.size()){
                delete m_qualifierList[ listI ];
                m_qualifierList.erase(m_qualifierList.begin() + listI);
                return true;
        }
        return false;
}
boolean gnBaseFeature::SetQualifier( string& name, string& value, uint32 listI ){
        if(listI < m_qualifierList.size()){
                delete m_qualifierList[ listI ];
                m_qualifierList[listI] = new gnStringQualifier(name, value);
                return true;
        }
        return false;
}
boolean gnBaseFeature::SetQualifierName( string& name, uint32 listI ){
        if(listI < m_qualifierList.size()){
                gnStringQualifier* new_qual = new gnStringQualifier(name, m_qualifierList[listI]->GetValue());
                delete m_qualifierList[listI];
                m_qualifierList[listI] = new_qual;
                return true;
        }
        return false;
}
boolean gnBaseFeature::SetQualifierValue( string& value, uint32 listI ){
        if(listI < m_qualifierList.size()){
                gnStringQualifier* new_qual = new gnStringQualifier(m_qualifierList[listI]->GetName(), value);
                delete m_qualifierList[listI];
                m_qualifierList[listI] = new_qual;
                return true;
        }
        return false;
}
// Compare methods
boolean gnBaseFeature::Contains( gnSeqI i ) const{
        for(uint32 locationI=0; locationI< m_locationList.size(); locationI++){
                if((m_locationList[locationI].GetStart() <= i) &&
                        (m_locationList[locationI].GetEnd() >= i))
                        return true;
        }
        return false;
}
boolean gnBaseFeature::Contains( const gnLocation& l ) const{
        for(uint32 locationI=0; locationI< m_locationList.size(); locationI++){
                if(m_locationList[locationI].Contains(l))
                        return true;
        }
        return false;
}
boolean gnBaseFeature::Contains( gnBaseFeature* feature ) const{
        for(uint32 locationI=0; locationI< m_locationList.size(); locationI++){
                uint32 i=0;
                for(; i < feature->GetLocationListLength(); i++){
                        if(m_locationList[locationI].Contains(feature->GetLocation(i)))
                                break;  //it's contained so we'll break the loop early
                }
                if(i == feature->GetLocationListLength())
                        return false;   //the loop went full cycle.  we found an uncontained location
        }
        return true;
}
boolean gnBaseFeature::IsContainedBy( const gnLocation& l ) const{
        for(uint32 locationI=0; locationI< m_locationList.size(); locationI++){
                if(!l.Contains(m_locationList[locationI]))
                        return false;
        }
        return true;
}

boolean gnBaseFeature::Intersects( const gnLocation& l ) const{
        for(uint32 locationI=0; locationI< m_locationList.size(); locationI++){
                if(!l.Intersects(m_locationList[locationI]))
                        return false;
        }
        return true;
}
boolean gnBaseFeature::Intersects( gnBaseFeature* feature ) const{
        for(uint32 locationI=0; locationI< m_locationList.size(); locationI++){
                uint32 i=0;
                for(; i < feature->GetLocationListLength(); i++){
                        if(m_locationList[locationI].Intersects(feature->GetLocation(i)))
                                break;  //it's contained so we'll break the loop early
                }
                if(i == feature->GetLocationListLength())
                        return false;   //the loop went full cycle.  we found an uncontained location
        }
        return true;
}
inline
boolean gnBaseFeature::AddLocation( const gnLocation& l, uint32 listI ){
        if(listI <= m_locationList.size()){
                m_locationList.insert(m_locationList.begin() + listI, l);
                return true;
        }
        return false;
}

gnLocation gnBaseFeature::GetLocation( uint32 listI ) const{
        if(listI < m_locationList.size())
                return m_locationList[listI];
        return gnLocation();
}

boolean gnBaseFeature::RemoveLocation( uint32 listI ){
        if(listI < m_locationList.size()){
                m_locationList.erase(m_locationList.begin() + listI);
                return true;
        }
        return false;
}

boolean gnBaseFeature::SetLocation( const gnLocation& l, uint32 listI ){
        if(listI < m_locationList.size()){
                m_locationList[listI] = l;
                return true;
        }
        return false;
}

boolean gnBaseFeature::AddQualifier( gnBaseQualifier* qualifier ){
        if(qualifier != NULL){
                m_qualifierList.push_back(qualifier);
                return true;
        }
        return false;
}

boolean gnBaseFeature::HasQualifier( const string& name ) const{
        for(uint32 i=0; i < m_qualifierList.size(); i++)
                if(m_qualifierList[i]->GetName() == name)
                        return true;
        return false;
}

string gnBaseFeature::GetQualifierName( uint32 listI ) const{
        if(listI < m_qualifierList.size())
                return m_qualifierList[listI]->GetName();
        return string();
}

string gnBaseFeature::GetQualifierValue( uint32 listI ) const{
        if(listI < m_qualifierList.size())
                return m_qualifierList[listI]->GetValue();
        return string();
}

gnBaseQualifier* gnBaseFeature::GetQualifier( uint32 listI ){
        if(listI < m_qualifierList.size())
                return m_qualifierList[listI]->Clone();
        return NULL;
}

---