CoreSymbolList.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_CORESYMBOLLIST_H
#define BPP_SEQ_CORESYMBOLLIST_H
 
#include <Bpp/Clonable.h>
 
#include "Alphabet/Alphabet.h"
 
// From the STL:
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <memory>
 
namespace bpp
{
class CruxSymbolListInterface :
  public virtual Clonable
{
public:
  CruxSymbolListInterface* clone() const override = 0;
  // Class destructor
  virtual ~CruxSymbolListInterface() {}
 
public:
  virtual std::shared_ptr<const Alphabet> getAlphabet() const = 0;
 
  virtual const Alphabet& alphabet() const = 0;
 
  virtual size_t size() const = 0;
 
  virtual std::string toString() const = 0;
 
  virtual void deleteElement(size_t pos) = 0;
 
  virtual void deleteElements(size_t pos, size_t len) = 0;
 
  virtual void shuffle() = 0;
  virtual double getStateValueAt(size_t position, int state) const = 0;
 
  virtual double operator()(size_t position, int state) const = 0;
};
 
 
template<class T>
class TemplateCoreSymbolListInterface :
  public virtual CruxSymbolListInterface
{
public:
  TemplateCoreSymbolListInterface* clone() const override = 0;
  // Class destructor
  virtual ~TemplateCoreSymbolListInterface() {}
 
public:
  virtual void setContent(const std::vector<T>& list) = 0;
 
  virtual const std::vector<T>& getContent() const = 0;
 
  virtual void addElement(const T& c) = 0;
 
  virtual void addElement(size_t pos, const T& c) = 0;
 
  virtual void setElement(size_t pos, const T& c) = 0;
 
  virtual const T& getElement(size_t pos) const = 0;
 
  virtual const T& getValue(size_t pos) const = 0;
 
  virtual const T& operator[](size_t pos) const = 0;
 
  virtual T& operator[](size_t pos) = 0;
 
};
 
using IntCoreSymbolListInterface = TemplateCoreSymbolListInterface<int>;
using ProbabilisticCoreSymbolListInterface = TemplateCoreSymbolListInterface< std::vector<double>>;
 
 
template<class T>
class CoreSymbolListEditionEvent
{
private:
  TemplateCoreSymbolListInterface<T>* list_;
 
public:
  CoreSymbolListEditionEvent(TemplateCoreSymbolListInterface<T>* list) :
    list_(list) {}
 
  CoreSymbolListEditionEvent(const CoreSymbolListEditionEvent<T>& slee) : list_(slee.list_) {}
 
  CoreSymbolListEditionEvent<T>& operator=(const CoreSymbolListEditionEvent<T>& slee)
  {
    list_ = slee.list_;
    return *this;
  }
 
  virtual ~CoreSymbolListEditionEvent() {}
 
public:
  virtual TemplateCoreSymbolListInterface<T>* getCoreSymbolList() { return list_; }
  virtual const TemplateCoreSymbolListInterface<T>* getCoreSymbolList() const { return list_; }
};
 
 
template<class T>
class CoreSymbolListInsertionEvent :
  public CoreSymbolListEditionEvent<T>
{
private:
  size_t pos_;
  size_t len_;
 
public:
  CoreSymbolListInsertionEvent(TemplateCoreSymbolListInterface<T>* list, size_t pos, size_t len) :
    CoreSymbolListEditionEvent<T>(list), pos_(pos), len_(len) {}
 
public:
  virtual size_t getPosition() const { return pos_; }
  virtual size_t getLength() const { return len_; }
};
 
 
template<class T>
class CoreSymbolListDeletionEvent :
  public CoreSymbolListEditionEvent<T>
{
private:
  size_t pos_;
  size_t len_;
 
public:
  CoreSymbolListDeletionEvent(TemplateCoreSymbolListInterface<T>* list, size_t pos, size_t len) :
    CoreSymbolListEditionEvent<T>(list), pos_(pos), len_(len) {}
 
public:
  virtual size_t getPosition() const { return pos_; }
  virtual size_t getLength() const { return len_; }
};
 
 
template<class T>
class CoreSymbolListSubstitutionEvent :
  public CoreSymbolListEditionEvent<T>
{
private:
  size_t begin_;
  size_t end_;
 
public:
  CoreSymbolListSubstitutionEvent(TemplateCoreSymbolListInterface<T>* list, size_t begin, size_t end) :
    CoreSymbolListEditionEvent<T>(list), begin_(begin), end_(end) {}
 
public:
  virtual size_t getBegin() const { return begin_; }
  virtual size_t getEnd() const { return end_; }
};
 
template<class T>
class CoreSymbolListListener :
  public virtual Clonable
{
public:
  virtual ~CoreSymbolListListener() {}
 
  virtual CoreSymbolListListener* clone() const = 0;
 
public:
  virtual bool isRemovable() const = 0;
  virtual bool isShared() const = 0;
  virtual void beforeSequenceChanged(const CoreSymbolListEditionEvent<T>& event) = 0;
  virtual void afterSequenceChanged(const CoreSymbolListEditionEvent<T>& event) = 0;
  virtual void beforeSequenceInserted(const CoreSymbolListInsertionEvent<T>& event) = 0;
  virtual void afterSequenceInserted(const CoreSymbolListInsertionEvent<T>& event) = 0;
  virtual void beforeSequenceDeleted(const CoreSymbolListDeletionEvent<T>& event) = 0;
  virtual void afterSequenceDeleted(const CoreSymbolListDeletionEvent<T>& event) = 0;
  virtual void beforeSequenceSubstituted(const CoreSymbolListSubstitutionEvent<T>& event) = 0;
  virtual void afterSequenceSubstituted(const CoreSymbolListSubstitutionEvent<T>& event) = 0;
};
 
 
template<class T>
class TemplateEventDrivenCoreSymbolListInterface :
  public virtual TemplateCoreSymbolListInterface<T>
{
public:
  virtual TemplateEventDrivenCoreSymbolListInterface* clone() const override = 0;
  // Class destructor
  virtual ~TemplateEventDrivenCoreSymbolListInterface(){}
 
public:
  virtual size_t getNumberOfListeners() const = 0;
 
  virtual const CoreSymbolListListener<T>& listener(size_t i) const = 0;
 
  virtual std::shared_ptr<const CoreSymbolListListener<T>> getListener(size_t i) const = 0;
 
  virtual CoreSymbolListListener<T>& listener(size_t i) = 0;
 
  virtual std::shared_ptr<CoreSymbolListListener<T>> getListener(size_t i) = 0;
 
  virtual void addCoreSymbolListListener(std::shared_ptr<CoreSymbolListListener<T>> listener)  = 0;
 
  virtual void removeCoreSymbolListListener(std::shared_ptr<CoreSymbolListListener<T>> listener) = 0;
 
protected:
  virtual void beforeSequenceChanged(const CoreSymbolListEditionEvent<T>& event) = 0;
 
  virtual void afterSequenceChanged(const CoreSymbolListEditionEvent<T>& event) = 0;
 
  virtual void beforeSequenceInserted(const CoreSymbolListInsertionEvent<T>& event) = 0;
  virtual void afterSequenceInserted(const CoreSymbolListInsertionEvent<T>& event) = 0;
 
  virtual void beforeSequenceDeleted(const CoreSymbolListDeletionEvent<T>& event) = 0;
  virtual void afterSequenceDeleted(const CoreSymbolListDeletionEvent<T>& event) = 0;
 
  virtual void beforeSequenceSubstituted(const CoreSymbolListSubstitutionEvent<T>& event) = 0;
  virtual void afterSequenceSubstituted(const CoreSymbolListSubstitutionEvent<T>& event) = 0;
 
  virtual void fireBeforeSequenceChanged(const CoreSymbolListEditionEvent<T>& event) = 0;
 
  virtual void fireAfterSequenceChanged(const CoreSymbolListEditionEvent<T>& event) = 0;
 
  virtual void fireBeforeSequenceInserted(const CoreSymbolListInsertionEvent<T>& event) = 0;
 
  virtual void fireAfterSequenceInserted(const CoreSymbolListInsertionEvent<T>& event) = 0;
 
  virtual void fireBeforeSequenceDeleted(const CoreSymbolListDeletionEvent<T>& event) = 0;
 
  virtual void fireAfterSequenceDeleted(const CoreSymbolListDeletionEvent<T>& event) = 0;
 
  virtual void fireBeforeSequenceSubstituted(const CoreSymbolListSubstitutionEvent<T>& event) = 0;
 
  virtual void fireAfterSequenceSubstituted(const CoreSymbolListSubstitutionEvent<T>& event) = 0;
 
protected:
  virtual void propagateEvents(bool yn) = 0;
  virtual bool propagateEvents() const = 0;
};
 
using IntEventDrivenCoreSymbolListInterface = TemplateEventDrivenCoreSymbolListInterface<int>;
using ProbabilisticEventDrivenCoreSymbolListInterface = TemplateEventDrivenCoreSymbolListInterface< std::vector<double>>;
} // end of namespace bpp.
#endif // BPP_SEQ_CORESYMBOLLIST_H