AlignmentBase.h

/*  This file is part of Victor.

    Victor is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Victor is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Victor.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __AlignmentBase_H__
#define __AlignmentBase_H__

#include <Debug.h>
#include <string>
#include <vector>

namespace Victor { namespace Align2{

    class AlignmentBase {
    public:

        // CONSTRUCTORS:

        AlignmentBase();

        AlignmentBase(const AlignmentBase &orig);

        virtual ~AlignmentBase();


        // OPERATORS:

        AlignmentBase& operator =(const AlignmentBase &orig);


        // PREDICATES:

        unsigned int size() const;

        unsigned int getLength();

        unsigned int getSequenceLength(const string &seq);

        virtual string getTargetName() const;

        virtual string getTarget() const;

        virtual char getTargetPos(unsigned int p) const;

        virtual int getTargetAminoAcidOffset() const;

        virtual string getTemplateName(unsigned int index = 0) const;

        virtual string getTemplate(unsigned int index = 0) const;

        virtual char getTemplatePos(unsigned int p, unsigned int index = 0) const;

        virtual int getTemplateAminoAcidOffset(unsigned int index = 0) const;

        virtual double calculatePairwiseIdentity(const string &seq1,
                const string &seq2);

        virtual double calculateIdentity();

        virtual bool isConserved(unsigned int p, unsigned int index = 9999) const;

        virtual bool isInsertion(unsigned int p, unsigned int index = 0) const;

        virtual bool isDeletion(unsigned int p) const;

        virtual bool isGap(unsigned int p, unsigned int index = 0) const;

        virtual vector< vector<int> > getMatchSubset();

        virtual vector<int> shiftMatchSubset(vector<int> inputVector,
                int newStartPos);

        virtual double matchPositionVector(vector<int> CeTarget,
                vector<int> CeTemplate, vector<int> seqTarget, vector<int> seqTemplate);

        static void saveFasta(string t, string tName, ostream &output);

        virtual void saveFasta(ostream &output) const;

        static void saveClustal(string t, string tName, ostream &output,
                unsigned int from);

        virtual void saveClustal(ostream &output) const;


        // MODIFIERS:

        virtual void copy(const AlignmentBase &orig);

        virtual AlignmentBase* newCopy();

        virtual void setTarget(string t, string tName = "target");

        virtual void setTargetPos(unsigned int p, char res);

        virtual void setTargetAminoAcidOffset(int orig);

        virtual void setTemplate(string t, string tName = "template");

        virtual void setTemplatePos(unsigned int p, char res,
                unsigned int index = 0);

        virtual void swapTemplate(unsigned int index1, unsigned int index2);

        virtual void setTemplateAminoAcidOffset(unsigned int index, int val);

        void insertCharacter(unsigned int p, char c);

        void insertDash(unsigned int p);

        void deletePos(unsigned int p);

        void purgeTargetInsertions();

        virtual void cutTemplate(unsigned int index);

        virtual void clearTemplate();

        virtual void addAlignment(const AlignmentBase &other);

        virtual void clearAlignment();


        // HELPERS:

        static string getPureSequence(const string &s);

        static unsigned int getOrigPos(const string &s, unsigned int p);

        static unsigned int getNewPos(const string &s, unsigned int p);

        vector<string> getTokens(const string &text);

        string deleteChar(const string &s, unsigned int n);


    protected:

        // ATTRIBUTES:

        string targetName; 
        vector<string> seqTemplateName; 
        string target; 
        vector<string> seqTemplate; 
        int startAaTarget; 
        vector<int> startAaTemplates; 


    private:

    };

    // -----------------------------------------------------------------------------
    //                                AlignmentBase
    // -----------------------------------------------------------------------------

    // PREDICATES:

    inline unsigned int
    AlignmentBase::size() const {
        return seqTemplate.size();
    }

    inline unsigned int
    AlignmentBase::getLength() {
        return target.length();
    }

    inline string
    AlignmentBase::getTargetName() const {
        return targetName;
    }

    inline string
    AlignmentBase::getTarget() const {
        return target;
    }

    inline char
    AlignmentBase::getTargetPos(unsigned int p) const {
        if (p >= target.length())
            ERROR("AlignmentBase::getTargetPos() Invalid position requested.", exception);
        return target[p];
    }

    inline int
    AlignmentBase::getTargetAminoAcidOffset() const {
        return startAaTarget;
    }

    inline string
    AlignmentBase::getTemplateName(unsigned int index) const {
        if (index >= seqTemplateName.size())
            ERROR("AlignmentBase::getTemplateName() Invalid template requested.", exception);
        return seqTemplateName[index];
    }

    inline string
    AlignmentBase::getTemplate(unsigned int index) const {
        if (index >= seqTemplate.size())
            ERROR("AlignmentBase::getTemplate() Invalid template requested.", exception);
        return seqTemplate[index];
    }

    inline char
    AlignmentBase::getTemplatePos(unsigned int p, unsigned int index) const {
        if (index >= seqTemplate.size())
            ERROR("AlignmentBase::getTemplatePos() Invalid template requested.", exception);
        if (p >= seqTemplate[index].length())
            ERROR("AlignmentBase::getTemplatePos() Invalid position requested.", exception);
        return seqTemplate[index][p];
    }

    inline int
    AlignmentBase::getTemplateAminoAcidOffset(unsigned int index) const {
        return startAaTemplates[index];
    }

    inline void
    AlignmentBase::saveFasta(string t, string tName, ostream &output) {
        output << ">" << tName << "\n";

        for (unsigned int i = 0; i < t.length(); i++) {
            if ((i != 0) && ((i % 60) == 0))
                output << "\n";
            output << t[i];
        }

        output << "\n";
    }

    inline void
    AlignmentBase::saveClustal(string t, string tName, ostream &output,
            unsigned int from) {
        output << tName;

        for (int i = 0; i < (17 - static_cast<int> (tName.length())); ++i)
            output << " ";

        unsigned int max = ((from + 60) < t.length()) ? from + 60 : t.length();
        for (unsigned int i = from; i < max; i++)
            output << t[i];

        output << "\n";
    }


    // MODIFIERS:

    inline void
    AlignmentBase::setTarget(string t, string tName) {
        if (seqTemplate.size() > 0)
            if (t.length() != seqTemplate[0].length())
                ERROR("AlignmentBase::setTarget() Target length does not match template.", exception);
        targetName = tName;
        target = t;
    }

    inline void
    AlignmentBase::setTargetPos(unsigned int p, char res) {
        if (p >= target.length())
            ERROR("AlignmentBase::getTargetPos() Invalid position requested.", exception);
        target[p] = res;
    }

    inline void
    AlignmentBase::setTargetAminoAcidOffset(int orig) {
        startAaTarget = orig;
    }

    inline void
    AlignmentBase::setTemplatePos(unsigned int p, char res, unsigned int index) {
        if (index >= seqTemplate.size())
            ERROR("AlignmentBase::getTemplatePos() Invalid template requested.", expection);
        if (p >= seqTemplate[index].length())
            ERROR("AlignmentBase::getTemplatePos() Invalid position requested.", exception);
        seqTemplate[index][p] = res;
    }

    inline void
    AlignmentBase::setTemplateAminoAcidOffset(unsigned int index, int val) {
        PRECOND(index < startAaTemplates.size(), exception);
        startAaTemplates[index] = val;
    }

    inline void
    AlignmentBase::clearTemplate() {
        seqTemplate.clear();
        seqTemplateName.clear();
        startAaTemplates.clear();
    }

    inline void
    AlignmentBase::clearAlignment() {
        targetName = "";
        target = "";
        startAaTarget = 0;
        clearTemplate();
    }

}} // namespace

#endif