variant_header.h

Go to the documentation of this file.

#ifndef gamgee__variant_header__guard
#define gamgee__variant_header__guard

#include "htslib/vcf.h"

#include "../missing.h"

#include <memory>
#include <string>
#include <vector>

namespace gamgee {

template<bool fields_forward_LUT_ordering, bool fields_reverse_LUT_ordering, bool samples_forward_LUT_ordering, bool samples_reverse_LUT_ordering>
class VariantHeaderMerger;  //forward declaration to declare friendship in VariantHeader
class VariantHeader {
 public:
  VariantHeader() = default;                                                             
  explicit VariantHeader(const std::shared_ptr<bcf_hdr_t>& header) : m_header{header} {} 
  VariantHeader(const VariantHeader& other);                                             
  VariantHeader(VariantHeader&& other) noexcept;                                         
  VariantHeader& operator=(const VariantHeader& other);                                  
  VariantHeader& operator=(VariantHeader&& other) noexcept;                              
  ~VariantHeader() = default;

  bool operator==(const VariantHeader& rhs) const;
  bool operator!=(const VariantHeader& rhs) const { return !operator==(rhs); }

  std::vector<std::string> samples() const;           
  uint32_t n_samples() const { return uint32_t(bcf_hdr_nsamples(m_header.get())); };  
  std::vector<std::string> chromosomes() const;       
  uint32_t n_chromosomes() const;                     

  uint32_t field_index_end() const { return static_cast<uint32_t>(m_header->n[BCF_DT_ID]); };

  uint32_t n_filters() const;
  std::vector<std::string> filters() const;           

  uint32_t n_shared_fields() const;
  std::vector<std::string> shared_fields() const;     

  uint32_t n_individual_fields() const;
  std::vector<std::string> individual_fields() const; 

  // type checking functions: returns BCF_HT_FLAG, BCF_HT_INT, BCF_HT_REAL, BCF_HT_STR from htslib/vcf.h
  uint8_t shared_field_type(const std::string& tag) const { return field_type(field_index(tag), BCF_HL_INFO); }     
  uint8_t shared_field_type(const int32_t index) const { return field_type(index, BCF_HL_INFO); }                   
  uint8_t individual_field_type(const std::string& tag) const { return field_type(field_index(tag), BCF_HL_FMT); }  
  uint8_t individual_field_type(const int32_t index) const { return field_type(index, BCF_HL_FMT); }                

  uint8_t field_type(const std::string& tag, const int32_t field_category) const { return field_type(field_index(tag), field_category); }

  uint8_t field_type(const int32_t index, const int32_t field_category) const { return bcf_hdr_id2type(m_header.get(), field_category, index); }
  /*
   * returns one of BCF_VL_* values for field with the specified name and category (one of BCF_HL_FMT, BCF_HL_INFO, or BCF_HL_FLT)
   *
   * @note must check whether the field exists before calling this function, as it doesn't check for you
   */
  uint32_t field_length_descriptor(const std::string& tag, const int32_t field_category) const { return field_length_descriptor(field_index(tag), field_category); }
  uint32_t field_length_descriptor(const int32_t index, const int32_t field_category) const { return bcf_hdr_id2length(m_header.get(), field_category, index); }
  uint32_t field_length(const std::string& tag, const int32_t field_category) const { return field_length(field_index(tag), field_category); }
  uint32_t field_length(const int32_t index, const int32_t field_category) const { return bcf_hdr_id2number(m_header.get(), field_category, index); }
  bool has_filter(const std::string& filter_name) const { return has_field(field_index(filter_name), BCF_HL_FLT); }

  bool has_filter(const int32_t filter_index) const { return has_field(filter_index, BCF_HL_FLT); }

  bool has_shared_field(const std::string& field_name) const { return has_field(field_index(field_name), BCF_HL_INFO); }

  bool has_shared_field(const int32_t field_index) const { return has_field(field_index, BCF_HL_INFO); }

  bool has_individual_field(const std::string& field_name) const { return has_field(field_index(field_name), BCF_HL_FMT); }

  bool has_individual_field(const int32_t field_index) const { return has_field(field_index, BCF_HL_FMT); }

  bool has_field(const std::string& field_name, const int32_t field_category) const { return has_field(field_index(field_name), field_category); }

  bool has_field(const int32_t field_index, const int32_t field_category) const {
    // Can't just use bcf_hdr_idinfo_exists() here since it assumes the index came from a hash lookup,
    // which is not always the case
    return field_index >= 0 &&
           field_index < m_header->n[BCF_DT_ID] &&
           m_header->id[BCF_DT_ID][field_index].val != nullptr &&
           m_header->id[BCF_DT_ID][field_index].val->hrec[field_category] != nullptr;
  }

  bool has_sample(const std::string& sample_name) const { return has_sample(sample_index(sample_name)); }

  bool has_sample(const int32_t sample_index) const {
    // Can't assume that sample_index came from a hash lookup, so must validate the hard way
    return sample_index >= 0 &&
           sample_index < m_header->n[BCF_DT_SAMPLE] &&
           m_header->id[BCF_DT_SAMPLE][sample_index].val != nullptr &&
           m_header->id[BCF_DT_SAMPLE][sample_index].val->id != -1;
  }

  int32_t field_index(const std::string& tag) const {
    const auto index = bcf_hdr_id2int(m_header.get(), BCF_DT_ID, tag.c_str());
    return index >= 0 ? index : missing_values::int32;
  }

  int32_t sample_index(const std::string& sample) const {
    const auto index = bcf_hdr_id2int(m_header.get(), BCF_DT_SAMPLE, sample.c_str());
    return index >= 0 ? index : missing_values::int32;
  }

  std::string get_field_name(const int32_t field_idx) const {
    if(field_idx >= 0 && field_idx < m_header->n[BCF_DT_ID])
    {
      auto name_ptr = bcf_hdr_int2id(m_header.get(), BCF_DT_ID, field_idx);
      if(name_ptr)
  return name_ptr;
    }
    return "";
  }

  std::string get_sample_name(const int32_t sample_idx) const {
    if(sample_idx >= 0 && sample_idx < m_header->n[BCF_DT_SAMPLE])
    {
      auto name_ptr= bcf_hdr_int2id(m_header.get(), BCF_DT_SAMPLE, sample_idx);
      if(name_ptr)
  return name_ptr;
    }
    return "";
  }

 private:
  std::shared_ptr<bcf_hdr_t> m_header;

  friend class Variant;
  friend class VariantWriter;
  friend class VariantHeaderBuilder;
  friend class VariantBuilder;       
  friend class VariantBuilderSharedRegion;
  friend class VariantBuilderIndividualRegion;
  template<bool fields_forward_LUT_ordering, bool fields_reverse_LUT_ordering, bool samples_forward_LUT_ordering, bool samples_reverse_LUT_ordering>
  friend class VariantHeaderMerger;  //to access m_header
};

}

#endif // gamgee__variant_header__guard