Individual.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef _INDIVIDUAL_H_
#define _INDIVIDUAL_H_
 
// From STL
#include <vector>
#include <memory>
 
#include <Bpp/Graphics/Point2D.h>
#include <Bpp/Exceptions.h>
#include <Bpp/Text/TextTools.h>
 
// From bpp-seq
#include <Bpp/Seq/Sequence.h>
#include <Bpp/Seq/SequenceExceptions.h>
#include <Bpp/Seq/Container/VectorSequenceContainer.h>
 
// From bpp-popgen
#include "Locality.h"
#include "Date.h"
#include "../MultilocusGenotype.h"
#include "../GeneralExceptions.h"
 
namespace bpp
{
class Individual
{
protected:
  std::string id_;
  unsigned short sex_;
  std::unique_ptr<Date> date_;
  std::unique_ptr<Point2D<double>> coord_;
  std::shared_ptr<const Locality<double>> locality_;
  std::unique_ptr<VectorSequenceContainer> sequences_;
  std::unique_ptr<MultilocusGenotype> genotype_;
 
public:
  // Constructors and destructor :
  Individual();
 
  Individual(const std::string& id);
 
  Individual(const std::string& id,
      const Date& date,
      const Point2D<double>& coord,
      std::shared_ptr<Locality<double>> locality,
      const unsigned short sex);
 
  Individual(const Individual& ind);
 
  virtual ~Individual();
 
public:
  // Methods
  Individual& operator=(const Individual& ind);
 
  void setId(const std::string& id);
 
  const std::string& getId() const { return id_; }
 
  void setSex(const unsigned short sex);
 
  unsigned short getSex() const { return sex_; }
 
  void setDate(const Date& date);
 
  const Date& date() const;
 
  bool hasDate() const;
 
  void setCoord(const Point2D<double>& coord);
 
  void setCoord(const double x, const double y);
 
  const Point2D<double>& coord() const;
 
  bool hasCoord() const;
 
  void setX(const double x);
 
  void setY(const double y);
 
  double getX() const;
 
  double getY() const;
 
  void setLocality(std::shared_ptr<const Locality<double>> locality)
  {
    locality_ = locality;
  }
 
  std::shared_ptr<const Locality<double>> getLocality() const;
 
  const Locality<double>& locality() const;
 
  bool hasLocality() const
  {
    return locality_ != nullptr;
  }
 
  void addSequence(size_t sequenceKey, std::unique_ptr<Sequence>& sequence);
 
  const Sequence& sequenceByName(const std::string& sequenceName) const;
 
  const Sequence& sequenceAtPosition(size_t sequencePosition) const;
 
  void deleteSequenceByName(const std::string& sequenceName);
 
  void deleteSequenceAtPosition(size_t sequencePosition);
 
  bool hasSequences() const;
 
  bool hasSequenceAtPosition(size_t position) const;
 
  std::shared_ptr<const Alphabet> getSequenceAlphabet() const;
 
  const Alphabet& sequenceAlphabet() const;
 
  std::vector<std::string> getSequenceNames() const
  {
    if (!sequences_)
      throw NullPointerException("Individual::getSequencesNames: no sequence data.");
    return sequences_->getSequenceNames();
  }
 
  std::vector<size_t> getSequencePositions() const;
 
  size_t getSequencePosition(const std::string& sequenceKey) const;
 
  size_t getNumberOfSequences() const
  {
    return sequences_ ? sequences_->getNumberOfSequences() : 0;
  }
 
 
  void setSequences(const SequenceContainerInterface& sc)
  {
    sequences_.reset(new VectorSequenceContainer(sc));
  }
 
  const SequenceContainerInterface& sequences() const
  {
    if (!sequences_)
      throw NullPointerException("Individual::getSequences: no sequence data.");
    return *sequences_;
  }
 
 
  void setGenotype(const MultilocusGenotype& genotype);
 
  void initGenotype(size_t lociNumber);
 
  const MultilocusGenotype& getGenotype() const;
 
  void deleteGenotype();
 
  bool hasGenotype() const;
 
  void setMonolocusGenotype(size_t locusPosition, const MonolocusGenotypeInterface& monogen);
 
  void setMonolocusGenotypeByAlleleKey(
      size_t locusPosition,
      const std::vector<size_t> alleleKeys);
 
  void setMonolocusGenotypeByAlleleId(
      size_t locusPosition,
      const std::vector<std::string> alleleId,
      const LocusInfo& locusInfo);
 
  const MonolocusGenotypeInterface& getMonolocusGenotype(size_t locusPosition);
 
  size_t countNonMissingLoci() const;
 
  size_t countHomozygousLoci() const;
 
  size_t countHeterozygousLoci() const;
};
} // end of namespace bpp;
 
#endif // _INDIVIDUAL_H_