merged_vcf_lut.h

Go to the documentation of this file.

#ifndef __gamgee_merged_vcf_lut__
#define __gamgee_merged_vcf_lut__

#include <assert.h>
#include <vector>

#include "htslib/vcf.h"

#include "../missing.h"
#include "../variant/variant_header.h"

//forward declaration for friend function of MergedVCFLUTBase
template<bool inputs_2_merged_LUT_is_input_ordered, bool merged_2_inputs_LUT_is_input_ordered>
void test_lut_base();

namespace gamgee
{
  //forward declaration of friend class of MergedVCFLUTBase
  template<bool fields_forward_LUT_ordering, bool fields_reverse_LUT_ordering, bool samples_forward_LUT_ordering, bool samples_reverse_LUT_ordering>
  class VariantHeaderMerger;

  namespace utils
  {
    template<bool inputs_2_merged_LUT_is_input_ordered, bool merged_2_inputs_LUT_is_input_ordered>
    class MergedVCFLUTBase
    {
      template<bool fields_forward_LUT_ordering, bool fields_reverse_LUT_ordering, bool samples_forward_LUT_ordering, bool samples_reverse_LUT_ordering>
      friend class gamgee::VariantHeaderMerger;
      template<bool v1, bool v2>
      friend void ::test_lut_base();
      public:
      inline void reset_luts()
      {
        for(auto& vec : m_inputs_2_merged_lut)
          reset_vector(vec);
        for(auto& vec : m_merged_2_inputs_lut)
          reset_vector(vec);
      }

      /*
       * @brief Add a valid mapping between input VCF and merged VCF
       * @note all parameters should be valid parameters, no bcf_int32_missing allowed, use reset_() functions to invalidate existing mapping
       * @param inputGVCFIdx index of the input VCF file
       * @param inputIdx index of the field in the input VCF file - field could be anything header field,sample,allele etc
       * @param mergedIdx index of the field in the merged VCF file
       */
      inline void add_input_merged_idx_pair(unsigned inputGVCFIdx, int inputIdx, int mergedIdx)
      {
        set_merged_idx_for_input(inputGVCFIdx, inputIdx, mergedIdx);
        set_input_idx_for_merged(inputGVCFIdx, inputIdx, mergedIdx);
      }

      template <bool M = merged_2_inputs_LUT_is_input_ordered, typename std::enable_if<M>::type* = nullptr>
      inline int get_input_idx_for_merged(unsigned inputGVCFIdx, int mergedIdx) const
      { return get_lut_value(m_merged_2_inputs_lut, inputGVCFIdx, mergedIdx); }
      template <bool M = merged_2_inputs_LUT_is_input_ordered, typename std::enable_if<!M>::type* = nullptr>
      inline int get_input_idx_for_merged(unsigned inputGVCFIdx, int mergedIdx) const
      { return get_lut_value(m_merged_2_inputs_lut, mergedIdx, inputGVCFIdx); }

      template <bool M = inputs_2_merged_LUT_is_input_ordered, typename std::enable_if<M>::type* = nullptr>
      inline int get_merged_idx_for_input(unsigned inputGVCFIdx, int inputIdx) const
      { return get_lut_value(m_inputs_2_merged_lut, inputGVCFIdx, inputIdx); }
      template <bool M = inputs_2_merged_LUT_is_input_ordered, typename std::enable_if<!M>::type* = nullptr>
      inline int get_merged_idx_for_input(unsigned inputGVCFIdx, int inputIdx) const
      { return get_lut_value(m_inputs_2_merged_lut, inputIdx, inputGVCFIdx); }

      inline void reset_merged_idx_for_input(unsigned inputGVCFIdx, int inputIdx)
      { set_merged_idx_for_input(inputGVCFIdx, inputIdx, gamgee::missing_values::int32); }
      inline void reset_input_idx_for_merged(unsigned inputGVCFIdx, int mergedIdx)
      { set_input_idx_for_merged(inputGVCFIdx, gamgee::missing_values::int32, mergedIdx); }

      protected:
      //Only inherited classes should call constructor,destructor etc
      MergedVCFLUTBase(); 
      MergedVCFLUTBase(unsigned numInputGVCFs, unsigned numMergedFields);
      ~MergedVCFLUTBase() = default;
      void clear();

      unsigned m_num_input_vcfs;
      unsigned m_num_merged_fields;

      template <bool M = inputs_2_merged_LUT_is_input_ordered, typename std::enable_if<M>::type* = nullptr>
      void resize_inputs_2_merged_lut_if_needed(unsigned numInputGVCFs, unsigned numMergedFields)
      { resize_and_reset_lut(m_inputs_2_merged_lut, numInputGVCFs, numMergedFields, m_num_input_vcfs, m_num_merged_fields); }

      template <bool M = inputs_2_merged_LUT_is_input_ordered, typename std::enable_if<!M>::type* = nullptr>
      void resize_inputs_2_merged_lut_if_needed(unsigned numInputGVCFs, unsigned numMergedFields)
      { resize_and_reset_lut(m_inputs_2_merged_lut, numMergedFields, numInputGVCFs, m_num_merged_fields, m_num_input_vcfs); }

      template <bool M = merged_2_inputs_LUT_is_input_ordered, typename std::enable_if<M>::type* = nullptr>
      void resize_merged_2_inputs_lut_if_needed(unsigned numInputGVCFs, unsigned numMergedFields)
      { resize_and_reset_lut(m_merged_2_inputs_lut, numInputGVCFs, numMergedFields, m_num_input_vcfs, m_num_merged_fields); }

      template <bool M = merged_2_inputs_LUT_is_input_ordered, typename std::enable_if<!M>::type* = nullptr>
      void resize_merged_2_inputs_lut_if_needed(unsigned numInputGVCFs, unsigned numMergedFields)
      { resize_and_reset_lut(m_merged_2_inputs_lut, numMergedFields, numInputGVCFs, m_num_merged_fields, m_num_input_vcfs); }

      /*
       * @brief wrapper around single LUT resize functions
       */
      void resize_luts_if_needed(unsigned numInputGVCFs, unsigned numMergedFields)
      {
        resize_merged_2_inputs_lut_if_needed(numInputGVCFs, numMergedFields);
        resize_inputs_2_merged_lut_if_needed(numInputGVCFs, numMergedFields);
      }
      private:
      //why not unordered_map? because I feel the need, the need for speed
      std::vector<std::vector<int>> m_inputs_2_merged_lut;
      std::vector<std::vector<int>> m_merged_2_inputs_lut;
      void reset_vector(std::vector<int>& vec, unsigned from=0u);
      void resize_and_reset_vector(std::vector<int>& vec, unsigned new_size);
      void resize_and_reset_lut(std::vector<std::vector<int>>& lut, unsigned new_lut_size, unsigned new_size, unsigned& numRowsVar, unsigned& numColsVar);

      inline int get_lut_value(const std::vector<std::vector<int>>& lut, int rowIdx, int columnIdx) const
      {
        assert(rowIdx >= 0);
        assert(rowIdx < static_cast<int>(lut.size()));
        assert(columnIdx >= 0);
        assert(columnIdx < static_cast<int>(lut[rowIdx].size()));
        return lut[rowIdx][columnIdx];
      }

      inline void set_lut_value(std::vector<std::vector<int>>& lut, int rowIdx, int columnIdx, int value)
      {
        assert(rowIdx >= 0);
        assert(rowIdx < static_cast<int>(lut.size()));
        assert(columnIdx >= 0);
        assert(columnIdx < static_cast<int>(lut[rowIdx].size()));
        lut[rowIdx][columnIdx] = value;
      }

      template <bool M = inputs_2_merged_LUT_is_input_ordered, typename std::enable_if<M>::type* = nullptr>
      inline void set_merged_idx_for_input(unsigned inputGVCFIdx, int inputIdx, int mergedIdx)
      { set_lut_value(m_inputs_2_merged_lut, inputGVCFIdx, inputIdx, mergedIdx); } 

      template <bool M = inputs_2_merged_LUT_is_input_ordered, typename std::enable_if<!M>::type* = nullptr>
      inline void set_merged_idx_for_input(unsigned inputGVCFIdx, int inputIdx, int mergedIdx)
      { set_lut_value(m_inputs_2_merged_lut, inputIdx, inputGVCFIdx, mergedIdx); } 

      template <bool M = merged_2_inputs_LUT_is_input_ordered, typename std::enable_if<M>::type* = nullptr>
      inline void set_input_idx_for_merged(unsigned inputGVCFIdx, int inputIdx, int mergedIdx)
      { set_lut_value(m_merged_2_inputs_lut, inputGVCFIdx, mergedIdx, inputIdx); }

      template <bool M = merged_2_inputs_LUT_is_input_ordered, typename std::enable_if<!M>::type* = nullptr>
      inline void set_input_idx_for_merged(unsigned inputGVCFIdx, int inputIdx, int mergedIdx)
      { set_lut_value(m_merged_2_inputs_lut, mergedIdx, inputGVCFIdx, inputIdx); }

    };

    template<bool inputs_2_merged_LUT_is_input_ordered, bool merged_2_inputs_LUT_is_input_ordered>
    class MergedVCFAllelesIdxLUT
    : public MergedVCFLUTBase<inputs_2_merged_LUT_is_input_ordered, merged_2_inputs_LUT_is_input_ordered>
    {
      private:
        static const auto m_DEFAULT_INIT_NUM_ALLELES=10u;
      public:
        MergedVCFAllelesIdxLUT(unsigned numInputGVCFs)
          : MergedVCFLUTBase<inputs_2_merged_LUT_is_input_ordered, merged_2_inputs_LUT_is_input_ordered>(numInputGVCFs,
              m_DEFAULT_INIT_NUM_ALLELES)
          { m_max_num_alleles = m_DEFAULT_INIT_NUM_ALLELES; }
        inline void resize_luts_if_needed(unsigned numMergedAlleles)
        {
          if(numMergedAlleles > m_max_num_alleles)
          {
            MergedVCFLUTBase<inputs_2_merged_LUT_is_input_ordered, merged_2_inputs_LUT_is_input_ordered>::resize_luts_if_needed(
                MergedVCFLUTBase<inputs_2_merged_LUT_is_input_ordered, merged_2_inputs_LUT_is_input_ordered>::m_num_input_vcfs, numMergedAlleles); 
            m_max_num_alleles = numMergedAlleles;
          }
        }
      private:
        unsigned m_max_num_alleles;
    };

    /*NOTE: Needs explicit instantiation in .cpp file to use this type alias*/
    using CombineAllelesLUT = MergedVCFAllelesIdxLUT<true,true>;
  }
}

#endif