CompressedVectorSiteContainer.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_CONTAINER_COMPRESSEDVECTORSITECONTAINER_H
#define BPP_SEQ_CONTAINER_COMPRESSEDVECTORSITECONTAINER_H
 
#include <Bpp/Numeric/VectorTools.h>
 
#include "../Site.h"
#include "AbstractSequenceContainer.h"
#include "AlignedSequenceContainer.h"
#include "SiteContainer.h"
 
// From the STL library:
#include <string>
#include <vector>
#include <iostream>
 
namespace bpp
{
class CompressedVectorSiteContainer :
  public AbstractTemplateSequenceContainer<Sequence, std::string>,
  public virtual TemplateSiteContainerInterface<Site, Sequence, std::string>
{
protected:
  VectorPositionedContainer<Site> siteContainer_;
  VectorMappedContainer<Sequence> sequenceContainer_;
  std::vector<std::string> sequenceNames_;
  std::vector<Comments> sequenceComments_;
  std::vector<size_t> index_; // For all sites, give the actual position in the set.
 
public:
  CompressedVectorSiteContainer(
      std::vector< std::unique_ptr<Site>>& vs,
      std::shared_ptr<const Alphabet>& alphabet);
 
  CompressedVectorSiteContainer(
      size_t size,
      std::shared_ptr<const Alphabet>& alphabet);
 
  CompressedVectorSiteContainer(
      const std::vector<std::string>& names,
      std::shared_ptr<const Alphabet>& alphabet);
 
  CompressedVectorSiteContainer(std::shared_ptr<const Alphabet>& alphabet);
 
  CompressedVectorSiteContainer(const CompressedVectorSiteContainer& vsc);
  CompressedVectorSiteContainer(const SiteContainerInterface& sc);
 
  CompressedVectorSiteContainer& operator=(const CompressedVectorSiteContainer& vsc);
  CompressedVectorSiteContainer& operator=(const SiteContainerInterface& sc);
 
  virtual ~CompressedVectorSiteContainer() { clear(); }
 
public:
  CompressedVectorSiteContainer* clone() const override
  {
    return new CompressedVectorSiteContainer(*this);
  }
  const Site& site(size_t sitePosition) const override
  {
    return *siteContainer_.getObject(index_[sitePosition]);
  }
 
  void setSite(size_t sitePosition, std::unique_ptr<Site>& site, bool checkCoordinate = true) override;
 
  std::unique_ptr<Site> removeSite(size_t sitePosition) override;
 
  void deleteSite(size_t sitePosition) override;
 
  void addSite(std::unique_ptr<Site>& site, bool checkCoordinate = false) override;
 
  void addSite(std::unique_ptr<Site>& site, size_t sitePosition, bool checkCoordinate = false) override;
 
  void deleteSites(size_t sitePosition, size_t length) override;
 
  size_t getNumberOfSites() const override { return index_.size(); }
 
  void reindexSites() override;
 
  Vint getSiteCoordinates() const override;
 
  void setSiteCoordinates(const Vint& coordinates) override;
 
 
  size_t getNumberOfUniqueSites() const
  {
    return siteContainer_.getSize();
  }
 
 
  // These methods are implemented for this class:
 
  const Sequence& sequence(size_t sequenceIndex) const override;
 
  const Sequence& sequence(const std::string& sequenceKey) const override
  {
    // Look for sequence name:
    size_t pos = getSequencePosition(sequenceKey);
    return sequence(pos);
  }
 
  bool hasSequence(const std::string& name) const override
  {
    // Look for sequence key:
    return sequenceContainer_.hasObject(name);
  }
 
  size_t getSequencePosition(const std::string& sequenceKey) const override
  {
    // Look for sequence key:
    return sequenceContainer_.getObjectPosition(sequenceKey);
  }
 
  std::unique_ptr<Sequence> removeSequence(size_t sequencePosition) override
  {
    // Implementing this function would involve (partially) decompressing the data...
    throw NotImplementedException("CompressedVectorSiteContainer::removeSequence.");
  }
 
  std::unique_ptr<Sequence> removeSequence(const std::string& sequenceKey) override
  {
    // Implementing this function would involve (partially) decompressing the data...
    throw NotImplementedException("CompressedVectorSiteContainer::removeSequence.");
  }
 
  void deleteSequence(size_t sequencePosition) override
  {
    // Implementing this function would involve (partially) decompressing the data...
    throw NotImplementedException("CompressedVectorSiteContainer::deleteSequence.");
  }
 
  void deleteSequence(const std::string& sequenceKey) override
  {
    // Implementing this function would involve (partially) decompressing the data...
    throw NotImplementedException("CompressedVectorSiteContainer::deleteSequence.");
  }
 
  size_t getNumberOfSequences() const override
  {
    return sequenceContainer_.getNumberOfObjects();
  }
 
  std::vector<std::string> getSequenceKeys() const override
  {
    return sequenceContainer_.getObjectNames();
  }
 
  void setSequenceKeys(const std::vector<std::string>& sequenceKeys) override
  {
    sequenceContainer_.setObjectNames(sequenceKeys);
  }
 
  const std::string& sequenceKey(size_t sequencePosition) const override
  {
    return sequenceContainer_.getObjectName(sequencePosition);
  }
 
  std::vector<std::string> getSequenceNames() const override
  {
    return sequenceNames_;
  }
 
  void setSequenceNames(const std::vector<std::string>& names, bool updateKeys) override
  {
    if (names.size() != getNumberOfSequences())
      throw DimensionException("CompressedVectorSiteContainer::setSequenceNames : bad number of names", names.size(), getNumberOfSequences());
    sequenceContainer_.clear();
    sequenceNames_ = names;
    if (updateKeys)
    {
      setSequenceKeys(names);
    }
  }
 
  std::vector<Comments> getSequenceComments() const override
  {
    return sequenceComments_;
  }
 
  void clear() override
  {
    siteContainer_.clear();
    sequenceContainer_.clear();
    sequenceNames_.clear();
    sequenceComments_.clear();
    index_.clear();
  }
 
  CompressedVectorSiteContainer* createEmptyContainer() const override
  {
    auto alphaP = getAlphabet();
    CompressedVectorSiteContainer* vsc = new CompressedVectorSiteContainer(alphaP);
    vsc->setComments(getComments());
    return vsc;
  }
 
  void setSequence(size_t sequencePosition, std::unique_ptr<Sequence>& sequence, const std::string& sequenceKey) override
  {
    // Implementing this function would involve (partially) decompressing the data...
    throw NotImplementedException("CompressedVectorSiteContainer::setSequence.");
  }
 
  void setSequence(size_t sequencePosition, std::unique_ptr<Sequence>& sequence) override
  {
    // Implementing this function would involve (partially) decompressing the data...
    throw NotImplementedException("CompressedVectorSiteContainer::setSequence.");
  }
 
  void setSequence(const std::string& sequenceKey, std::unique_ptr<Sequence>& sequence) override
  {
    // Implementing this function would involve (partially) decompressing the data...
    throw NotImplementedException("CompressedVectorSiteContainer::setSequence.");
  }
 
  void addSequence(const std::string& sequenceKey, std::unique_ptr<Sequence>& sequence) override
  {
    // Implementing this function would involve (partially) decompressing the data...
    throw NotImplementedException("CompressedVectorSiteContainer::addSequence.");
  }
 
  void insertSequence(size_t sequencePosition, std::unique_ptr<Sequence>& sequence, const std::string& sequenceKey) override
  {
    // Implementing this function would involve (partially) decompressing the data...
    throw NotImplementedException("CompressedVectorSiteContainer::insertSequence.");
  }
 
  const int& valueAt(const std::string& sequenceKey, size_t sitePosition) const override
  {
    return site(sitePosition)[getSequencePosition(sequenceKey)];
  }
 
  int& valueAt(const std::string& sequenceKey, size_t sitePosition) override
  {
    // Implementing this function would involve (partially) decompressing the data...
    throw NotImplementedException("CompressedVectorSiteContainer::valueAt (non const).");
  }
 
  const int& valueAt(size_t sequencePosition, size_t sitePosition) const override
  {
    return site(sitePosition)[sequencePosition];
  }
 
  int& valueAt(size_t sequencePosition, size_t sitePosition) override
  {
    // Implementing this function would involve (partially) decompressing the data...
    throw NotImplementedException("CompressedVectorSiteContainer::valueAt (non const).");
  }
 
  double getStateValueAt(size_t sitePosition, const std::string& sequenceKey, int state) const override
  {
    return site(sitePosition).getStateValueAt(getSequencePosition(sequenceKey), state);
  }
 
  double operator()(size_t sitePosition, const std::string& sequenceKey, int state) const override
  {
    return site(sitePosition).getStateValueAt(getSequencePosition(sequenceKey), state);
  }
 
  double getStateValueAt(size_t sitePosition, size_t sequencePosition, int state) const override
  {
    return site(sitePosition).getStateValueAt(sequencePosition, state);
  }
 
  double operator()(size_t sitePosition, size_t sequencePosition, int state) const override
  {
    return site(sitePosition).getStateValueAt(sequencePosition, state);
  }
 
protected:
  Site& getSite_(size_t sitePosition)
  {
    return *siteContainer_.getObject(index_[sitePosition]);
  }
 
  size_t getSiteIndex_(const Site& site);
};
} // end of namespace bpp.
#endif // BPP_SEQ_CONTAINER_COMPRESSEDVECTORSITECONTAINER_H