Aligner.h

#ifndef _theplu_yat_utility_aligner_
#define _theplu_yat_utility_aligner_

// $Id: Aligner.h 3847 2019-09-22 23:39:13Z peter $

/*
  Copyright (C) 2012 Peter Johansson
  Copyright (C) 2013 Jari Häkkinen, Peter Johansson
  Copyright (C) 2014, 2016, 2019 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library 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.

  The yat library 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "CigarIterator.h"

#include <boost/cstdint.hpp>

#include <deque>
#include <cstddef>
#include <iosfwd>
#include <vector>

namespace theplu {
namespace yat {
namespace utility {

  class Matrix;

  class Aligner
  {
  public:
    enum direction { none, right, down, diagonal };

    explicit Aligner(double gap=0, double open_gap=0);

    Aligner(double vertical_gap, double open_vertical_gap,
            double horizon_gap, double open_horizon_gap);

    double needleman_wunsch(const Matrix& d);

    double smith_waterman(const Matrix& d);

    void operator()(const Matrix& dot, Matrix& score);

    const direction& alignment(size_t i, size_t j) const;

    class Cigar
    {
    public:
      typedef
      CigarIterator<std::deque<uint32_t>::const_iterator > const_iterator;

      const_iterator begin(void) const;

      void clear(void);

      const_iterator end(void) const;

      uint32_t length(void) const;

      uint8_t op(size_t i) const;

      char opchr(size_t i) const;

      uint32_t oplen(size_t i) const;

      void pop_back(uint32_t len=1);

      void pop_front(uint32_t len=1);

      void push_back(uint8_t op, uint32_t len=1);

      void push_front(uint8_t op, uint32_t len=1);

      uint32_t query_length(void) const;

      uint32_t reference_length(void) const;

      void reverse(void);

      uint32_t operator[](size_t i) const;

      size_t size(void) const;
    private:
      std::deque<uint32_t> cigar_;

      // calculate length only counting operations whose type is set
      // in mask, i.e., mask & type returns true
      uint32_t length(uint8_t mask) const;
      // using compiler generated copy
      // Cigar(const Cigar& other);
      // Cigar& operator=(const Cigar&);
    };

    const Cigar cigar(size_t i, size_t j) const;

  private:
    direction& directions(size_t i, size_t j);

    size_t columns_;
    double vertical_gap_;
    double open_vertical_gap_;
    double horizon_gap_;
    double open_horizon_gap_;
    std::vector<direction> alignment_;
  };


  std::ostream& operator<<(std::ostream& os, const Aligner::Cigar& cigar);

}}} // of namespace utility, yat, and theplu

#endif