SequenceWithAnnotation.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_SEQUENCEWITHANNOTATION_H
#define BPP_SEQ_SEQUENCEWITHANNOTATION_H
 
 
#include "CoreSequence.h"
#include "IntSymbolList.h"
#include "Sequence.h"
 
// From the STL:
#include <string>
#include <vector>
 
namespace bpp
{
class SequenceWithAnnotation;
 
class SequenceAnnotation :
  public virtual IntSymbolListListener
{
public:
  virtual SequenceAnnotation* clone() const override = 0;
 
  virtual void init(const Sequence& seq) = 0;
 
  virtual const std::string& getType() const = 0;
 
  virtual bool isValidWith(const SequenceWithAnnotation& sequence, bool throwException = true) const = 0;
 
  virtual bool merge(const SequenceAnnotation& anno) = 0;
 
  virtual std::unique_ptr<SequenceAnnotation> getPartAnnotation(size_t pos, size_t len) const = 0;
};
 
class SequenceWithAnnotation :
  public virtual SequenceInterface,
  public AbstractCoreSequence,
  public EventDrivenIntSymbolList
{
public:
  SequenceWithAnnotation(std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList(alpha),
    AbstractCoreSequence(""),
    EventDrivenIntSymbolList(alpha)
  {}
 
 
  SequenceWithAnnotation(
      const std::string& name,
      const std::string& sequence,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList(alpha),
    AbstractCoreSequence(name),
    EventDrivenIntSymbolList(alpha)
  {
    if (sequence != "")
      setContent(sequence);
  }
 
 
  SequenceWithAnnotation(
      const std::string& name,
      const std::string& sequence,
      const Comments& comments,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList(alpha),
    AbstractCoreSequence(name, comments),
    EventDrivenIntSymbolList(alpha)
  {
    if (sequence != "")
      setContent(sequence);
  }
 
 
  SequenceWithAnnotation(
      const std::string& name,
      const std::vector<std::string>& sequence,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList(alpha),
    AbstractCoreSequence(name),
    EventDrivenIntSymbolList(sequence, alpha)
  {}
 
 
  SequenceWithAnnotation(
      const std::string& name,
      const std::vector<std::string>& sequence,
      const Comments& comments,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList(alpha),
    AbstractCoreSequence(name, comments),
    EventDrivenIntSymbolList(sequence, alpha)
  {}
 
 
  SequenceWithAnnotation(
      const std::string& name,
      const std::vector<int>& sequence,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList(sequence, alpha),
    AbstractCoreSequence(name),
    EventDrivenIntSymbolList(sequence, alpha)
  {}
 
 
  SequenceWithAnnotation(
      const std::string& name,
      const std::vector<int>& sequence,
      const Comments& comments,
      std::shared_ptr<const Alphabet>& alpha) :
    AbstractTemplateSymbolList(sequence, alpha),
    AbstractCoreSequence(name, comments),
    EventDrivenIntSymbolList(sequence, alpha)
  {}
 
 
  SequenceWithAnnotation(const Sequence& s) :
    AbstractTemplateSymbolList(s.getContent(), s.getAlphabet()),
    AbstractCoreSequence(s.getName(), s.getComments()),
    EventDrivenIntSymbolList(s.getContent(), s.getAlphabet())
  {}
 
 
  SequenceWithAnnotation(const SequenceWithAnnotation& s) :
    AbstractTemplateSymbolList(s.getContent(), s.getAlphabet()),
    AbstractCoreSequence(s.getName(), s.getComments()),
    EventDrivenIntSymbolList(s.getContent(), s.getAlphabet())
  {}
 
 
  SequenceWithAnnotation& operator=(const Sequence& s)
  {
    setContent(s.getContent());
    setName(s.getName());
    setComments(s.getComments());
    return *this;
  }
 
 
  SequenceWithAnnotation& operator=(const SequenceWithAnnotation& s)
  {
    AbstractCoreSequence::operator=(s);
    EventDrivenIntSymbolList::operator=(s);
    return *this;
  }
 
 
  virtual ~SequenceWithAnnotation() {}
 
public:
  SequenceWithAnnotation* clone() const override { return new SequenceWithAnnotation(*this); }
  virtual void setContent(const std::string& sequence) override;
 
  void setContent(const std::vector<std::string>& list) override
  {
    EventDrivenIntSymbolList::setContent(list);
  }
 
  void setContent(const std::vector<int>& list) override
  {
    EventDrivenIntSymbolList::setContent(list);
  }
 
  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;
 
  virtual void addAnnotation(std::shared_ptr<SequenceAnnotation> anno)
  {
    anno->isValidWith(*this);
    addIntSymbolListListener(anno);
  }
 
  virtual bool hasAnnotation(const std::string& type) const
  {
    for (size_t i = 0; i < getNumberOfListeners(); ++i)
    {
      const auto& lstn = listener(i);
      try
      {
        const SequenceAnnotation& anno = dynamic_cast<const SequenceAnnotation&>(lstn);
        if (anno.getType() == type) return true;
      }
      catch (std::bad_cast&) {}
    }
    return false;
  }
 
 
  virtual const SequenceAnnotation& annotation(const std::string& type) const
  {
    for (size_t i = 0; i < getNumberOfListeners(); ++i)
    {
      const auto& lstn = listener(i);
      try
      {
        const SequenceAnnotation& anno = dynamic_cast<const SequenceAnnotation&>(lstn);
        if (anno.getType() == type) return anno;
      }
      catch (std::bad_cast&) {}
    }
    throw Exception("SequenceWithAnnotation::getAnnotation. No annotation found with type '" + type + "'.");
  }
 
  virtual SequenceAnnotation& annotation(const std::string& type)
  {
    for (size_t i = 0; i < getNumberOfListeners(); ++i)
    {
      auto& lstn = listener(i);
      try
      {
        SequenceAnnotation& anno = dynamic_cast<SequenceAnnotation&>(lstn);
        if (anno.getType() == type) return anno;
      }
      catch (std::bad_cast&) {}
    }
    throw Exception("SequenceWithAnnotation::getAnnotation. No annotation found with type '" + type + "'.");
  }
 
  virtual std::vector<std::string> getAnnotationTypes() const;
 
  virtual void merge(const SequenceWithAnnotation& swa);
};
} // end of namespace bpp.
#endif // BPP_SEQ_SEQUENCEWITHANNOTATION_H