PolymorphismSequenceContainer.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef _POLYMORPHISMSEQUENCECONTAINER_H_
#define _POLYMORPHISMSEQUENCECONTAINER_H_
 
#include <set>
#include <string>
 
#include <Bpp/Clonable.h>
#include <Bpp/Text/StringTokenizer.h>
#include <Bpp/Text/TextTools.h>
 
#include <Bpp/Seq/Container/VectorSiteContainer.h>
#include <Bpp/Seq/Container/SequenceContainerTools.h>
 
namespace bpp
{
class PolymorphismSequenceContainer :
  public VectorSiteContainer
{
private:
  std::vector<bool> ingroup_;
  std::vector<unsigned int> count_;
  std::vector<size_t> group_;
 
public:
  // Constructors and destructor
  PolymorphismSequenceContainer(std::shared_ptr<const Alphabet> alpha) :
    VectorSiteContainer(alpha),
    ingroup_(std::vector<bool>()),
    count_(0),
    group_(0)
  {}
 
  PolymorphismSequenceContainer(size_t size, std::shared_ptr<const Alphabet> alpha) :
    VectorSiteContainer(size, alpha),
    ingroup_(size),
    count_(size),
    group_(size)
  {}
 
  PolymorphismSequenceContainer(const std::vector<std::string>& names, std::shared_ptr<const Alphabet> alpha) :
    VectorSiteContainer(names, alpha),
    ingroup_(names.size()),
    count_(names.size()),
    group_(names.size())
  {}
 
  PolymorphismSequenceContainer(const SequenceContainerInterface& sc) :
    VectorSiteContainer(sc),
    ingroup_(sc.getNumberOfSequences(), true),
    count_(sc.getNumberOfSequences(), 1),
    group_(sc.getNumberOfSequences(), 1)
  {}
 
  PolymorphismSequenceContainer(const SequenceContainerInterface& sc, bool count);
 
  PolymorphismSequenceContainer(const PolymorphismSequenceContainer& psc);
 
  PolymorphismSequenceContainer& operator=(const PolymorphismSequenceContainer& psc);
 
  virtual ~PolymorphismSequenceContainer();
 
  PolymorphismSequenceContainer* clone() const override
  {
    return new PolymorphismSequenceContainer(*this);
  }
 
public:
  // Other methods
  std::unique_ptr<Sequence> removeSequence(size_t sequencePosition) override;
 
  std::unique_ptr<Sequence> removeSequence(const std::string& sequenceKey)override;
 
  void deleteSequence(size_t sequencePosition) override;
 
  void deleteSequence(const std::string& sequenceKey) override;
 
  void addSequenceWithFrequency(
      const std::string& sequenceKey,
      std::unique_ptr<Sequence>& sequence,
      unsigned int frequency)
  {
    VectorSiteContainer::addSequence(sequenceKey, sequence);
    count_.push_back(frequency);
    ingroup_.push_back(true);
    group_.push_back(0);
  }
 
 
  void insertSequenceWithFrequency(
      size_t sequencePosition,
      std::unique_ptr<Sequence>& sequence,
      const std::string& sequenceKey,
      unsigned int frequency)
  {
    VectorSiteContainer::insertSequence(sequencePosition, sequence, sequenceKey);
    count_.insert(count_.begin() + static_cast<ptrdiff_t>(sequencePosition), frequency);
    ingroup_.insert(ingroup_.begin() + static_cast<ptrdiff_t>(sequencePosition), true);
    group_.insert(group_.begin() + static_cast<ptrdiff_t>(sequencePosition), 0);
  }
 
  void addSequence(
      const std::string& sequenceKey,
      std::unique_ptr<Sequence>& sequence) override
  {
    addSequenceWithFrequency(sequenceKey, sequence, 1);
  }
 
  void insertSequence(size_t sequencePosition, std::unique_ptr<Sequence>& sequence, const std::string& sequenceKey) override
  {
    insertSequenceWithFrequency(sequencePosition, sequence, sequenceKey, 1);
  }
 
  void clear() override
  {
    VectorSiteContainer::clear();
    count_.clear();
    ingroup_.clear();
    group_.clear();
  }
 
  size_t getGroupId(size_t index) const
  {
    if (index >= getNumberOfSequences())
      throw IndexOutOfBoundsException("PolymorphismSequenceContainer::getGroupId: index out of bounds.", index, 0, getNumberOfSequences());
    return group_[index];
  }
 
  size_t getGroupId(const std::string& name) const
  {
    try
    {
      return group_[getSequencePosition(name)];
    }
    catch (SequenceNotFoundException& snfe)
    {
      throw SequenceNotFoundException("PolymorphismSequenceContainer::getGroupId.", name);
    }
  }
 
 
  std::set<size_t> getAllGroupsIds() const;
 
  void setGroupId(size_t index, size_t group_id)
  {
    if (index >= getNumberOfSequences())
      throw IndexOutOfBoundsException("PolymorphismSequenceContainer::setGroupId: index out of bounds.", index, 0, getNumberOfSequences());
    group_[index] = group_id;
  }
 
  void setGroupId(const std::string& name, size_t group_id)
  {
    try
    {
      group_[getSequencePosition(name)] = group_id;
    }
    catch (SequenceNotFoundException& snfe)
    {
      throw SequenceNotFoundException("PolymorphismSequenceContainer::setGroupId.", name);
    }
  }
 
  size_t getNumberOfGroups() const
  {
    return getAllGroupsIds().size();
  }
 
  bool hasOutgroup() const;
 
  bool isIngroupMember(size_t index) const
  {
    if (index >= getNumberOfSequences())
      throw IndexOutOfBoundsException("PolymorphismSequenceContainer::isIngroupMember: index out of bounds.", index, 0, getNumberOfSequences());
    return ingroup_[index];
  }
 
  bool isIngroupMember(const std::string& name) const
  {
    try
    {
      return ingroup_[getSequencePosition(name)];
    }
    catch (SequenceNotFoundException& snfe)
    {
      throw SequenceNotFoundException("PolymorphismSequenceContainer::isIngroupMember.", name);
    }
  }
 
  void setAsIngroupMember(size_t index);
 
  void setAsIngroupMember(const std::string& name);
 
  void setAsOutgroupMember(size_t index);
 
  void setAsOutgroupMember(const std::string& name);
 
  void setSequenceCount(size_t index, unsigned int count);
 
  void setSequenceCount(const std::string& name, unsigned int count);
 
  void incrementSequenceCount(size_t index);
 
  void incrementSequenceCount(const std::string& name);
 
  void decrementSequenceCount(size_t index);
 
  void decrementSequenceCount(const std::string& name);
 
  unsigned int getSequenceCount(size_t index) const;
 
  unsigned int getSequenceCount(const std::string& name) const;
 
  std::unique_ptr<SiteContainerInterface> toSiteContainer() const;
};
} // end of namespace bpp;
 
#endif // _POLYMORPHISMSEQUENCECONTAINER_H_