libMems/gnAlignedSequences.h

Go to the documentation of this file.

/*******************************************************************************
 * $Id: gnAlignedSequences.h,v 1.5 2004/02/27 23:08:55 darling Exp $
 * This file is copyright 2002-2007 Aaron Darling and authors listed in the AUTHORS file.
 * This file is licensed under the GPL.
 * Please see the file called COPYING for licensing details.
 * **************
 ******************************************************************************/

// File:            gnAlignedSequences.h
// Purpose:         Aligned Sequences class
// Discription:     Provides an alignment interface for any number of alignable
//                                      sequences (the data of each of which is contained in a 
//                  genome::gnSequence object).
//                  Currently only compatible with ClustalW alignment files.
// Revisions:       
// Version:         A
// Created:         August 3, 2000, 11:55am
// Author:          Brian Gettler
// Last Edited:     May 3, 2001, 4:25pm
// Modified by:     
// Copyright:       (c)
// Licences:         
#ifndef __gnAlignedSequences_h__
#define __gnAlignedSequences_h__

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "libGenome/gnSequence.h"
#include "libGenome/gnFilter.h"
#include <list>
#include <fstream>
#include <vector>

namespace mems {

// the number of characters in each row of an alignment file
const int MEGA_ALIGN_COLUMNS = 60;

class gnAlignedSequences// : blClone
{
public:
        gnAlignedSequences();
        gnAlignedSequences(const gnAlignedSequences &toCopy);
        ~gnAlignedSequences();


        static const std::vector< std::string >& getSupportedFormats();

        static boolean isSupportedFormat( const std::string& format_name );

        void output( const std::string& format_name, std::ostream& os ) const;

// sequence alignment loading
        void constructFromClustalW(std::string alignedFileName);
        void constructFromPhylip(std::string alignedFileName);
        void constructFromMSF(std::string alignedFileName);
        void constructFromNexus(std::string alignedFileName);
        void constructFromMega(std::string alignedFileName);
        
        void constructFromRelaxedNexus( std::istream& align_stream );

        void assignFileName(std::string name);

// output
        bool outputPhylip(std::ostream& os) const;
        bool outputClustalW(std::ostream& os) const;
        bool outputMSF(std::ostream& os) const;
        bool outputNexus(std::ostream& os) const;
        bool outputMega(std::ostream& os) const;
        bool outputCodon(std::ostream& os) const;
        bool outputWithConsensus(std::ostream& os);

// alignment manipulators that create new gnAlignedSequences
        gnAlignedSequences getAlignedSegment(unsigned start, unsigned stop);
        gnAlignedSequences getCodons(int readingFrame, int startCodon, int codonMultiple);
        
        std::string getAlignedSequenceFileName();
        gnSeqI alignedSeqsSize() const;

        bool removeAlignedSeq(std::string seqName);
        bool removeAlignedSeq(unsigned index);

        void concatenateAlignedSequences(gnAlignedSequences toConcat);
        
        void extractVariableSites(gnAlignedSequences &variableSites, bool countGapsAsMismatches);

        bool collapseIdenticalSequences();
        std::vector <char> operator[]( const int offset ); //const;
        
        void addSequence(std::string& seqToAdd, std::string& seqName);
        void addSequence(genome::gnSequence& seqToAdd, std::string& seqName);

        std::list <std::pair <std::string*, std::string*> > alignedSequences;
        std::vector< std::string > sequences;
        std::vector< std::string > names;
        std::vector< int64 > positions;         
        void seq( uint seqI );

private:

        bool readRelaxedNexusAlignment( std::istream& align_stream );
        bool readClustalWAlignment();
        bool readPhylipAlignment();
        bool readMSFAlignment();
        bool readNexusAlignment();
        bool readMegaAlignment();

        bool constructClustalWAlignedSequenceList(std::ifstream& alignmentFile);
        bool constructPhylipAlignedSequenceList(std::ifstream& alignmentFile);
        bool constructMSFAlignedSequenceList(std::ifstream& alignmentFile);
        bool constructNexusAlignedSequenceList(std::ifstream& alignmentFile);
        bool constructMegaAlignedSequenceList(std::ifstream& alignmentFile);

        bool sequenceNameInList(std::string sequenceName, std::list <std::pair <std::string*, std::string*> >::iterator &sequenceItr);

        int sequenceNameInList( std::string& sequenceName );

        bool buildConsensus();

        void addSequence(genome::gnSequence seqToAdd, std::string seqName, int consensusStart, std::string originalConsensus);

        void addAllSegments(gnAlignedSequences &alignment, unsigned start, unsigned stop);
        void addAllSegmentsReplaceGaps(gnAlignedSequences &alignment, unsigned start, unsigned stop);
        void removeAllSegments(unsigned start, unsigned stop);
        
        int determineBaseIndex(char base);
        
        bool coordinates(std::string line);

        std::string alignedSequenceFileName;
//      list <pair <string*, genome::gnSequence*> > alignedSequences;
        std::string consensus;
        std::vector <int> indexPositions; // 1->n if a standard alignment, variable for varible sites
}; // gnAlignedSequences


// destructor
inline
gnAlignedSequences::~gnAlignedSequences() {}

inline
void gnAlignedSequences::assignFileName(std::string name) {alignedSequenceFileName=name;}

inline
std::string gnAlignedSequences::getAlignedSequenceFileName() {return alignedSequenceFileName;}

}

#endif  // __gnAlignedSequences_h__

---