GeneticCode.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_GENETICCODE_GENETICCODE_H
#define BPP_SEQ_GENETICCODE_GENETICCODE_H
 
#include <Bpp/Exceptions.h>
 
#include "../Alphabet/AlphabetTools.h"
#include "../Alphabet/CodonAlphabet.h"
#include "../Alphabet/ProteicAlphabet.h"
#include "../Transliterator.h"
 
namespace bpp
{
class StopCodonException :
  public virtual Exception
{
private:
  std::string codon_;
 
public:
  // Class constructor
  StopCodonException(const std::string& text, const std::string& codon);
 
  // Class destructor
  virtual ~StopCodonException() {}
 
public:
  virtual const std::string& getCodon() const { return codon_; }
};
 
class GeneticCode :
  public AbstractTransliterator,
  public virtual Clonable
{
protected:
  std::shared_ptr<const CodonAlphabet> codonAlphabet_;
  std::shared_ptr<const ProteicAlphabet> proteicAlphabet_;
  std::map<int, int> tlnTable_;
 
public:
  GeneticCode(std::shared_ptr<const NucleicAlphabet> alphabet) :
    AbstractTransliterator(),
    codonAlphabet_(new CodonAlphabet(alphabet)),
    proteicAlphabet_(AlphabetTools::PROTEIN_ALPHABET),
    tlnTable_()
  {}
 
  virtual ~GeneticCode() {}
 
  virtual GeneticCode* clone() const override = 0;
 
public:
  std::shared_ptr<const Alphabet> getSourceAlphabet() const override { return codonAlphabet_; }
 
  const Alphabet& sourceAlphabet() const override { return *codonAlphabet_; }
 
  std::shared_ptr<const Alphabet> getTargetAlphabet() const override { return proteicAlphabet_; }
 
  const Alphabet& targetAlphabet() const override { return *proteicAlphabet_; }
 
  int translate(int state) const override;
 
  std::string translate(const std::string& state) const override;
 
  std::unique_ptr<Sequence> translate(const SequenceInterface& sequence) const override
  {
    return AbstractTransliterator::translate(sequence);
  }
public:
  virtual std::shared_ptr<const CodonAlphabet> getCodonAlphabet() const { return codonAlphabet_; }
 
  virtual const CodonAlphabet& codonAlphabet() const { return *codonAlphabet_; }
 
  virtual std::shared_ptr<const ProteicAlphabet> getProteicAlphabet() const { return proteicAlphabet_; }
 
  virtual const ProteicAlphabet& proteicAlphabet() const { return *proteicAlphabet_; }
 
  virtual size_t getNumberOfStopCodons() const = 0;
 
  virtual std::vector<int> getStopCodonsAsInt() const = 0;
 
  virtual std::vector<std::string> getStopCodonsAsChar() const = 0;
 
  virtual bool isStop(int state) const = 0;
 
  virtual bool isStop(const std::string& state) const = 0;
 
  virtual bool isStart(int state) const
  {
    // Test:
    codonAlphabet_->intToChar(state); // throw exception if invalid state!
    return state == 14;
  }
 
  virtual bool isStart(const std::string& state) const
  {
    return isStart(codonAlphabet_->charToInt(state));
  }
 
  virtual bool isAltStart(int state) const = 0;
 
  virtual bool isAltStart(const std::string& state) const = 0;
 
  bool areSynonymous(int i, int j) const
  {
    return translate(i) == translate(j);
  }
 
  bool areSynonymous(const std::string& i, const std::string& j) const
  {
    return translate(i) == translate(j);
  }
 
  std::vector<int> getSynonymous(int aminoacid) const;
 
  std::vector<std::string> getSynonymous(const std::string& aminoacid) const;
 
  bool isFourFoldDegenerated(int codon) const;
 
  std::unique_ptr<Sequence> getCodingSequence(const SequenceInterface& sequence, bool lookForInitCodon = false, bool includeInitCodon = false) const;
};
} // end of namespace bpp.
#endif // BPP_SEQ_GENETICCODE_GENETICCODE_H