---

gnSequence.h

Go to the documentation of this file.

// File:            gnSequence.h
// Purpose:         Sequence class
// Description:     Provides a high level sequence interface to all types of
//                                      sequence data.
// Changes:        
// Version:         libGenome 0.1.0 
// Author:          Aaron Darling 
// Last Edited:     April 15, 2001, 10:34:50pm 
// Modified by:     
// Copyright:       (c) Aaron Darling 
// Licenses:        Proprietary 
#ifndef _gnSequence_h_
#define _gnSequence_h_

#include "gn/gnDefs.h"

#include <string>
#include <iostream>
#include <list>
#include "gn/gnBaseSource.h"
#include "gn/gnGenomeSpec.h"
#include "gn/gnSourceSpec.h"
#include "gn/gnStringSpec.h"
#include "gn/gnBaseFilter.h"
#include "gn/gnCompare.h"

class GNDLLEXPORT gnSequence : public gnClone
{
public:
        gnSequence();
        gnSequence( const gnSeqC* seq );
        gnSequence( const string& str );
        gnSequence( const gnGenomeSpec& gngs );
        gnSequence( const gnFragmentSpec& gnfs );
        gnSequence( const gnContigSpec& gncs );
        gnSequence( gnSeqC *bases, const gnSeqI length);
        gnSequence( const gnSequence& seq);
        ~gnSequence();

        gnSequence& operator=( const gnSequence& seq);

        gnSequence* Clone() const;

        gnSeqI contigListSize() const;
        gnSeqI contigListLength() const;
        uint32 contigIndexByBase( const gnSeqI baseI) const;
        gnSequence contig( const uint32 contigI) const;
        gnSequence contigByBase( const gnSeqI baseI) const;
        virtual gnSeqI contigStart( const uint32 contigI) const;
        virtual gnSeqI contigLength( const uint32 contigI) const;
        virtual uint32 contigIndexByName( string& contigName) const;
        virtual string contigName( const uint32 contigI) const;
        virtual gnSequence contigByName( string& contigName) const;
        virtual void merge(const gnSeqI startI, const gnSeqI endI);
        virtual void mergeContigs(const uint32 startC, const uint32 endC);
        virtual void splitContig(const gnSeqI splitI, const uint32 contigI=ALL_CONTIGS);

        virtual void setContigName( const uint32 contigI, const string& contig_name);

        virtual uint32 getFeatureListLength() const;
        virtual gnBaseFeature* getFeature(const uint32 featureI) const;
        virtual void getContainedFeatures(const gnLocation& lt, vector<gnBaseFeature*>& feature_vector, vector<uint32>& index_vector) const;
        virtual void getIntersectingFeatures(const gnLocation& lt, vector<gnBaseFeature*>& feature_vector, vector<uint32>& index_vector) const;
        virtual uint32 addFeature(gnBaseFeature* feature);
        virtual void removeFeature(const uint32 featureI);
        virtual void getBrokenFeatures(const gnLocation& lt, vector<gnBaseFeature*>& feature_vector) const;
        virtual uint32 getHeaderListLength(const uint32 contigI) const;
        virtual gnBaseHeader* getHeader(const uint32 contigI, const uint32 headerI) const;
        virtual void addHeader(const uint32 contigI, gnBaseHeader* header, const uint32 headerI);
        virtual void removeHeader(const uint32 contigI, const uint32 headerI);
        virtual void setReverseComplement( const boolean revComp, const uint32 contigI=ALL_CONTIGS);
        virtual boolean isReverseComplement( const uint32 contigI=ALL_CONTIGS );
        virtual boolean isCircular() const;
        virtual void setCircular( const boolean value );
        
        virtual void globalToLocal(uint32& contigI, gnSeqI& baseI) const;

        virtual void localToGlobal(const uint32 contigI, gnSeqI& baseI) const;
        virtual void globalToSource(uint32& contigI, gnSeqI& baseI) const;
        virtual void localToSource(uint32& contigI, gnSeqI& baseI) const;
        virtual bool LoadSource(const string sourcename);

        virtual void setFilter(const gnBaseFilter* filt);

        virtual void setFilterList(list<const gnBaseFilter*>& filt_list);

        virtual list<const gnBaseFilter*> getFilterList() const;

        virtual void assign(gnSequence& seq);

// Comparison Operators
        void operator=(gnSequence& seq);
        boolean operator==(const gnSequence& seq) const;
        boolean operator!=(const gnSequence& seq) const;
        boolean operator<(const gnSequence& seq) const;
        boolean operator<=(const gnSequence& seq) const;
        boolean operator>(const gnSequence& seq) const;
        boolean operator>=(const gnSequence& seq) const;
        gnSequence& operator+=(const gnSequence& seq);
        virtual int compare(const gnSequence& seq) const;
        virtual int compare(const string& str) const;
// Append and Insert Operators
        virtual void append( const gnSequence& seq);
        virtual void insert( const gnSeqI offset, const gnSeqC *bases, const gnSeqI length);
        virtual void insert( const gnSeqI offset, const gnSequence& seq);
        virtual void insert( const gnSeqI offset, const gnGenomeSpec& gnbs);
// Concatenation Operators
        gnSequence const operator+(const gnSequence& seq) const;
// Substrings and base deletion
        gnSequence subseq(const gnSeqI offset, const gnSeqI length) const;
        virtual void erase( const gnSeqI offset=0, const gnSeqI length=GNSEQI_END );
// IO operators
        friend std::istream& operator>>(std::istream& is, gnSequence& gns);     //read from source.
        friend std::ostream& operator<<(std::ostream& os, const gnSequence& gns); //write to source.
// Size functions
        virtual gnSeqI length() const;
        virtual gnSeqI size() const;
// Raw Sequence Access
        virtual string ToString( const gnSeqI length=GNSEQI_END, const gnSeqI offset=1 ) const;
        virtual boolean ToString( string& str, const gnSeqI length=GNSEQI_END, const gnSeqI offset=1 ) const;
        virtual boolean ToArray( gnSeqC* pSeqC, gnSeqI length, const gnSeqI offset=1 ) const;
        virtual gnSeqC GetSeqC( const gnSeqI offset ) const; // return gnSeqC illegal char.
        gnSeqC operator[]( const gnSeqI offset ) const;

        virtual gnGenomeSpec* GetSpec() const;
        virtual void SetSpec(gnGenomeSpec* s);
        
        virtual gnSeqI find(const gnSequence& search, const gnSeqI offset=0) const;
        
private:
        gnGenomeSpec *spec;
        list<const gnBaseFilter*> filter_list;
        const gnCompare* comparator;
}; // class gnSequence


GNDLLEXPORT
std::istream& operator>>(std::istream& is, gnSequence& gns);    //read from source.
GNDLLEXPORT
std::ostream& operator<<(std::ostream& os, const gnSequence& gns); //write to source.

// Assignment Operators
inline
void gnSequence::operator=(gnSequence& seq){
        spec = seq.spec->Clone();
}
inline
void gnSequence::assign(gnSequence& seq){
        spec = seq.spec->Clone();
}
inline
boolean gnSequence::operator==(const gnSequence& seq) const{
        return (compare(seq)==0);
}
inline
boolean gnSequence::operator!=(const gnSequence& seq) const{
        return (compare(seq)!=0);
}
inline
boolean gnSequence::operator<(const gnSequence& seq) const{
        return (compare(seq)<0);
}
inline
boolean gnSequence::operator<=(const gnSequence& seq) const{
        return (compare(seq)<=0);
}
inline
boolean gnSequence::operator>(const gnSequence& seq) const{
        return (compare(seq)>0);
}
inline
boolean gnSequence::operator>=(const gnSequence& seq) const{
        return (compare(seq)>=0);
}
// Append and Insert Operators
inline
gnSequence& gnSequence::operator+=(const gnSequence& seq){
        insert(GNSEQI_END, *seq.spec);
        return *this;
}
inline
void gnSequence::append( const gnSequence& seq){
        insert(GNSEQI_END, *seq.spec);
}
//Feature functions
inline
uint32 gnSequence::getFeatureListLength() const{
        return spec->GetFeatureListLength();
}
inline
gnBaseFeature* gnSequence::getFeature(const uint32 featureI) const{
        return spec->GetFeature(featureI);
}
inline
uint32 gnSequence::addFeature(gnBaseFeature* feature){
        return spec->AddFeature(feature);
}
inline
void gnSequence::removeFeature(const uint32 featureI){
        spec->RemoveFeature(featureI);
}
inline
void gnSequence::getContainedFeatures(const gnLocation& lt, vector<gnBaseFeature*>& feature_vector, vector<uint32>& index_vector) const{
        spec->GetContainedFeatures(lt, feature_vector, index_vector);
}
inline
void gnSequence::getIntersectingFeatures(const gnLocation& lt, vector<gnBaseFeature*>& feature_vector, vector<uint32>& index_vector) const{
        spec->GetIntersectingFeatures(lt, feature_vector, index_vector);
}
inline
void gnSequence::getBrokenFeatures(const gnLocation& lt, vector<gnBaseFeature*>& feature_vector) const{
        spec->GetBrokenFeatures(lt, feature_vector);
}

inline
boolean gnSequence::isCircular() const{
        return spec->IsCircular();
}

inline
void gnSequence::setCircular( const boolean value ){
        spec->SetCircular(value);
}
inline
void gnSequence::insert( const gnSeqI offset, const gnSequence& seq){
        insert(offset, *seq.spec);
}

// Size functions
inline
gnSeqI gnSequence::length() const{
        return spec->GetLength();
}
inline
gnSeqI gnSequence::size() const{
        return spec->GetLength();
}
inline
gnGenomeSpec* gnSequence::GetSpec() const{
        return spec;
}
inline
void gnSequence::SetSpec(gnGenomeSpec* s){
        if(spec != NULL)
                delete spec;
        spec = s;
}

inline
void gnSequence::setFilter(const gnBaseFilter* filt){
        filter_list.clear();
        if(filt != NULL)
                filter_list.push_back(filt);
}
inline
void gnSequence::setFilterList(list<const gnBaseFilter*>& filt_list){
        filter_list = filt_list;
}
inline
list<const gnBaseFilter*> gnSequence::getFilterList() const{
        return filter_list;
}


#endif
        // _gnSequence_h_

---