Group.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef _GROUP_H_
#define _GROUP_H_
 
// From STL
#include <vector>
#include <memory>
 
#include <Bpp/Exceptions.h>
#include <Bpp/Graphics/Point2D.h>
 
// From bpp-seq
#include <Bpp/Seq/Container/VectorSequenceContainer.h>
#include <Bpp/Seq/Container/VectorSiteContainer.h>
#include <Bpp/Seq/Container/SequenceContainerTools.h>
 
// From bpp-popgen
#include "Individual.h"
#include "../GeneralExceptions.h"
 
namespace bpp
{
class Group :
  public virtual Clonable
{
protected:
  size_t id_;
  std::string name_;
  std::vector<std::unique_ptr<Individual>> individuals_;
 
public:
  // Constructors and destructor :
  Group(size_t groupId) :
    id_(groupId),
    name_(""),
    individuals_()
  {}
 
  Group(const Group& group) :
    id_(group.id_),
    name_(group.name_),
    individuals_()
  {
    for (size_t i = 0; i < group.getNumberOfIndividuals(); ++i)
    {
      addIndividual(group.getIndividualAtPosition(i));
    }
  }
 
  Group& operator=(const Group& group)
  {
    id_ = group.id_;
    name_ = group.name_;
    individuals_.clear();
    for (size_t i = 0; i < group.getNumberOfIndividuals(); ++i)
    {
      addIndividual(group.getIndividualAtPosition(i));
    }
    return *this;
  }
 
  Group(const Group& group, size_t groupId) :
    id_(groupId),
    name_(group.name_),
    individuals_()
  {
    for (size_t i = 0; i < group.getNumberOfIndividuals(); ++i)
    {
      addIndividual(group.getIndividualAtPosition(i));
    }
  }
 
 
  virtual ~Group() = default;
 
  Group* clone() const override { return new Group(*this); }
 
public:
  void setGroupId(size_t groupId){ id_ = groupId; }
 
  const std::string& getGroupName() const { return name_; }
 
  void setGroupName(const std::string& groupName) { name_ = groupName; }
 
  size_t getGroupId() const { return id_; }
 
  void addIndividual(const Individual& ind);
 
  void addEmptyIndividual(const std::string& individualId);
 
  size_t getNumberOfIndividuals() const { return individuals_.size(); }
 
  size_t getMaxNumberOfSequences() const;
 
  size_t getIndividualPosition(const std::string& individualId) const;
 
  const Individual& getIndividualById(const std::string& individualId) const;
 
  const Individual& getIndividualAtPosition(size_t individualPosition) const;
 
  std::unique_ptr<Individual> removeIndividualById(const std::string& individualId);
 
  std::unique_ptr<Individual> removeIndividualAtPosition(size_t individualPosition);
 
  void deleteIndividualById(const std::string& individualId);
 
  void deleteIndividualAtPosition(size_t individualPosition);
 
  void clear() { individuals_.clear(); }
 
  // -- Dealing with Individuals -----------------------------
  void setIndividualSexAtPosition(size_t individualPosition, const unsigned short sex);
 
  unsigned short getIndividualSexAtPosition(size_t individualPosition) const;
 
  void setIndividualDateAtPosition(size_t individualPosition, const Date& date);
 
  const Date& getIndividualDateAtPosition(size_t individualPosition) const;
 
  void setIndividualCoordAtPosition(size_t individualPosition, const Point2D<double>& coord);
 
  const Point2D<double>& getIndividualCoordAtPosition(size_t individualPosition) const;
 
  void setIndividualLocalityAtPosition(
      size_t individualPosition,
      std::shared_ptr<const Locality<double>> locality);
 
  std::shared_ptr<const Locality<double>> getIndividualLocalityAtPosition(size_t individualPosition) const;
 
  void addIndividualSequenceAtPosition(size_t individualPosition,
      size_t sequencePosition,
      std::unique_ptr<Sequence>& sequence);
 
  const Sequence& getIndividualSequenceByName(
      size_t individualPosition,
      const std::string& sequence_name) const;
 
  const Sequence& getIndividualSequenceAtPosition(
      size_t individualPosition,
      size_t sequencePosition) const;
 
  void deleteIndividualSequenceByName(size_t individualPosition, const std::string& sequence_name);
 
  void deleteIndividualSequenceAtPosition(size_t individualPosition, size_t sequencePosition);
 
  bool hasIndividualSequences(size_t individualPosition) const;
 
  std::vector<std::string> getIndividualSequencesNames(size_t individualPosition) const;
 
  size_t getIndividualSequencePosition(
      size_t individualPosition,
      const std::string& sequence_name) const;
 
  size_t getIndividualNumberOfSequences(size_t individualPosition) const;
 
  void setIndividualSequences(size_t individualPosition, const SequenceContainerInterface& sc);
 
  void setIndividualGenotype(size_t individualPosition, const MultilocusGenotype& genotype);
 
  void initIndividualGenotype(size_t individualPosition, size_t loci_number);
 
  void deleteIndividualGenotype(size_t individualPosition);
 
  bool hasIndividualGenotype(size_t individualPosition) const;
 
  void setIndividualMonolocusGenotype(
      size_t individualPosition,
      size_t locusPosition,
      const MonolocusGenotypeInterface& monogen);
 
  void setIndividualMonolocusGenotypeByAlleleKey(
      size_t individualPosition,
      size_t locusPosition,
      const std::vector<size_t>& alleleKeys);
 
  void setIndividualMonolocusGenotypeByAlleleId(
      size_t individualPosition,
      size_t locusPosition,
      const std::vector<std::string>& alleleId,
      const LocusInfo& locusInfo);
 
  const MonolocusGenotypeInterface& getIndividualMonolocusGenotype(
      size_t individualPosition,
      size_t locusPosition) const;
 
  bool hasSequenceData() const;
 
  std::shared_ptr<const Alphabet> getAlphabet() const;
 
  size_t getGroupSizeForLocus(size_t locusPosition) const;
 
  size_t getGroupSizeForSequence(size_t sequencePosition) const;
};
} // end of namespace bpp;
 
#endif // _GROUP_H_