IntSymbolList.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_INTSYMBOLLIST_H
#define BPP_SEQ_INTSYMBOLLIST_H
 
#include <Bpp/Clonable.h>
 
#include "Alphabet/Alphabet.h"
#include "SymbolList.h"
#include "StringSequenceTools.h"
 
// From the STL:
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
 
namespace bpp
{
class IntSymbolListInterface :
  public virtual IntCoreSymbolListInterface
{
public:
  typedef int SymbolType;
 
public:
  IntSymbolListInterface() {}
 
  // Class destructor
  virtual ~IntSymbolListInterface() {}
 
public:
  using IntCoreSymbolListInterface::setContent;
 
  virtual void setContent(const std::vector<std::string>& list) = 0;
 
  using IntCoreSymbolListInterface::addElement;
  using IntCoreSymbolListInterface::setElement;
 
  virtual void addElement(const std::string& c) = 0;
 
  virtual void addElement(size_t pos, const std::string& c) = 0;
 
  virtual void setElement(size_t pos, const std::string& c) = 0;
 
  virtual std::string getChar(size_t pos) const = 0;
 
};
 
 
class IntSymbolList :
  public virtual IntSymbolListInterface,
  public virtual AbstractTemplateSymbolList<int> // This needs to be virtual because of diamond inheritance
{
public:
  IntSymbolList(std::shared_ptr<const Alphabet> alpha) :
    AbstractTemplateSymbolList<int>(alpha)
  {}
 
  IntSymbolList(const std::vector<std::string>& list, std::shared_ptr<const Alphabet> alpha) :
    AbstractTemplateSymbolList<int>(alpha)
  {
    setContent(list);
  }
 
  IntSymbolList(const std::vector<int>& list, std::shared_ptr<const Alphabet> alpha) :
    AbstractTemplateSymbolList<int>(list, alpha)
  {}
 
  IntSymbolList(const IntSymbolList& list) :
    AbstractTemplateSymbolList<int>(list)
  {}
 
  IntSymbolList& operator=(const IntSymbolListInterface& list);
 
  IntSymbolList& operator=(const IntSymbolList& list)
  {
    AbstractTemplateSymbolList<int>::operator=(list);
    return *this;
  }
 
  IntSymbolList* clone() const override { return new IntSymbolList(*this); }
  // Class destructor
  virtual ~IntSymbolList() {}
 
public:
  void setContent(const std::vector<int>& list) override;
 
  void setContent(const std::vector<std::string>& list) override;
 
  std::string toString() const override
  {
    auto alphaPtr = getAlphabet();
    return StringSequenceTools::decodeSequence(content_, alphaPtr);
  }
 
  void addElement(const std::string& c) override
  {
    content_.push_back(getAlphabet()->charToInt(c));
  }
 
  using AbstractTemplateSymbolList::addElement;
 
  void addElement(size_t pos, const std::string& c) override
  {
    if (pos >= content_.size())
      throw IndexOutOfBoundsException("IntSymbolList::addElement. Invalid position.", pos, 0, size() - 1);
    content_.insert(content_.begin() + static_cast<ptrdiff_t>(pos), getAlphabet()->charToInt(c));
  }
 
  using AbstractTemplateSymbolList::setElement;
 
  void setElement(size_t pos, const std::string& c) override
  {
    if (pos >= content_.size())
      throw IndexOutOfBoundsException("IntSymbolList::setElement. Invalid position.", pos, 0, size() - 1);
    content_[pos] = getAlphabet()->charToInt(c);
  }
 
  std::string getChar(size_t pos) const override;
 
  double getStateValueAt(size_t siteIndex, int state) const override
  {
    if (siteIndex >= content_.size())
      throw IndexOutOfBoundsException("IntSymbolList::getStateValueAt.", siteIndex, 0, content_.size() - 1);
 
    return getAlphabet()->isResolvedIn(content_[siteIndex], state) ? 1. : 0.;
  }
 
  double operator()(size_t siteIndex, int state) const override
  {
    return getAlphabet()->isResolvedIn(content_[siteIndex], state) ? 1. : 0.;
  }
};
 
typedef CoreSymbolListListener<int> IntSymbolListListener;
 
typedef CoreSymbolListEditionEvent<int> IntSymbolListEditionEvent;
 
typedef CoreSymbolListInsertionEvent<int> IntSymbolListInsertionEvent;
 
typedef CoreSymbolListDeletionEvent<int> IntSymbolListDeletionEvent;
 
typedef CoreSymbolListSubstitutionEvent<int> IntSymbolListSubstitutionEvent;
 
class EventDrivenIntSymbolList :
  public IntSymbolList,
  public AbstractTemplateEventDrivenSymbolList<int>
{
public:
  EventDrivenIntSymbolList(std::shared_ptr<const Alphabet> alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    IntSymbolList(alpha),
    AbstractTemplateEventDrivenSymbolList<int>(alpha)
  {}
 
  EventDrivenIntSymbolList(
      const std::vector<std::string>& list,
      std::shared_ptr<const Alphabet> alpha) :
    AbstractTemplateSymbolList<int>(alpha),
    IntSymbolList(alpha),
    AbstractTemplateEventDrivenSymbolList<int>(alpha)
  {
    setContent(list);
  }
 
 
  EventDrivenIntSymbolList(
      const std::vector<int>& list,
      std::shared_ptr<const Alphabet> alpha) :
    AbstractTemplateSymbolList<int>(list, alpha),
    IntSymbolList(list, alpha),
    AbstractTemplateEventDrivenSymbolList<int>(list, alpha)
  {}
 
 
  EventDrivenIntSymbolList(const IntSymbolList& list) :
    AbstractTemplateSymbolList<int>(list),
    IntSymbolList(list),
    AbstractTemplateEventDrivenSymbolList<int>(list)
  {}
 
  EventDrivenIntSymbolList(const EventDrivenIntSymbolList& list) :
    AbstractTemplateSymbolList<int>(list),
    IntSymbolList(list),
    AbstractTemplateEventDrivenSymbolList<int>(list)
  {}
 
 
  EventDrivenIntSymbolList& operator=(const IntSymbolList& list)
  {
    AbstractTemplateSymbolList<int>::operator=(list);
    IntSymbolList::operator=(list);
    AbstractTemplateEventDrivenSymbolList<int>::operator=(list);
    return *this;
  }
 
 
  EventDrivenIntSymbolList& operator=(const EventDrivenIntSymbolList& list)
  {
    AbstractTemplateSymbolList<int>::operator=(list);
    IntSymbolList::operator=(list);
    AbstractTemplateEventDrivenSymbolList<int>::operator=(list);
    return *this;
  }
 
  EventDrivenIntSymbolList* clone() const override { return new EventDrivenIntSymbolList(*this); }
  virtual ~EventDrivenIntSymbolList() {}
 
public:
  virtual void setContent(const std::vector<std::string>& list) override;
 
  void setContent(const std::vector<int>& list) override;
 
  virtual std::string toString() const override;
 
  using AbstractTemplateEventDrivenSymbolList<int>::addElement;
 
  virtual void addElement(const std::string& c) override;
 
  virtual void addElement(size_t pos, const std::string& c) override;
 
  using AbstractTemplateEventDrivenSymbolList<int>::setElement;
 
  virtual void setElement(size_t pos, const std::string& c) override;
 
  virtual std::string getChar(size_t pos) const override;
 
  void addIntSymbolListListener(std::shared_ptr<IntSymbolListListener> listener)
  {
    addCoreSymbolListListener(std::move(listener));
  }
 
protected:
  virtual void beforeSequenceChanged(const IntSymbolListEditionEvent& event) override {}
  virtual void afterSequenceChanged(const IntSymbolListEditionEvent& event) override {}
  virtual void beforeSequenceInserted(const IntSymbolListInsertionEvent& event) override {}
  virtual void afterSequenceInserted(const IntSymbolListInsertionEvent& event) override {}
  virtual void beforeSequenceDeleted(const IntSymbolListDeletionEvent& event) override {}
  virtual void afterSequenceDeleted(const IntSymbolListDeletionEvent& event) override {}
  virtual void beforeSequenceSubstituted(const IntSymbolListSubstitutionEvent& event) override {}
  virtual void afterSequenceSubstituted(const IntSymbolListSubstitutionEvent& event) override {}
};
} // end of namespace bpp.
#endif // BPP_SEQ_INTSYMBOLLIST_H