Sequence.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_SEQUENCE_H
#define BPP_SEQ_SEQUENCE_H
 
 
#include "CoreSequence.h"
#include "IntSymbolList.h"
#include "SequenceExceptions.h"
 
// From the STL:
#include <string>
#include <vector>
 
namespace bpp
{
class SequenceInterface :
  public virtual CoreSequenceInterface,
  public virtual IntSymbolListInterface
{
public:
  typedef int ElementType;
 
public:
  virtual ~SequenceInterface() {}
 
public:
  SequenceInterface* clone() const override = 0;
 
 
  virtual void setContent(const std::string& sequence) = 0;
 
  virtual void setContent(const std::vector<std::string>& list) override = 0;
 
  virtual void setContent(const std::vector<int>& list) override = 0;
 
  virtual void append(const SequenceInterface& seq) = 0;
 
  virtual void append(const std::vector<int>& content) = 0;
 
  virtual void append(const std::vector<std::string>& content) = 0;
 
  virtual void append(const std::string& content) = 0;
 
};
 
 
class Sequence :
  public virtual SequenceInterface,
  public AbstractCoreSequence,
  public IntSymbolList
{
public:
  Sequence(std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    AbstractCoreSequence(),
    IntSymbolList(alpha)
  {}
 
 
  Sequence(
      const std::string& name,
      const std::string& sequence,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    AbstractCoreSequence(name),
    IntSymbolList(alpha)
  {
    if (sequence != "")
      setContent(sequence);
  }
 
 
  Sequence(
      const std::string& name,
      const std::string& sequence,
      const Comments& comments,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    AbstractCoreSequence(name, comments),
    IntSymbolList(alpha)
  {
    if (sequence != "")
      setContent(sequence);
  }
 
 
  Sequence(
      const std::string& name,
      const std::vector<std::string>& sequence,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    AbstractCoreSequence(name),
    IntSymbolList(sequence, alpha)
  {}
 
 
  Sequence(
      const std::string& name,
      const std::vector<std::string>& sequence,
      const Comments& comments,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    AbstractCoreSequence(name, comments),
    IntSymbolList(sequence, alpha)
  {}
 
 
  Sequence(
      const std::string& name,
      const std::vector<int>& sequence,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(sequence, alpha),
    AbstractCoreSequence(name),
    IntSymbolList(sequence, alpha)
  {}
 
 
  Sequence(
      const std::string& name,
      const std::vector<int>& sequence,
      const Comments& comments,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList<int>(sequence, alpha),
    AbstractCoreSequence(name, comments),
    IntSymbolList(sequence, alpha)
  {}
 
 
  Sequence(const SequenceInterface& s) :
    AbstractTemplateSymbolList<int>(s.getContent(), s.getAlphabet()),
    AbstractCoreSequence(s),
    IntSymbolList(s.getContent(), s.getAlphabet())
  {}
 
 
  Sequence(const Sequence& s) :
    AbstractTemplateSymbolList<int>(s.getContent(), s.getAlphabet()),
    AbstractCoreSequence(s),
    IntSymbolList(s.getContent(), s.getAlphabet())
  {}
 
 
  Sequence& operator=(const SequenceInterface& s)
  {
    AbstractCoreSequence::operator=(s);
    setContent(s.getContent());
    return *this;
  }
 
 
  Sequence& operator=(const Sequence& s)
  {
    AbstractCoreSequence::operator=(s);
    IntSymbolList::operator=(s);
    return *this;
  }
 
 
  virtual ~Sequence() {}
 
public:
  Sequence* clone() const override { return new Sequence(*this); }
  void setContent(const std::string& sequence) override;
 
  using IntSymbolList::addElement;
 
  void setContent(const std::vector<std::string>& list) override
  {
    IntSymbolList::setContent(list);
  }
 
  void setContent(const std::vector<int>& list) override
  {
    IntSymbolList::setContent(list);
  }
 
  std::string toString() const override
  {
    return IntSymbolList::toString();
  }
 
  std::string getChar(size_t pos) const override
  {
    return IntSymbolList::getChar(pos);
  }
 
  void setToSizeR(size_t newSize) override;
 
  void setToSizeL(size_t newSize) override;
 
  void append(const SequenceInterface& seq) override;
 
  void append(const std::vector<int>& content) override;
 
  void append(const std::vector<std::string>& content) override;
 
  void append(const std::string& content) override;
 
  double getStateValueAt(size_t sitePosition, int state) const override
  {
    if (sitePosition  >= size()) throw IndexOutOfBoundsException("BasicSequence::getStateValueAt.", sitePosition, 0, size() - 1);
    return getAlphabet()->isResolvedIn((*this)[sitePosition], state) ? 1. : 0.;
  }
};
} // end of namespace bpp.
#endif // BPP_SEQ_SEQUENCE_H