alignment_string_ops.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 * 
 * This file is part of SHORE.
 * 
 * SHORE 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.
 * 
 * SHORE 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 SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef SHORE_ALIGNMENT_STRING_OPS_HPP__
#define SHORE_ALIGNMENT_STRING_OPS_HPP__

#include <iterator>
#include <limits>
#include <string>

#include "shore/datatype/datatypes.hpp"

namespace shore {

enum AlignmentOperation
{
        ALN_NOOP=0,
        ALN_MATCH=1,
        ALN_SUBST=2,
        ALN_INS=4,
        ALN_DEL=8,
        ALN_LONGDEL=16,
        ALN_FRAGMENT=32,
        ALN_SOFTCLIP=64,
        ALN_BISULFITE=128,
        ALN_GRAPH=256,
        ALN_INVERT=512
};

class alignment_tokenizer;
class alignment_helper;

class alignment_token
{
 public:

        typedef std::string::const_iterator iterator;
        typedef std::reverse_iterator<iterator> reverse_iterator;

 private:

        friend class alignment_tokenizer;
        friend class alignment_builder;
        friend class alignment_helper;

        static const std::string CIGAR_TRF;

        bool m_sequence_omitted;

        iterator m_ref_beg;
        iterator m_ref_end;
        iterator m_qry_beg;
        iterator m_qry_end;

        int m_operation;
        long m_opsize;
        long m_refsize;
        long m_qrysize;
        long m_nchars;

 public:

        alignment_token();
        void clear();

        bool sequence_omitted() const;

        int operation() const;

        long opsize() const;

        long refsize() const;

        long querysize() const;

        long nchars() const;

        iterator ref_begin() const;

        iterator ref_end() const;

        iterator query_begin() const;

        iterator query_end() const;

        void print(std::ostream &os) const;

        void to_string(std::string &res,const size_t pos=0,
                       const size_t size=std::numeric_limits<size_t>::max(),
                       const bool omit_refbases=false) const;
        void to_cigar(std::string &res,const size_t pos=0,
                      const size_t size=std::numeric_limits<size_t>::max()) const;
};

struct alignment;

class alignment_tokenizer
{
 private:

        bool m_reverse;

        const std::string *m_aln;
        long m_offset;
        bool m_hasdata;

        alignment_token m_current;

        std::string m_ref;
        std::string m_qry;


        void tokenize_fwd();
        void tokenize_rev();

 public:
 
        alignment_tokenizer();

        void set_alignment(const std::string &aln);

        const std::string &get_alignment() const;

        void set_reverse(const bool rev);

        const alignment_token &current() const;

        bool has_data();

        void next();
};

class alignment_builder
{
 private:

        std::vector<shore::nuc::base> m_ref;
        std::vector<shore::nuc::base> m_qry;
        std::vector<AlignmentOperation> m_ops;

        std::string m_ws_ref;
        std::string m_ws_qry;
        alignment_token m_ws_tok;

        AlignmentOperation m_ws_op;


        void build_at(std::string & buf,size_t i);

 public:

        void to_string(std::string & buf,const bool reverse);

        void add_softclip(const shore::nuc::base b);

        void add_qry(const shore::nuc::base b);

        void add_ref(const shore::nuc::base b);

        void add_paired(const shore::nuc::base r,const shore::nuc::base q);

        size_t size() const;

        bool empty() const;

        void resize(const size_t size);

        void clear();
};

class alignment_helper
{
 private:

        alignment_tokenizer m_alntok;
        std::string m_workspace;

 public:

        size_t extract_ref(const std::string &alignment,std::string &ref);

        size_t extract_qry(const std::string &alignment,std::string &qry,
                           const bool include_softclipped=false);

        void extract_seq(const std::string &alignment,
                         std::string &ref,std::string &qry,
                         const bool include_softclipped=false);

        size_t calc_size_of_qry(const std::string &alignment,
                                const bool include_softclipped=false);

        size_t calc_size_on_ref(const std::string &alignment);

        int calc_editdistance(const std::string &alignment);

        std::pair<int,int> calc_indels(const std::string &alignment);

        int move_start_by_qrybases(std::string &alignment,int nbases);

        int move_start_by_refbases(std::string &alignment,int nbases);

        int move_end_by_qrybases(std::string &alignment,int nbases);

        int move_end_by_refbases(std::string &alignment,int nbases);

        void rebuild(std::string &alignment);

        void invert(std::string &alignment);

        void revcomp(std::string &alignment);

        void paste(std::string &alignment,const std::string &other,
                   int distance=0,bool inv=false,bool forcefrag=true,
                   bool nomove=false);

        void cigar(const std::string &alignment,
                   std::string &cigar,const char sep=0);


        size_t calc_size_on_ref(const shore::alignment &a);

        long calc_end_excl(const shore::alignment &a);

        shore::refseq_coor calc_end_coor_excl(const shore::alignment &a);

        void resize(shore::alignment &f,const size_t newsize);


        static std::string compose(alignment_tokenizer &ref,
                                   alignment_tokenizer &qry);
};

} // namespace

#endif // SHORE_ALIGNMENT_STRING_OPS_HPP__