Commit 5ceb935b authored by Haowen Zhang's avatar Haowen Zhang
Browse files

Move temp mapping file handle to a separate header.

parent df421278

src/chromap.h

+1 −0
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
#include "ksort.h"

#include "output_tools.h"

#include "sequence_batch.h"

#include "temp_mapping.h"



#define CHROMAP_VERSION "0.1.3-r257"

src/output_tools.h

+0 −244
Original line number Diff line number Diff line
@@ -34,250 +34,6 @@ bool ReadIdLess(const std::pair<uint32_t, MappingRecord> &a, 
  return a.second.read_id_ < b.second.read_id_;

}



template <typename MappingRecord>

struct TempMappingFileHandle {

  std::string file_path;

  FILE *file;

  bool all_loaded;

  uint32_t num_mappings;

  uint32_t block_size;

  uint32_t current_rid;

  uint32_t current_mapping_index;

  uint32_t num_mappings_on_current_rid;

  uint32_t num_loaded_mappings_on_current_rid;

  std::vector<MappingRecord>

      mappings;  // this vector only keep mappings on the same ref seq

  inline void InitializeTempMappingLoading(uint32_t num_reference_sequences) {

    file = fopen(file_path.c_str(), "rb");

    assert(file != NULL);

    all_loaded = false;

    current_rid = 0;

    fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

    mappings.resize(block_size);

    num_loaded_mappings_on_current_rid = 0;

    // std::cerr << "Block size: " << block_size << ", initialize temp file " <<

    // file_path << "\n";

  }

  inline void FinalizeTempMappingLoading() { fclose(file); }

  inline void LoadTempMappingBlock(uint32_t num_reference_sequences) {

    num_mappings = 0;

    while (num_mappings == 0) {

      // Only keep mappings on one ref seq, which means # mappings in buffer can

      // be less than block size Two cases: current ref seq has remainings or

      // not

      if (num_loaded_mappings_on_current_rid < num_mappings_on_current_rid) {

        // Check if # remains larger than block size

        uint32_t num_mappings_to_load_on_current_rid =

            num_mappings_on_current_rid - num_loaded_mappings_on_current_rid;

        if (num_mappings_to_load_on_current_rid > block_size) {

          num_mappings_to_load_on_current_rid = block_size;

        }

        // std::cerr << num_mappings_to_load_on_current_rid << " " <<

        // num_loaded_mappings_on_current_rid << " " <<

        // num_mappings_on_current_rid << "\n"; std::cerr << mappings.size() <<

        // "\n";

        fread(mappings.data(), sizeof(MappingRecord),

              num_mappings_to_load_on_current_rid, file);

        // std::cerr << "Load mappings\n";

        num_loaded_mappings_on_current_rid +=

            num_mappings_to_load_on_current_rid;

        num_mappings = num_mappings_to_load_on_current_rid;

      } else {

        // Move to next rid

        ++current_rid;

        if (current_rid < num_reference_sequences) {

          // std::cerr << "Load size\n";

          fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

          // std::cerr << "Load size " << num_mappings_on_current_rid << "\n";

          num_loaded_mappings_on_current_rid = 0;

        } else {

          all_loaded = true;

          break;

        }

      }

    }

    current_mapping_index = 0;

  }

  inline void Next(uint32_t num_reference_sequences) {

    ++current_mapping_index;

    if (current_mapping_index >= num_mappings) {

      LoadTempMappingBlock(num_reference_sequences);

    }

  }

};



template <>

inline void TempMappingFileHandle<PAFMapping>::LoadTempMappingBlock(

    uint32_t num_reference_sequences) {

  num_mappings = 0;

  while (num_mappings == 0) {

    // Only keep mappings on one ref seq, which means # mappings in buffer can

    // be less than block size Two cases: current ref seq has remainings or not

    if (num_loaded_mappings_on_current_rid < num_mappings_on_current_rid) {

      // Check if # remains larger than block size

      uint32_t num_mappings_to_load_on_current_rid =

          num_mappings_on_current_rid - num_loaded_mappings_on_current_rid;

      if (num_mappings_to_load_on_current_rid > block_size) {

        num_mappings_to_load_on_current_rid = block_size;

      }

      // std::cerr << num_mappings_to_load_on_current_rid << " " <<

      // num_loaded_mappings_on_current_rid << " " <<

      // num_mappings_on_current_rid

      // << "\n"; std::cerr << mappings.size() << "\n";

      for (size_t mi = 0; mi < num_mappings_to_load_on_current_rid; ++mi) {

        mappings[mi].LoadFromFile(file);

      }

      // fread(mappings.data(), sizeof(MappingRecord),

      // num_mappings_to_load_on_current_rid, file); std::cerr << "Load

      // mappings\n";

      num_loaded_mappings_on_current_rid += num_mappings_to_load_on_current_rid;

      num_mappings = num_mappings_to_load_on_current_rid;

    } else {

      // Move to next rid

      ++current_rid;

      if (current_rid < num_reference_sequences) {

        // std::cerr << "Load size\n";

        fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

        // std::cerr << "Load size " << num_mappings_on_current_rid << "\n";

        num_loaded_mappings_on_current_rid = 0;

      } else {

        all_loaded = true;

        break;

      }

    }

  }

  current_mapping_index = 0;

}



template <>

inline void TempMappingFileHandle<PairedPAFMapping>::LoadTempMappingBlock(

    uint32_t num_reference_sequences) {

  num_mappings = 0;

  while (num_mappings == 0) {

    // Only keep mappings on one ref seq, which means # mappings in buffer can

    // be less than block size Two cases: current ref seq has remainings or not

    if (num_loaded_mappings_on_current_rid < num_mappings_on_current_rid) {

      // Check if # remains larger than block size

      uint32_t num_mappings_to_load_on_current_rid =

          num_mappings_on_current_rid - num_loaded_mappings_on_current_rid;

      if (num_mappings_to_load_on_current_rid > block_size) {

        num_mappings_to_load_on_current_rid = block_size;

      }

      // std::cerr << num_mappings_to_load_on_current_rid << " " <<

      // num_loaded_mappings_on_current_rid << " " <<

      // num_mappings_on_current_rid

      // << "\n"; std::cerr << mappings.size() << "\n";

      for (size_t mi = 0; mi < num_mappings_to_load_on_current_rid; ++mi) {

        mappings[mi].LoadFromFile(file);

      }

      // fread(mappings.data(), sizeof(MappingRecord),

      // num_mappings_to_load_on_current_rid, file); std::cerr << "Load

      // mappings\n";

      num_loaded_mappings_on_current_rid += num_mappings_to_load_on_current_rid;

      num_mappings = num_mappings_to_load_on_current_rid;

    } else {

      // Move to next rid

      ++current_rid;

      if (current_rid < num_reference_sequences) {

        // std::cerr << "Load size\n";

        fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

        // std::cerr << "Load size " << num_mappings_on_current_rid << "\n";

        num_loaded_mappings_on_current_rid = 0;

      } else {

        all_loaded = true;

        break;

      }

    }

  }

  current_mapping_index = 0;

}



template <>

inline void TempMappingFileHandle<SAMMapping>::LoadTempMappingBlock(

    uint32_t num_reference_sequences) {

  num_mappings = 0;

  while (num_mappings == 0) {

    // Only keep mappings on one ref seq, which means # mappings in buffer can

    // be less than block size Two cases: current ref seq has remainings or not

    if (num_loaded_mappings_on_current_rid < num_mappings_on_current_rid) {

      // Check if # remains larger than block size

      uint32_t num_mappings_to_load_on_current_rid =

          num_mappings_on_current_rid - num_loaded_mappings_on_current_rid;

      if (num_mappings_to_load_on_current_rid > block_size) {

        num_mappings_to_load_on_current_rid = block_size;

      }

      // std::cerr << num_mappings_to_load_on_current_rid << " " <<

      // num_loaded_mappings_on_current_rid << " " <<

      // num_mappings_on_current_rid

      // << "\n"; std::cerr << mappings.size() << "\n";

      for (size_t mi = 0; mi < num_mappings_to_load_on_current_rid; ++mi) {

        mappings[mi].LoadFromFile(file);

      }

      // fread(mappings.data(), sizeof(MappingRecord),

      // num_mappings_to_load_on_current_rid, file); std::cerr << "Load

      // mappings\n";

      num_loaded_mappings_on_current_rid += num_mappings_to_load_on_current_rid;

      num_mappings = num_mappings_to_load_on_current_rid;

    } else {

      // Move to next rid

      ++current_rid;

      if (current_rid < num_reference_sequences) {

        // std::cerr << "Load size\n";

        fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

        // std::cerr << "Load size " << num_mappings_on_current_rid << "\n";

        num_loaded_mappings_on_current_rid = 0;

      } else {

        all_loaded = true;

        break;

      }

    }

  }

  current_mapping_index = 0;

}



template <>

inline void TempMappingFileHandle<PairsMapping>::LoadTempMappingBlock(

    uint32_t num_reference_sequences) {

  num_mappings = 0;

  while (num_mappings == 0) {

    // Only keep mappings on one ref seq, which means # mappings in buffer can

    // be less than block size Two cases: current ref seq has remainings or not

    if (num_loaded_mappings_on_current_rid < num_mappings_on_current_rid) {

      // Check if # remains larger than block size

      uint32_t num_mappings_to_load_on_current_rid =

          num_mappings_on_current_rid - num_loaded_mappings_on_current_rid;

      if (num_mappings_to_load_on_current_rid > block_size) {

        num_mappings_to_load_on_current_rid = block_size;

      }

      // std::cerr << num_mappings_to_load_on_current_rid << " " <<

      // num_loaded_mappings_on_current_rid << " " <<

      // num_mappings_on_current_rid

      // << "\n"; std::cerr << mappings.size() << "\n";

      for (size_t mi = 0; mi < num_mappings_to_load_on_current_rid; ++mi) {

        mappings[mi].LoadFromFile(file);

      }

      // fread(mappings.data(), sizeof(MappingRecord),

      // num_mappings_to_load_on_current_rid, file); std::cerr << "Load

      // mappings\n";

      num_loaded_mappings_on_current_rid += num_mappings_to_load_on_current_rid;

      num_mappings = num_mappings_to_load_on_current_rid;

    } else {

      // Move to next rid

      ++current_rid;

      if (current_rid < num_reference_sequences) {

        // std::cerr << "Load size\n";

        fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

        // std::cerr << "Load size " << num_mappings_on_current_rid << "\n";

        num_loaded_mappings_on_current_rid = 0;

      } else {

        all_loaded = true;

        break;

      }

    }

  }

  current_mapping_index = 0;

}



template <typename MappingRecord>

class OutputTools {

 public:

src/temp_mapping.h

0 → 100644
+267 −0
Original line number Diff line number Diff line 
#ifndef TEMPMAPPING_H_

#define TEMPMAPPING_H_



#include <assert.h>



#include <cinttypes>

#include <cstring>

#include <functional>

#include <iostream>

#include <string>

#include <vector>



#include "bed_mapping.h"

#include "mapping.h"

#include "paf_mapping.h"

#include "pairs_mapping.h"

#include "sam_mapping.h"



namespace chromap {



template <typename MappingRecord>

struct TempMappingFileHandle {

  std::string file_path;

  FILE *file;

  bool all_loaded;

  uint32_t num_mappings;

  uint32_t block_size;

  uint32_t current_rid;

  uint32_t current_mapping_index;

  uint32_t num_mappings_on_current_rid;

  uint32_t num_loaded_mappings_on_current_rid;

  std::vector<MappingRecord>

      mappings;  // this vector only keep mappings on the same ref seq

  inline void InitializeTempMappingLoading(uint32_t num_reference_sequences) {

    file = fopen(file_path.c_str(), "rb");

    assert(file != NULL);

    all_loaded = false;

    current_rid = 0;

    fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

    mappings.resize(block_size);

    num_loaded_mappings_on_current_rid = 0;

    // std::cerr << "Block size: " << block_size << ", initialize temp file " <<

    // file_path << "\n";

  }

  inline void FinalizeTempMappingLoading() { fclose(file); }

  inline void LoadTempMappingBlock(uint32_t num_reference_sequences) {

    num_mappings = 0;

    while (num_mappings == 0) {

      // Only keep mappings on one ref seq, which means # mappings in buffer can

      // be less than block size Two cases: current ref seq has remainings or

      // not

      if (num_loaded_mappings_on_current_rid < num_mappings_on_current_rid) {

        // Check if # remains larger than block size

        uint32_t num_mappings_to_load_on_current_rid =

            num_mappings_on_current_rid - num_loaded_mappings_on_current_rid;

        if (num_mappings_to_load_on_current_rid > block_size) {

          num_mappings_to_load_on_current_rid = block_size;

        }

        // std::cerr << num_mappings_to_load_on_current_rid << " " <<

        // num_loaded_mappings_on_current_rid << " " <<

        // num_mappings_on_current_rid << "\n"; std::cerr << mappings.size() <<

        // "\n";

        fread(mappings.data(), sizeof(MappingRecord),

              num_mappings_to_load_on_current_rid, file);

        // std::cerr << "Load mappings\n";

        num_loaded_mappings_on_current_rid +=

            num_mappings_to_load_on_current_rid;

        num_mappings = num_mappings_to_load_on_current_rid;

      } else {

        // Move to next rid

        ++current_rid;

        if (current_rid < num_reference_sequences) {

          // std::cerr << "Load size\n";

          fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

          // std::cerr << "Load size " << num_mappings_on_current_rid << "\n";

          num_loaded_mappings_on_current_rid = 0;

        } else {

          all_loaded = true;

          break;

        }

      }

    }

    current_mapping_index = 0;

  }

  inline void Next(uint32_t num_reference_sequences) {

    ++current_mapping_index;

    if (current_mapping_index >= num_mappings) {

      LoadTempMappingBlock(num_reference_sequences);

    }

  }

};



template <>

inline void TempMappingFileHandle<PAFMapping>::LoadTempMappingBlock(

    uint32_t num_reference_sequences) {

  num_mappings = 0;

  while (num_mappings == 0) {

    // Only keep mappings on one ref seq, which means # mappings in buffer can

    // be less than block size Two cases: current ref seq has remainings or not

    if (num_loaded_mappings_on_current_rid < num_mappings_on_current_rid) {

      // Check if # remains larger than block size

      uint32_t num_mappings_to_load_on_current_rid =

          num_mappings_on_current_rid - num_loaded_mappings_on_current_rid;

      if (num_mappings_to_load_on_current_rid > block_size) {

        num_mappings_to_load_on_current_rid = block_size;

      }

      // std::cerr << num_mappings_to_load_on_current_rid << " " <<

      // num_loaded_mappings_on_current_rid << " " <<

      // num_mappings_on_current_rid

      // << "\n"; std::cerr << mappings.size() << "\n";

      for (size_t mi = 0; mi < num_mappings_to_load_on_current_rid; ++mi) {

        mappings[mi].LoadFromFile(file);

      }

      // fread(mappings.data(), sizeof(MappingRecord),

      // num_mappings_to_load_on_current_rid, file); std::cerr << "Load

      // mappings\n";

      num_loaded_mappings_on_current_rid += num_mappings_to_load_on_current_rid;

      num_mappings = num_mappings_to_load_on_current_rid;

    } else {

      // Move to next rid

      ++current_rid;

      if (current_rid < num_reference_sequences) {

        // std::cerr << "Load size\n";

        fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

        // std::cerr << "Load size " << num_mappings_on_current_rid << "\n";

        num_loaded_mappings_on_current_rid = 0;

      } else {

        all_loaded = true;

        break;

      }

    }

  }

  current_mapping_index = 0;

}



template <>

inline void TempMappingFileHandle<PairedPAFMapping>::LoadTempMappingBlock(

    uint32_t num_reference_sequences) {

  num_mappings = 0;

  while (num_mappings == 0) {

    // Only keep mappings on one ref seq, which means # mappings in buffer can

    // be less than block size Two cases: current ref seq has remainings or not

    if (num_loaded_mappings_on_current_rid < num_mappings_on_current_rid) {

      // Check if # remains larger than block size

      uint32_t num_mappings_to_load_on_current_rid =

          num_mappings_on_current_rid - num_loaded_mappings_on_current_rid;

      if (num_mappings_to_load_on_current_rid > block_size) {

        num_mappings_to_load_on_current_rid = block_size;

      }

      // std::cerr << num_mappings_to_load_on_current_rid << " " <<

      // num_loaded_mappings_on_current_rid << " " <<

      // num_mappings_on_current_rid

      // << "\n"; std::cerr << mappings.size() << "\n";

      for (size_t mi = 0; mi < num_mappings_to_load_on_current_rid; ++mi) {

        mappings[mi].LoadFromFile(file);

      }

      // fread(mappings.data(), sizeof(MappingRecord),

      // num_mappings_to_load_on_current_rid, file); std::cerr << "Load

      // mappings\n";

      num_loaded_mappings_on_current_rid += num_mappings_to_load_on_current_rid;

      num_mappings = num_mappings_to_load_on_current_rid;

    } else {

      // Move to next rid

      ++current_rid;

      if (current_rid < num_reference_sequences) {

        // std::cerr << "Load size\n";

        fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

        // std::cerr << "Load size " << num_mappings_on_current_rid << "\n";

        num_loaded_mappings_on_current_rid = 0;

      } else {

        all_loaded = true;

        break;

      }

    }

  }

  current_mapping_index = 0;

}



template <>

inline void TempMappingFileHandle<SAMMapping>::LoadTempMappingBlock(

    uint32_t num_reference_sequences) {

  num_mappings = 0;

  while (num_mappings == 0) {

    // Only keep mappings on one ref seq, which means # mappings in buffer can

    // be less than block size Two cases: current ref seq has remainings or not

    if (num_loaded_mappings_on_current_rid < num_mappings_on_current_rid) {

      // Check if # remains larger than block size

      uint32_t num_mappings_to_load_on_current_rid =

          num_mappings_on_current_rid - num_loaded_mappings_on_current_rid;

      if (num_mappings_to_load_on_current_rid > block_size) {

        num_mappings_to_load_on_current_rid = block_size;

      }

      // std::cerr << num_mappings_to_load_on_current_rid << " " <<

      // num_loaded_mappings_on_current_rid << " " <<

      // num_mappings_on_current_rid

      // << "\n"; std::cerr << mappings.size() << "\n";

      for (size_t mi = 0; mi < num_mappings_to_load_on_current_rid; ++mi) {

        mappings[mi].LoadFromFile(file);

      }

      // fread(mappings.data(), sizeof(MappingRecord),

      // num_mappings_to_load_on_current_rid, file); std::cerr << "Load

      // mappings\n";

      num_loaded_mappings_on_current_rid += num_mappings_to_load_on_current_rid;

      num_mappings = num_mappings_to_load_on_current_rid;

    } else {

      // Move to next rid

      ++current_rid;

      if (current_rid < num_reference_sequences) {

        // std::cerr << "Load size\n";

        fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

        // std::cerr << "Load size " << num_mappings_on_current_rid << "\n";

        num_loaded_mappings_on_current_rid = 0;

      } else {

        all_loaded = true;

        break;

      }

    }

  }

  current_mapping_index = 0;

}



template <>

inline void TempMappingFileHandle<PairsMapping>::LoadTempMappingBlock(

    uint32_t num_reference_sequences) {

  num_mappings = 0;

  while (num_mappings == 0) {

    // Only keep mappings on one ref seq, which means # mappings in buffer can

    // be less than block size Two cases: current ref seq has remainings or not

    if (num_loaded_mappings_on_current_rid < num_mappings_on_current_rid) {

      // Check if # remains larger than block size

      uint32_t num_mappings_to_load_on_current_rid =

          num_mappings_on_current_rid - num_loaded_mappings_on_current_rid;

      if (num_mappings_to_load_on_current_rid > block_size) {

        num_mappings_to_load_on_current_rid = block_size;

      }

      // std::cerr << num_mappings_to_load_on_current_rid << " " <<

      // num_loaded_mappings_on_current_rid << " " <<

      // num_mappings_on_current_rid

      // << "\n"; std::cerr << mappings.size() << "\n";

      for (size_t mi = 0; mi < num_mappings_to_load_on_current_rid; ++mi) {

        mappings[mi].LoadFromFile(file);

      }

      // fread(mappings.data(), sizeof(MappingRecord),

      // num_mappings_to_load_on_current_rid, file); std::cerr << "Load

      // mappings\n";

      num_loaded_mappings_on_current_rid += num_mappings_to_load_on_current_rid;

      num_mappings = num_mappings_to_load_on_current_rid;

    } else {

      // Move to next rid

      ++current_rid;

      if (current_rid < num_reference_sequences) {

        // std::cerr << "Load size\n";

        fread(&num_mappings_on_current_rid, sizeof(size_t), 1, file);

        // std::cerr << "Load size " << num_mappings_on_current_rid << "\n";

        num_loaded_mappings_on_current_rid = 0;

      } else {

        all_loaded = true;

        break;

      }

    }

  }

  current_mapping_index = 0;

}



}  // namespace chromap



#endif  // TEMPMAPPING_H_

CRA Git | Maintained and supported by SUSTech CRA and CCSE