WordAlphabet.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_ALPHABET_WORDALPHABET_H
#define BPP_SEQ_ALPHABET_WORDALPHABET_H
 
 
#include "AbstractAlphabet.h"
 
// From the STL:
#include <string>
#include <vector>
 
#include "../Sequence.h"
 
namespace bpp
{
class CoreWordAlphabet
{
public:
  CoreWordAlphabet() {}
 
  virtual ~CoreWordAlphabet() {}
 
  virtual unsigned int getLength() const = 0;
 
  virtual unsigned int getSize() const = 0;
 
  virtual bool hasUniqueAlphabet() const = 0;
 
  virtual std::shared_ptr<const Alphabet> getNAlphabet(size_t n) const = 0;
 
  virtual int getWord(const Sequence& seq, size_t pos = 0) const = 0;
 
 
  virtual int getWord(const std::vector<int>& vint, size_t pos = 0) const = 0;
 
  virtual std::string getWord(const std::vector<std::string>& vpos, size_t pos = 0) const = 0;
 
  virtual int getNPosition(int word, size_t n) const = 0;
 
  virtual std::vector<int> getPositions(int word) const = 0;
 
  virtual std::string getNPosition(const std::string& word, size_t n) const = 0;
 
  virtual std::vector<std::string> getPositions(const std::string& word) const = 0;
 
  virtual std::unique_ptr<SequenceInterface> translate(const SequenceInterface& sequence, size_t pos = 0) const = 0;
 
  virtual std::unique_ptr<SequenceInterface> reverse(const SequenceInterface& sequence) const = 0;
 
private:
  virtual bool containsUnresolved(const std::string& state) const = 0;
 
  virtual bool containsGap(const std::string& state) const = 0;
 
};
 
 
class WordAlphabet :
  public virtual CoreWordAlphabet,
  public AbstractAlphabet
{
protected:
  std::vector< std::shared_ptr<const Alphabet>> vAbsAlph_;
 
public:
  // Constructor and destructor.
  WordAlphabet(const std::vector< std::shared_ptr<const Alphabet>>& vAlpha);
 
  WordAlphabet(std::shared_ptr<const Alphabet> pAlpha, size_t num);
 
  WordAlphabet(const WordAlphabet& bia) : AbstractAlphabet(bia), vAbsAlph_(bia.vAbsAlph_) {}
 
  WordAlphabet& operator=(const WordAlphabet& bia)
  {
    AbstractAlphabet::operator=(bia);
    vAbsAlph_ = bia.vAbsAlph_;
    return *this;
  }
 
  WordAlphabet* clone() const override
  {
    return new WordAlphabet(*this);
  }
 
  virtual ~WordAlphabet() {}
 
public:
  std::string getName(const std::string& state) const override;
 
  int charToInt(const std::string& state) const override
  {
    if (state.size() != vAbsAlph_.size())
      throw BadCharException(state, "WordAlphabet::charToInt", this);
    if (containsUnresolved(state))
      return static_cast<int>(getSize());
    if (containsGap(state))
      return -1;
    else return AbstractAlphabet::charToInt(state);
  }
 
  unsigned int getSize() const override
  {
    return getNumberOfChars() - 2;
  }
 
  bool isResolvedIn(int state1, int state2) const override;
 
  bool hasUniqueAlphabet() const override;
 
  unsigned int getLength() const override
  {
    return static_cast<unsigned int>(vAbsAlph_.size());
  }
 
 
  unsigned int getNumberOfTypes() const override
  {
    return getNumberOfChars() - 1;
  }
 
  std::string getAlphabetType() const override;
 
  int getUnknownCharacterCode() const override
  {
    return static_cast<int>(getSize());
  }
 
  bool isUnresolved(int state) const override { return state == getUnknownCharacterCode(); }
  bool isUnresolved(const std::string& state) const override { return charToInt(state) == getUnknownCharacterCode(); }
 
  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;
 
  std::string getGeneric(const std::vector<std::string>& states) const override;
 
private:
  bool containsUnresolved(const std::string& state) const override;
  bool containsGap(const std::string& state) const override;
  void build_();
public:
  std::shared_ptr<const Alphabet> getNAlphabet(size_t n) const override
  {
    if (n >= vAbsAlph_.size())
      throw IndexOutOfBoundsException("WordAlphabet::getNPosition", n, 0, vAbsAlph_.size());
 
    return vAbsAlph_[n];
  }
 
  virtual int getWord(const Sequence& seq, size_t pos = 0) const override;
 
 
  virtual int getWord(const std::vector<int>& vint, size_t pos = 0) const override;
 
  virtual std::string getWord(const std::vector<std::string>& vpos, size_t pos = 0) const override;
 
  int getNPosition(int word, size_t n) const override
  {
    if (n >= vAbsAlph_.size())
      throw IndexOutOfBoundsException("WordAlphabet::getNPosition", n, 0, vAbsAlph_.size());
 
    std::string s = intToChar(word);
    return vAbsAlph_[n]->charToInt(s.substr(n, 1));
  }
 
  std::vector<int> getPositions(int word) const override
  {
    std::string s = intToChar(word);
    std::vector<int> positions;
    for (size_t i = 0; i < s.size(); i++)
    {
      positions.push_back(vAbsAlph_[i]->charToInt(s.substr(i, 1)));
    }
 
    return positions;
  }
  std::string getNPosition(const std::string& word, size_t n) const override
  {
    if (n > vAbsAlph_.size())
      throw BadCharException("", "WordAlphabet::getNPosition", this);
    // Test:
    charToInt(word);
 
    return "" + word.substr(n, 1);
  }
 
 
  std::vector<std::string> getPositions(const std::string& word) const override
  {
    charToInt(word);
    std::vector<std::string> positions;
    for (size_t i = 0; i < word.size(); i++)
    {
      positions.push_back(word.substr(i, 1));
    }
 
    return positions;
  }
 
  std::unique_ptr<SequenceInterface> translate(const SequenceInterface& sequence, size_t = 0) const override;
 
  std::unique_ptr<SequenceInterface> reverse(const SequenceInterface& sequence) const override;
 
  unsigned int getStateCodingSize() const override
  {
    return static_cast<unsigned int>(vAbsAlph_.size());
  }
};
} // end of namespace bpp.
#endif // BPP_SEQ_ALPHABET_WORDALPHABET_H