variant_reader.h

Go to the documentation of this file.

#ifndef gamgee__variant_reader__guard
#define gamgee__variant_reader__guard

#include "variant_header.h"
#include "variant_iterator.h"

#include "../exceptions.h"
#include "../utils/hts_memory.h"
#include "../utils/variant_utils.h"

#include "htslib/vcf.h"

#include <string>
#include <fstream>
#include <algorithm>
#include <memory>


namespace gamgee {

template<class ITERATOR>
class VariantReader {
 public:

  explicit VariantReader(const std::string& filename) :
    m_variant_file_ptr {},
    m_variant_header_ptr {}
  {
    init_reader(filename);
  }

  explicit VariantReader(const std::vector<std::string>& filenames) :
    m_variant_file_ptr {},
    m_variant_header_ptr {}
  {
    if (filenames.size() > 1)
      throw SingleInputException{"filenames", filenames.size()};
    if (!filenames.empty())
      init_reader(filenames.front());
  }

  VariantReader(const std::string& filename, const std::vector<std::string>& samples, const bool include = true) :
    m_variant_file_ptr {},
    m_variant_header_ptr {}
  {
    init_reader(filename);
    subset_variant_samples(m_variant_header_ptr.get(), samples, include);
  }

  VariantReader(const std::vector<std::string>& filenames, const std::vector<std::string>& samples, const bool include = true) :
    m_variant_file_ptr {},
    m_variant_header_ptr {}
  {
    if (filenames.size() > 1)
      throw SingleInputException{"filenames", filenames.size()};
    if (!filenames.empty()){
      init_reader(filenames.front());
      subset_variant_samples(m_variant_header_ptr.get(), samples, include);
    }
  }

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

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

  ITERATOR begin() const {
    return ITERATOR{ m_variant_file_ptr, m_variant_header_ptr };
  }

  ITERATOR end() const {
    return ITERATOR{};
  }

  inline VariantHeader header() const { return VariantHeader{m_variant_header_ptr}; }

 private:
  std::shared_ptr<htsFile> m_variant_file_ptr;          
  std::shared_ptr<bcf_hdr_t> m_variant_header_ptr;      

  void init_reader (const std::string& filename) {
    // Need to check raw pointers for null before wrapping them in a shared_ptr to avoid a segfault
    // during destruction if an exception is thrown

    auto* file_ptr = bcf_open(filename.empty() ? "-" : filename.c_str(), "r");
    if ( file_ptr == nullptr ) {
      throw FileOpenException{filename};
    }
    m_variant_file_ptr = utils::make_shared_hts_file(file_ptr);

    auto* header_ptr = bcf_hdr_read(file_ptr);
    if ( header_ptr == nullptr ) {
      throw HeaderReadException{filename};
    }
    m_variant_header_ptr = utils::make_shared_variant_header(header_ptr);
  }
};

using SingleVariantReader = VariantReader<VariantIterator>;

}  // end of namespace

#endif /* defined(gamgee__variant_reader__guard) */