DataSet.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef _DATASET_H_
#define _DATASET_H_
 
// From the STL
#include <algorithm>
#include <vector>
#include <map>
#include <string>
 
#include <Bpp/Exceptions.h>
#include <Bpp/Graphics/Point2D.h>
#include <Bpp/Utils/MapTools.h>
 
#include "Group.h"
#include "Individual.h"
#include "Locality.h"
#include "../GeneralExceptions.h"
#include "AnalyzedLoci.h"
#include "../PolymorphismMultiGContainer.h"
#include "../PolymorphismSequenceContainer.h"
 
namespace bpp
{
class DataSet
{
private:
  std::unique_ptr<AnalyzedLoci> analyzedLoci_;
  std::shared_ptr<const Alphabet> sequenceAlphabet_;
  std::vector<std::shared_ptr<Locality<double>>> localities_; // Localities can be shared
  std::vector<std::unique_ptr<Group>> groups_;
 
public:
  // Constructor and destructor
  DataSet() :
    analyzedLoci_(nullptr),
    sequenceAlphabet_(nullptr),
    localities_(),
    groups_()
  {}
 
 
  virtual ~DataSet() = default;
 
  DataSet(const DataSet& ds);
 
  DataSet& operator=(const DataSet& ds);
 
public:
  // Methodes
// ** Locality manipulation ***************************************************/
  void addLocality(const Locality<double>& locality);
 
  size_t getLocalityPosition(const std::string& name) const;
 
  std::shared_ptr<const Locality<double>> getLocalityAtPosition(size_t localityPosition) const;
 
  const Locality<double>& localityAtPosition(size_t localityPosition) const;
 
  std::shared_ptr<const Locality<double>> getLocalityByName(const std::string& name) const;
 
  const Locality<double>& localityByName(const std::string& name) const;
 
  void deleteLocalityAtPosition(size_t localityPosition);
 
  void deleteLocalityByName(const std::string& name);
 
  size_t getNumberOfLocalities() const { return localities_.size(); }
 
  bool hasLocality() const { return getNumberOfLocalities() > 0; }
 
  // ** Group manipulation ******************************************************/
  void addGroup(const Group& group);
 
  void addEmptyGroup(size_t group_id);
 
  const Group& getGroupById(size_t group_id) const;
 
  size_t getGroupPosition(size_t group_id) const;
 
  std::string getGroupName(size_t group_id) const;
  void setGroupName(size_t group_id, const std::string& group_name) const;
 
  const Group& getGroupAtPosition(size_t groupPosition) const;
 
  void deleteGroupAtPosition(size_t groupPosition);
 
  size_t getNumberOfGroups() const;
 
  void mergeTwoGroups(size_t source_id, size_t target_id);
 
  void mergeGroups(std::vector<size_t>& group_ids);
 
  void splitGroup(size_t group_id, std::vector<size_t> individuals_selection);
 
  // ** Individuals manipulation ************************************************/
  void addIndividualToGroup(size_t groupPosition, const Individual& individual);
 
  void addEmptyIndividualToGroup(size_t groupPosition, const std::string& individual_id);
 
  size_t getNumberOfIndividualsInGroup(size_t groupPosition) const;
 
  size_t getIndividualPositionInGroup(size_t groupPosition, const std::string& individual_id) const;
 
  const Individual& getIndividualAtPositionFromGroup(size_t groupPosition, size_t individualPosition) const;
 
  const Individual& getIndividualByIdFromGroup(size_t groupPosition, const std::string& individualId) const;
 
  void deleteIndividualAtPositionFromGroup(size_t groupPosition, size_t individualPosition);
 
  void deleteIndividualByIdFromGroup(size_t groupPosition, const std::string& individualId);
 
  void setIndividualSexInGroup(size_t groupPosition, size_t individualPosition, const unsigned short sex);
 
  unsigned short getIndividualSexInGroup(size_t groupPosition, size_t individualPosition) const;
 
  void setIndividualDateInGroup(
      size_t groupPosition,
      size_t individualPosition,
      const Date& date);
 
  const Date& individualDateInGroup(
      size_t groupPosition,
      size_t individualPosition) const;
 
  void setIndividualCoordInGroup(size_t groupPosition, size_t individualPosition, const Point2D<double>& coord);
 
  const Point2D<double>& individualCoordInGroup(
      size_t groupPosition,
      size_t individualPosition) const;
 
  void setIndividualLocalityInGroupByName(
      size_t groupPosition,
      size_t individualPosition,
      const std::string& localityName);
 
  std::shared_ptr<const Locality<double>> getIndividualLocalityInGroup(
      size_t groupPosition,
      size_t individualPosition) const;
 
  void addIndividualSequenceInGroup(
      size_t groupPosition,
      size_t individualPosition,
      size_t sequencePosition,
      std::unique_ptr<Sequence>& sequence);
 
  const Sequence& getIndividualSequenceByNameInGroup(size_t groupPosition, size_t individualPosition, const std::string& sequenceName) const;
 
  const Sequence& getIndividualSequenceAtPositionInGroup(size_t groupPosition, size_t individualPosition, size_t sequencePosition) const;
 
  void deleteIndividualSequenceByNameInGroup(size_t groupPosition, size_t individualPosition, const std::string& sequenceName);
 
  void deleteIndividualSequenceAtPositionInGroup(size_t groupPosition, size_t individualPosition, size_t sequencePosition);
 
  std::vector<std::string> getIndividualSequencesNamesInGroup(size_t groupPosition, size_t individualPosition) const;
 
  size_t getIndividualSequencePositionInGroup(size_t groupPosition, size_t individualPosition, const std::string& sequenceName) const;
 
  size_t getIndividualNumberOfSequencesInGroup(size_t groupPosition, size_t individualPosition) const;
 
  void setIndividualGenotypeInGroup(size_t groupPosition, size_t individualPosition, const MultilocusGenotype& genotype);
 
  void initIndividualGenotypeInGroup(size_t groupPosition, size_t individualPosition);
 
  void deleteIndividualGenotypeInGroup(size_t groupPosition, size_t individualPosition);
 
  void setIndividualMonolocusGenotypeInGroup(
      size_t groupPosition,
      size_t individualPosition,
      size_t locusPosition,
      const MonolocusGenotypeInterface& monogen);
 
  void setIndividualMonolocusGenotypeByAlleleKeyInGroup(
      size_t groupPosition,
      size_t individualPosition,
      size_t locusPosition,
      const std::vector<size_t> alleleKeys);
 
  void setIndividualMonolocusGenotypeByAlleleIdInGroup(
      size_t groupPosition,
      size_t individualPosition,
      size_t locusPosition,
      const std::vector<std::string> alleleId);
 
  const MonolocusGenotypeInterface& getIndividualMonolocusGenotypeInGroup(
      size_t groupPosition,
      size_t individualPosition,
      size_t locusPosition) const;
 
  void setAlphabet(std::shared_ptr<const Alphabet> alpha) { sequenceAlphabet_ = alpha; }
 
  void setAlphabet(const std::string& alphaType);
 
  std::shared_ptr<const Alphabet> getAlphabet() const
  {
    if (!sequenceAlphabet_)
      throw NullPointerException("DataSet::getAlphabet: no sequence data.");
    return sequenceAlphabet_;
  }
 
  const Alphabet& alphabet() const
  {
    if (!sequenceAlphabet_)
      throw NullPointerException("DataSet::getAlphabet: no sequence data.");
    return *sequenceAlphabet_;
  }
 
  std::string getAlphabetType() const
  {
    if (!sequenceAlphabet_)
      throw NullPointerException("DataSet::getAlphabet: no sequence data.");
    return sequenceAlphabet_->getAlphabetType();
  }
 
 
  // ** AnalyzedLoci manipulation ***********************************************/
  void setAnalyzedLoci(const AnalyzedLoci& analyzedLoci)
  {
    analyzedLoci_.reset(analyzedLoci.clone());
  }
 
  void initAnalyzedLoci(size_t numberOfLoci)
  {
    if (analyzedLoci_)
      throw Exception("DataSet::initAnalyzedLoci: analyzedLoci_ already initialized.");
    analyzedLoci_ = std::make_unique<AnalyzedLoci>(numberOfLoci);
  }
 
  const AnalyzedLoci& analyzedLoci() const
  {
    if (analyzedLoci_)
      return *analyzedLoci_;
    throw NullPointerException("DataSet::getAnalyzedLoci: no loci initialized.");
  }
 
  void deleteAnalyzedLoci()
  {
    if (analyzedLoci_) analyzedLoci_.reset(nullptr);
  }
 
  void setLocusInfo(size_t locus_position, const LocusInfo& locus);
 
  const LocusInfo& getLocusInfoByName(const std::string& locus_name) const;
 
  const LocusInfo& getLocusInfoAtPosition(size_t locus_position) const;
 
  void addAlleleInfoByLocusName(const std::string& locus_name, const AlleleInfo& allele);
 
  void addAlleleInfoByLocusPosition(size_t locus_position, const AlleleInfo& allele);
 
  size_t getNumberOfLoci() const;
 
  size_t getPloidyByLocusName(const std::string& locus_name) const;
 
  size_t getPloidyByLocusPosition(size_t locus_position) const;
 
  std::unique_ptr<PolymorphismMultiGContainer> getPolymorphismMultiGContainer() const;
 
  std::unique_ptr<PolymorphismMultiGContainer> getPolymorphismMultiGContainer(const std::map<size_t, std::vector<size_t>>& selection) const;
 
  std::unique_ptr<PolymorphismSequenceContainer> getPolymorphismSequenceContainer(
      const std::map<size_t, std::vector<size_t>>& selection,
      size_t sequence_position) const;
 
  // ** General tests **********************************************************/
  bool hasSequenceData() const { return sequenceAlphabet_ != nullptr; }
 
  bool hasAlleleicData() const { return analyzedLoci_ != nullptr; }
};
} // end of namespace bpp;
 
#endif // _DATASET_H_