SequenceWithQuality.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_SEQUENCEWITHQUALITY_H
#define BPP_SEQ_SEQUENCEWITHQUALITY_H
 
#include <Bpp/Numeric/VectorExceptions.h>
#include <Bpp/Numeric/VectorTools.h>
 
#include "SequenceWithAnnotation.h"
 
// From the STL
 
#include <string>
#include <vector>
#include <cstddef>
 
namespace bpp
{
class SequenceQuality :
  public virtual SequenceAnnotation
{
private:
  bool removable_;
  std::vector<int> qualScores_;
 
public:
  static const std::string QUALITY_SCORE;
  static const int DEFAULT_QUALITY_VALUE;
 
public:
  SequenceQuality(size_t size = 0, bool removable = true) :
    removable_(removable),
    qualScores_(size, DEFAULT_QUALITY_VALUE) {}
 
 
  SequenceQuality(const std::vector<int>& quality, bool removable = true) :
    removable_(removable),
    qualScores_(quality)
  {}
 
  virtual ~SequenceQuality() {}
  SequenceQuality* clone() const override { return new SequenceQuality(*this); }
public:
  void init(const Sequence& seq) override
  {
    qualScores_.resize(seq.size());
    std::fill(qualScores_.begin(), qualScores_.end(), DEFAULT_QUALITY_VALUE);
  }
 
  const std::string& getType() const override { return QUALITY_SCORE; }
 
  bool isValidWith(const SequenceWithAnnotation& sequence, bool throwException = true) const override
  {
    if (throwException && qualScores_.size() != sequence.size()) throw Exception("SequenceQuality. Quality scores must match the sequence size.");
    return qualScores_.size() == sequence.size();
  }
 
  bool isRemovable() const override { return removable_; }
  bool isShared() const override { return false; }
  void beforeSequenceChanged(const IntSymbolListEditionEvent& event) override {}
  void afterSequenceChanged(const IntSymbolListEditionEvent& event) override;
  void beforeSequenceInserted(const IntSymbolListInsertionEvent& event) override {}
  void afterSequenceInserted(const IntSymbolListInsertionEvent& event) override;
  void beforeSequenceDeleted(const IntSymbolListDeletionEvent& event) override {}
  void afterSequenceDeleted(const IntSymbolListDeletionEvent& event) override;
  void beforeSequenceSubstituted(const IntSymbolListSubstitutionEvent& event) override {}
  void afterSequenceSubstituted(const IntSymbolListSubstitutionEvent& event) override {}
 
  size_t getSize() const { return qualScores_.size(); }
 
  const int& operator[](size_t i) const { return qualScores_[i]; }
  int& operator[](size_t i) { return qualScores_[i]; }
 
  void setScores(const std::vector<int>& scores)
  {
    if (scores.size() != qualScores_.size())
      throw DimensionException("SequenceQuality::setScores. Trying to replace score by a vector with different length.", scores.size(), qualScores_.size());
    qualScores_ = scores;
  }
 
  const std::vector<int>& getScores() const { return qualScores_; }
 
  void setScore(size_t pos, int score)
  {
    if (pos >= qualScores_.size())
      throw Exception("SequenceQuality::setScore. Vector overflow. Scores number: " + TextTools::toString(qualScores_.size()) + ", but trying to insert score at position " + TextTools::toString(pos) + ".");
    qualScores_[pos] = score;
  }
 
  void setScores(size_t pos, const std::vector<int>& scores)
  {
    if (pos + scores.size() > qualScores_.size())
      throw Exception("SequenceQuality::setScores. Vector overflow. Scores number: " + TextTools::toString(qualScores_.size()) + ", but trying to insert " + TextTools::toString(scores.size()) + " scores at position " + TextTools::toString(pos) + ".");
    std::copy(scores.begin(), scores.end(), qualScores_.begin() + static_cast<ptrdiff_t>(pos));
  }
 
  bool merge(const SequenceAnnotation& anno) override
  {
    try
    {
      const SequenceQuality* qual = &dynamic_cast<const SequenceQuality&>(anno);
      VectorTools::append(qualScores_, qual->getScores());
      return true;
    }
    catch (std::exception& e)
    {
      return false;
    }
  }
 
  std::unique_ptr<SequenceAnnotation> getPartAnnotation(size_t pos, size_t len) const override
  {
    return std::unique_ptr<SequenceAnnotation>(new SequenceQuality(
          std::vector<int>(
          qualScores_.begin() + static_cast<ptrdiff_t>(pos),
          qualScores_.begin() + static_cast<ptrdiff_t>(pos + len)),
          removable_));
  }
};
 
 
class SequenceWithQuality :
  public SequenceWithAnnotation
{
private:
  std::shared_ptr<SequenceQuality> qualScores_;
 
public:
  SequenceWithQuality(
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    SequenceWithAnnotation(alpha),
    qualScores_(new SequenceQuality(0, false))
  {
    addAnnotation(qualScores_);
  }
 
  SequenceWithQuality(
      const std::string& name,
      const std::string& sequence,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    SequenceWithAnnotation(name, sequence, alpha),
    qualScores_(new SequenceQuality(sequence.size(), false))
  {
    addAnnotation(qualScores_);
  }
 
  SequenceWithQuality(
      const std::string& name,
      const std::string& sequence,
      const Comments& comments,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    SequenceWithAnnotation(name, sequence, comments, alpha),
    qualScores_(new SequenceQuality(sequence.size(), false))
  {
    addAnnotation(qualScores_);
  }
 
  SequenceWithQuality(
      const std::string& name,
      const std::string& sequence,
      const std::vector<int>& quality,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    SequenceWithAnnotation(name, sequence, alpha),
    qualScores_(new SequenceQuality(quality, false))
  {
    addAnnotation(qualScores_);
  }
 
  SequenceWithQuality(
      const std::string& name,
      const std::string& sequence,
      const std::vector<int>& quality,
      const Comments& comments,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    SequenceWithAnnotation(name, sequence, comments, alpha),
    qualScores_(new SequenceQuality(quality, false))
  {
    addAnnotation(qualScores_);
  }
 
  SequenceWithQuality(
      const std::string& name,
      const std::vector<int>& sequence,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    SequenceWithAnnotation(name, sequence, alpha),
    qualScores_(new SequenceQuality(sequence.size(), false))
  {
    addAnnotation(qualScores_);
  }
 
  SequenceWithQuality(
      const std::string& name,
      const std::vector<int>& sequence,
      const Comments& comments,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    SequenceWithAnnotation(name, sequence, comments, alpha),
    qualScores_(new SequenceQuality(sequence.size(), false))
  {
    addAnnotation(qualScores_);
  }
 
  SequenceWithQuality(
      const std::string& name,
      const std::vector<int>& sequence,
      const std::vector<int>& quality,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    SequenceWithAnnotation(name, sequence, alpha),
    qualScores_(new SequenceQuality(quality, false))
  {
    addAnnotation(qualScores_);
  }
 
  SequenceWithQuality(
      const std::string& name,
      const std::vector<int>& sequence,
      const std::vector<int>& quality,
      const Comments& comments,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    SequenceWithAnnotation(name, sequence, comments, alpha),
    qualScores_(new SequenceQuality(quality, false))
  {
    addAnnotation(qualScores_);
  }
 
  SequenceWithQuality(const Sequence& s) :
    AbstractTemplateSymbolList<int>(s.getAlphabet()),
    SequenceWithAnnotation(s), qualScores_(new SequenceQuality(s.size(), false))
  {
    addAnnotation(qualScores_);
  }
 
  SequenceWithQuality(
      const Sequence& s,
      const std::vector<int>& sc) :
    AbstractTemplateSymbolList<int>(sc, s.getAlphabet()),
    SequenceWithAnnotation(s),
    qualScores_(new SequenceQuality(sc, false))
  {
    addAnnotation(qualScores_);
  }
 
  virtual ~SequenceWithQuality() {}
  SequenceWithQuality(const SequenceWithQuality& sequence) :
    AbstractTemplateSymbolList<int>(sequence.getAlphabet()),
    SequenceWithAnnotation(sequence), qualScores_(nullptr)
  {
    qualScores_.reset(dynamic_cast<SequenceQuality*>(&annotation(SequenceQuality::QUALITY_SCORE)));
  }
 
  SequenceWithQuality& operator=(const SequenceWithQuality& sequence)
  {
    SequenceWithAnnotation::operator=(sequence);
    qualScores_.reset(dynamic_cast<SequenceQuality*>(&annotation(SequenceQuality::QUALITY_SCORE)));
    return *this;
  }
 
  SequenceWithQuality* clone() const override { return new SequenceWithQuality(*this); }
  void setQuality(size_t pos, int quality)
  {
    qualScores_->setScore(pos, quality);
  }
 
  int getQuality(size_t pos) const
  {
    if (pos >= qualScores_->getSize())
      throw IndexOutOfBoundsException("SequenceWithQuality::getQuality: pos out of bounds", pos, 0, qualScores_->getSize() - 1);
    return (*qualScores_)[pos];
  }
 
  void setQualities(const std::vector<int>& quality)
  {
    if (quality.size() != qualScores_->getSize())
      throw DimensionException("SequenceWithQuality::setQualities: quality must fit sequence size", quality.size(), qualScores_->getSize());
    qualScores_->setScores(quality);
  }
 
  const std::vector<int>& getQualities() const
  {
    return qualScores_->getScores();
  }
 
  using SequenceWithAnnotation::append;
 
  virtual void append(
      const std::vector<int>& content,
      const std::vector<int>& qualities)
  {
    if (content.size() != qualities.size())
      throw DimensionException("SequenceWithQuality::append: qualities must fit content size", qualities.size(), content.size());
    size_t pos = qualScores_->getSize();
    append(content); // This automatically extend scores array with default values through the listener
    // Update scores:
    qualScores_->setScores(pos, qualities);
  }
 
  virtual void append(
      const std::vector<std::string>& content,
      const std::vector<int>& qualities)
  {
    if (content.size() != qualities.size())
      throw DimensionException("SequenceWithQuality::append: qualities must fit content size", qualities.size(), content.size());
    size_t pos = qualScores_->getSize();
    SequenceWithAnnotation::append(content); // This automatically extend scores array with default values through the listener
    // Update scores:
    qualScores_->setScores(pos, qualities);
  }
 
  virtual void append(
      const std::string& content,
      const std::vector<int>& qualities)
  {
    if (content.size() / this->getAlphabet()->getStateCodingSize()
        != qualities.size())
      throw DimensionException("SequenceWithQuality::append: qualities must fit content size", qualities.size(), content.size() / this->getAlphabet()->getStateCodingSize());
    size_t pos = qualScores_->getSize();
    SequenceWithAnnotation::append(content); // This automatically extend scores array with default values through the listener
    // Update scores:
    qualScores_->setScores(pos, qualities);
  }
 
  using SequenceWithAnnotation::addElement;
 
  using IntCoreSymbolListInterface::addElement;
  void addElement(const std::string& c, int q)
  {
    SequenceWithAnnotation::addElement(c);
    qualScores_->setScore(size() - 1, q);
  }
 
  void addElement(
      size_t pos, const std::string& c, int q)
  {
    SequenceWithAnnotation::addElement(pos, c);
    qualScores_->setScore(pos, q);
  }
 
  using EventDrivenIntSymbolList::addElement;
 
  void addElement(int v, int q)
  {
    EventDrivenIntSymbolList::addElement(v);
    qualScores_->setScore(size() - 1, q);
  }
 
  void addElement(size_t pos, int v, int q)
  {
    IntSymbolList::addElement(pos, v);
    qualScores_->setScore(pos, q);
  }
 
  // const Comments& getComments() const { return Commentable::getComments(); }
 
  // void setComments(const Comments& comments) { Commentable::setComments(comments); }
 
  // void clearComments() { Commentable::clearComments(); }
};
} // end of namespace bpp.
#endif // BPP_SEQ_SEQUENCEWITHQUALITY_H