NucleicAlphabet.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_ALPHABET_NUCLEICALPHABET_H
#define BPP_SEQ_ALPHABET_NUCLEICALPHABET_H
 
#include <iostream>
#include <map>
#include <typeinfo>
 
#include "LetterAlphabet.h"
#include "NucleicAlphabetState.h"
 
namespace bpp
{
class NucleicAlphabet :
  public LetterAlphabet
{
private:
  std::map<int, size_t> binCodes_;
  void updateBinMaps_(size_t pos, const NucleicAlphabetState& st)
  {
    if (binCodes_.find(st.getBinaryCode()) == binCodes_.end())
      binCodes_[st.getBinaryCode()] = pos;
  }
 
public:
  NucleicAlphabet() : LetterAlphabet(), binCodes_() {}
 
  NucleicAlphabet(const NucleicAlphabet& bia) : LetterAlphabet(bia), binCodes_(bia.binCodes_) {}
 
  NucleicAlphabet& operator=(const NucleicAlphabet& bia)
  {
    LetterAlphabet::operator=(bia);
    binCodes_ = bia.binCodes_;
    return *this;
  }
 
  virtual NucleicAlphabet* clone() const = 0;
 
  virtual ~NucleicAlphabet() {}
 
protected:
  void registerState(AlphabetState* st)
  {
    NucleicAlphabetState* nst = dynamic_cast<NucleicAlphabetState*>(st);
    if (!nst)
      throw Exception("NucleicAlphabet::registerState. Incorrect alphabet type.");
    LetterAlphabet::registerState(nst);
    updateBinMaps_(getNumberOfChars(), *nst);
  }
 
  void setState(size_t pos, AlphabetState* st)
  {
    NucleicAlphabetState* nst = dynamic_cast<NucleicAlphabetState*>(st);
    if (!nst)
      throw Exception("NucleicAlphabet::setState. Incorrect alphabet type.");
    LetterAlphabet::setState(pos, nst);
    updateBinMaps_(pos, *nst);
  }
 
public:
  const NucleicAlphabetState& getStateAt(size_t stateIndex) const
  {
    return dynamic_cast<const NucleicAlphabetState&>(
      AbstractAlphabet::getStateAt(stateIndex)
      );
  }
  NucleicAlphabetState& getStateAt(size_t stateIndex)
  {
    return dynamic_cast<NucleicAlphabetState&>(
      AbstractAlphabet::getStateAt(stateIndex)
      );
  }
  const NucleicAlphabetState& getState(const std::string& letter) const
  {
    return dynamic_cast<const NucleicAlphabetState&>(
      AbstractAlphabet::getState(letter)
      );
  }
  const NucleicAlphabetState& getState(int num) const
  {
    return dynamic_cast<const NucleicAlphabetState&>(
      AbstractAlphabet::getState(num)
      );
  }
  const NucleicAlphabetState& getStateByBinCode(int code) const
  {
    std::map<int, size_t>::const_iterator it = binCodes_.find(code);
    if (it == binCodes_.end())
      throw BadIntException(code, "NucleicAlphabet::getState(unsigned char): Binary code not in alphabet", this);
    return getStateAt(it->second);
  }
 
  int subtract(int s1, int s2) const
  {
    return getStateByBinCode(getState(s1).getBinaryCode() & ~getState(s2).getBinaryCode()).getNum();
  }
 
  std::string subtract(const std::string& s1, const std::string& s2) const
  {
    return intToChar(subtract(charToInt(s1), charToInt(s2)));
  }
 
  int getOverlap(int s1, int s2) const
  {
    return getStateByBinCode(getState(s1).getBinaryCode() & getState(s2).getBinaryCode()).getNum();
  }
 
  std::string getOverlap(const std::string& s1, const std::string& s2) const
  {
    return intToChar(getOverlap(charToInt(s1), charToInt(s2)));
  }
 
public:
  // return 4 : A, C, G, T (or U)
  unsigned int getSize() const { return 4; }
 
  // return 15 : gap isn't included, generic unresolved bases (N, X, ?, O, 0) count for one
  unsigned int getNumberOfTypes() const { return 15; }
 
  int getUnknownCharacterCode() const { return 14; }
 
  bool isUnresolved(int state) const { return state > 3; }
  bool isUnresolved(const std::string& state) const { return charToInt(state) > 3; }
};
} // end of namespace bpp.
#endif // BPP_SEQ_ALPHABET_NUCLEICALPHABET_H