CodonAlphabet.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_ALPHABET_CODONALPHABET_H
#define BPP_SEQ_ALPHABET_CODONALPHABET_H
 
 
#include "NucleicAlphabet.h"
#include "WordAlphabet.h"
 
// From the STL:
#include <string>
#include <memory>
 
namespace bpp
{
class CodonAlphabet :
  public virtual CoreWordAlphabet,
  public AbstractAlphabet
{
protected:
  std::shared_ptr<const NucleicAlphabet> nAlph_;
 
public:
  // Constructor and destructor.
 
  CodonAlphabet(std::shared_ptr<const NucleicAlphabet> alpha) :
    AbstractAlphabet(),
    nAlph_(alpha)
  {
    build_();
  }
 
  CodonAlphabet(const CodonAlphabet& bia) :
    AbstractAlphabet(bia),
    nAlph_(bia.nAlph_)
  {}
 
  CodonAlphabet& operator=(const CodonAlphabet& bia)
  {
    AbstractAlphabet::operator=(bia);
    nAlph_ = bia.nAlph_;
 
    return *this;
  }
 
  CodonAlphabet* clone() const override
  {
    return new CodonAlphabet(*this);
  }
 
  virtual ~CodonAlphabet()
  {}
 
  std::string getAlphabetType() const override
  {
    return "Codon(letter=" + nAlph_->getAlphabetType() + ")";
  }
 
private:
  bool containsUnresolved(const std::string& state) const override;
 
  bool containsGap(const std::string& state) const override;
 
  void build_();
 
public:
  unsigned int getNumberOfTypes() const override { return 65; }
 
  unsigned int getSize() const override
  {
    return 64;
  }
 
  int getUnknownCharacterCode() const override
  {
    return 64;
  }
 
  bool isUnresolved(int state) const override
  {
    return state >= 64;
  }
 
  bool isUnresolved(const std::string& state) const override
  {
    return isUnresolved(charToInt(state));
  }
 
  bool isResolvedIn(int state1, int state2) const override;
 
  std::vector<int> getAlias(int state) const override;
 
  std::vector<std::string> getAlias(const std::string& state) const override;
 
  int getGeneric(const std::vector<int>& states) const override
  {
    return states[0];
  }
 
  std::string getGeneric(const std::vector<std::string>& states) const override
  {
    return states[0];
  }
 
  int charToInt(const std::string& state) const override
  {
    if (state.size() != 3)
      throw BadCharException(state, "CodonAlphabet::charToInt", this);
    if (containsUnresolved(state))
      return static_cast<int>(getSize());
    if (containsGap(state))
      return -1;
    else return AbstractAlphabet::charToInt(state);
  }
 
  int getCodon(int pos1, int pos2, int pos3) const
  {
    return (nAlph_->isUnresolved(pos1)
           || nAlph_->isUnresolved(pos2)
           || nAlph_->isUnresolved(pos3)) ? getUnknownCharacterCode()
        : pos3 + 4 * pos2 + 16 * pos1;
  }
 
  std::string getCodon(const std::string& pos1, const std::string& pos2, const std::string& pos3) const
  {
    return pos1 + pos2 + pos3;
  }
 
  int getFirstPosition(int codon) const
  {
    return isUnresolved(codon) ? nAlph_->charToInt("N") : codon / 16;
  }
 
  int getSecondPosition(int codon) const
  {
    return isUnresolved(codon) ? nAlph_->charToInt("N") : (codon / 4) % 4;
  }
 
 
  int getThirdPosition(int codon) const
  {
    return isUnresolved(codon) ? nAlph_->charToInt("N") : codon % 4;
  }
 
  std::string getFirstPosition (const std::string& codon) const
  {
    return codon.substr(0, 1);
  }
 
 
  std::string getSecondPosition(const std::string& codon) const
  {
    return codon.substr(1, 1);
  }
 
 
  std::string getThirdPosition(const std::string& codon) const
  {
    return codon.substr(2, 1);
  }
 
 
  unsigned int getLength() const override
  {
    return 3;
  }
 
  bool hasUniqueAlphabet() const override
  {
    return true;
  }
 
  std::shared_ptr<const Alphabet> getNAlphabet(size_t n) const override
  {
    return nAlph_;
  }
 
  int getWord(const Sequence& seq, size_t pos = 0) const override
  {
    if (seq.size() < pos + 3)
      throw IndexOutOfBoundsException("CodonAlphabet::getWord", pos, 0, seq.size() - 3);
    return getCodon(seq[pos], seq[pos + 1], seq[pos + 2]);
  }
 
  std::string getWord(const std::vector<std::string>& vpos, size_t pos = 0) const override
  {
    if (vpos.size() < pos + 3)
      throw IndexOutOfBoundsException("CodonAlphabet::getWord", pos, 0, vpos.size() - 3);
 
    return getCodon(vpos[pos], vpos[pos + 1], vpos[pos + 2]);
  }
 
  int getWord(const std::vector<int>& vpos, size_t pos = 0) const override
  {
    if (vpos.size() < pos + 3)
      throw IndexOutOfBoundsException("CodonAlphabet::getWord", pos, 0, vpos.size() - 3);
 
    return getCodon(vpos[pos], vpos[pos + 1], vpos[pos + 2]);
  }
 
 
  int getNPosition(int codon, size_t pos) const override
  {
    if (isUnresolved(codon))
      return nAlph_->getUnknownCharacterCode();
    else
      return pos == 0 ? codon / 16 :
             (pos == 1 ? (codon / 4) % 4
                 : codon % 4);
  }
 
  std::vector<int> getPositions(int word) const override
  {
    if (isUnresolved(word))
    {
      int n = nAlph_->getUnknownCharacterCode();
      return std::vector<int>{n, n, n};
    }
    else
      return std::vector<int>{word / 16, (word / 4) % 4, word % 4}
    ;
  }
 
 
  std::string getNPosition(const std::string& codon, size_t pos) const override
  {
    return codon.substr(pos, 1);
  }
 
  std::vector<std::string> getPositions(const std::string& word) const override
  {
    return std::vector<std::string>{word.substr(0, 1), word.substr(1, 1), word.substr(2, 1)};
  }
 
  std::unique_ptr<SequenceInterface> translate(const SequenceInterface& sequence, size_t = 0) const override;
 
  std::unique_ptr<SequenceInterface> reverse(const SequenceInterface& sequence) const override;
 
  /*
   *
   * @}
   */
 
  int getGCinCodon(int codon) const;
 
  std::shared_ptr<const NucleicAlphabet> getNucleicAlphabet() const
  {
    return nAlph_;
  }
 
  unsigned int getStateCodingSize() const override { return 3; }
};
} // end of namespace bpp.
#endif // BPP_SEQ_ALPHABET_CODONALPHABET_H