genotype.h

Go to the documentation of this file.

#ifndef gamgee__genotype__guard
#define gamgee__genotype__guard

#include "variant_builder_multi_sample_vector.h"

#include "../utils/genotype_utils.h"
#include "../utils/hts_memory.h"
#include "../utils/utils.h"
#include "../utils/variant_field_type.h"
#include "../utils/variant_utils.h"

#include <memory>
#include <utility>
#include <stdexcept>

namespace gamgee {

class Genotype{

 public:
  Genotype(const std::shared_ptr<bcf1_t>& body, const bcf_fmt_t* const format_ptr, const uint8_t* data_ptr);

  Genotype(const Genotype& other) = delete;

  Genotype& operator=(const Genotype& other) = delete;

  Genotype(Genotype&& other) = default;

  Genotype& operator=(Genotype&& other) = default;

  ~Genotype() = default;

  bool operator!=(const Genotype& other) const;

  bool operator==(const Genotype& other) const;

  // only for diploids
  bool het() const;

  bool non_ref_het() const;

  uint32_t fast_diploid_key_generation() const;

  //for all ploidies
  bool hom_var() const;

  bool hom_ref() const;

  bool missing() const;

  // referencing alleles inside a sample's genotype

  std::vector<std::string> allele_strings() const;

  std::vector<int32_t> allele_keys() const;

  std::string allele_string(const uint32_t index) const;

  int32_t allele_key(const uint32_t index) const;

  int32_t operator[](const uint32_t index) const;

  uint32_t size() const;

  bool snp(const AlleleMask& mask) const;

  bool insertion(const AlleleMask& mask) const;

  bool deletion(const AlleleMask& mask) const;

  bool indel(const AlleleMask& mask) const;

  bool biallelic() const;

  bool complex() const { return !biallelic(); }

  bool mixed() const;

  bool variant() const {
    return !missing() && !hom_ref();
  }

  static inline void encode_genotype(std::vector<int32_t>& alleles) {
    encode_genotype(alleles, false);
  }

  static inline void encode_genotype(std::vector<int32_t>& alleles, bool phase_all_alleles) {
    for ( auto allele_index = 0u; allele_index < alleles.size(); ++allele_index ) {
      // Only legal value below -1 is the int32 vector end value
      if ( alleles[allele_index] < -1 && alleles[allele_index] != bcf_int32_vector_end ) {
        throw std::invalid_argument{"Genotype vector must consist only of allele indices, -1 for missing values, or vector end values"};
      }
      // Do not modify vector end values
      else if ( alleles[allele_index] != bcf_int32_vector_end ) {
        alleles[allele_index] = (alleles[allele_index] + 1) << 1 | (phase_all_alleles && allele_index > 0u ? 1 : 0);
      }
    }
  }

  static inline void encode_genotypes(std::vector<std::vector<int32_t>>& multiple_genotypes) {
    for ( auto& genotype : multiple_genotypes ) {
      encode_genotype(genotype, false);
    }
  }

  static inline void encode_genotypes(VariantBuilderMultiSampleVector<int32_t>& multiple_genotypes) {
    auto& genotypes_vector = const_cast<std::vector<int32_t>&>(multiple_genotypes.get_vector());
    encode_genotype(genotypes_vector, false);
  }

 private:
  std::shared_ptr<bcf1_t> m_body;
  const bcf_fmt_t* m_format_ptr;
  const uint8_t* m_data_ptr;

  bool allele_is_type_or_ref(const AlleleType& type, const std::vector<int32_t>& keys, const AlleleMask& mask) const;
};

}

#endif