AlphabetExceptions.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_ALPHABET_ALPHABETEXCEPTIONS_H
#define BPP_SEQ_ALPHABET_ALPHABETEXCEPTIONS_H
 
#include <Bpp/Exceptions.h>
#include "Alphabet.h"
 
// From the STL:
#include <vector>
#include <memory>
 
namespace bpp
{
class AlphabetException :
  public Exception
{
private:
  const Alphabet* alphabet_;
 
public:
  AlphabetException(const std::string& text, const Alphabet* alpha);
 
  AlphabetException(const std::string& text, std::shared_ptr<const Alphabet> alpha);
 
  AlphabetException(const AlphabetException& ae) :
    Exception(ae),
    alphabet_(ae.alphabet_)
  {}
 
  AlphabetException& operator=(const AlphabetException& ae)
  {
    Exception::operator=(ae);
    alphabet_ = ae.alphabet_;
    return *this;
  }
 
  virtual ~AlphabetException() {}
 
public:
  virtual const Alphabet* getAlphabet() const { return alphabet_; }
};
 
class BadCharException :
  public AlphabetException
{
protected:
  std::string c_;
 
public:
  BadCharException(const std::string& badChar, const std::string& text, const Alphabet* alpha);
 
  BadCharException(const std::string& badChar, const std::string& text, std::shared_ptr<const Alphabet> alpha);
 
  virtual ~BadCharException() {}
 
public:
  virtual std::string getBadChar() const;
};
 
class BadIntException :
  public AlphabetException
{
protected:
  int i_;
 
public:
  BadIntException(int badInt, const std::string& text, const Alphabet* alpha);
 
  BadIntException(int badInt, const std::string& text, std::shared_ptr<const Alphabet> alpha);
 
  virtual ~BadIntException() {}
 
public:
  virtual int getBadInt() const;
};
 
class AlphabetMismatchException :
  public Exception
{
private:
  const Alphabet* alphabet1_;
  const Alphabet* alphabet2_;
 
public:
  AlphabetMismatchException(
      const std::string& text,
      const Alphabet* alpha1,
      const Alphabet* alpha2);
 
  AlphabetMismatchException(
      const std::string& text,
      std::shared_ptr<const Alphabet> alpha1,
      std::shared_ptr<const Alphabet> alpha2);
 
  AlphabetMismatchException(const AlphabetMismatchException& ame) :
    Exception(ame),
    alphabet1_(ame.alphabet1_),
    alphabet2_(ame.alphabet2_)
  {}
 
  AlphabetMismatchException& operator=(const AlphabetMismatchException& ame)
  {
    Exception::operator=(ame);
    alphabet1_ = ame.alphabet1_;
    alphabet2_ = ame.alphabet2_;
    return *this;
  }
 
 
  virtual ~AlphabetMismatchException() {}
 
public:
  const Alphabet* getFirstAlphabet() const { return alphabet1_; }
 
  const Alphabet* getSecondAlphabet() const { return alphabet2_; }
};
 
class CharStateNotSupportedException :
  public AlphabetException
{
public:
  CharStateNotSupportedException(const std::string& text, const Alphabet* alpha);
 
  CharStateNotSupportedException(const std::string& text, std::shared_ptr<const Alphabet> alpha);
 
  virtual ~CharStateNotSupportedException() {}
};
} // end of namespace bpp.
#endif // BPP_SEQ_ALPHABET_ALPHABETEXCEPTIONS_H