AlphabetTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_ALPHABET_ALPHABETTOOLS_H
#define BPP_SEQ_ALPHABET_ALPHABETTOOLS_H
 
#include <Bpp/Numeric/VectorTools.h>
#include <typeinfo>
 
#include "BinaryAlphabet.h"
#include "IntegerAlphabet.h"
#include "CodonAlphabet.h"
#include "DNA.h"
#include "DefaultAlphabet.h"
#include "ProteicAlphabet.h"
#include "RNA.h"
#include "RNY.h"
#include "AllelicAlphabet.h"
#include "WordAlphabet.h"
 
// From the STL :
#include <string>
#include <vector>
 
namespace bpp
{
class AlphabetTools
{
public:
  static std::shared_ptr<const DNA> DNA_ALPHABET;
  static std::shared_ptr<const RNA> RNA_ALPHABET;
  static std::shared_ptr<const CodonAlphabet> DNA_CODON_ALPHABET;
  static std::shared_ptr<const CodonAlphabet> RNA_CODON_ALPHABET;
  static std::shared_ptr<const ProteicAlphabet> PROTEIN_ALPHABET;
  static std::shared_ptr<const DefaultAlphabet> DEFAULT_ALPHABET;
 
public:
  AlphabetTools() {}
  virtual ~AlphabetTools() {}
 
public:
  static int getType(char state);
 
  static bool checkAlphabetCodingSize(const Alphabet& alphabet);
 
  static bool checkAlphabetCodingSize(const Alphabet* alphabet);
 
  static unsigned int getAlphabetCodingSize(const Alphabet& alphabet);
 
  static unsigned int getAlphabetCodingSize(const Alphabet* alphabet);
 
  static bool isNucleicAlphabet(const Alphabet& alphabet) { return alphabetInheritsFrom<NucleicAlphabet>(alphabet); }
 
  static bool isDNAAlphabet(const Alphabet& alphabet) { return alphabetInheritsFrom<DNA>(alphabet); }
 
  static bool isRNAAlphabet(const Alphabet& alphabet) { return alphabetInheritsFrom<RNA>(alphabet); }
 
  static bool isProteicAlphabet(const Alphabet& alphabet) { return alphabetInheritsFrom<ProteicAlphabet>(alphabet); }
 
  static bool isCodonAlphabet(const Alphabet& alphabet) { return alphabetInheritsFrom<CodonAlphabet>(alphabet); }
 
  static bool isWordAlphabet(const Alphabet& alphabet) { return alphabetInheritsFrom<CoreWordAlphabet>(alphabet); }
 
  static bool isRNYAlphabet(const Alphabet& alphabet) { return alphabetInheritsFrom<RNY>(alphabet); }
 
  static bool isBinaryAlphabet(const Alphabet& alphabet) { return alphabetInheritsFrom<BinaryAlphabet>(alphabet); }
 
  static bool isIntegerAlphabet(const Alphabet& alphabet) { return alphabetInheritsFrom<IntegerAlphabet>(alphabet); }
 
  static bool isDefaultAlphabet(const Alphabet& alphabet) { return alphabetInheritsFrom<DefaultAlphabet>(alphabet); }
 
  static bool isAllelicAlphabet(const Alphabet& alphabet) { return alphabetInheritsFrom<AllelicAlphabet>(alphabet); }
 
  static bool match(std::shared_ptr<const Alphabet> alphabet, int i, int j)
  {
    std::vector<int> a = alphabet->getAlias(i);
    std::vector<int> b = alphabet->getAlias(j);
    std::vector<int> u = VectorTools::vectorIntersection(a, b);
    return u.size() > 0;
  }
 
private:
  template<class Y>
  static bool alphabetInheritsFrom(const Alphabet& alphabet)
  {
    try
    {
      std::ignore = dynamic_cast<const Y&>(alphabet);
      return true;
    }
    catch (std::exception& e)
    {
      return false;
    }
  }
};
} // end of namespace bpp.
#endif // BPP_SEQ_ALPHABET_ALPHABETTOOLS_H