columnar_vcf_reader.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  $Id: columnar_vcf_reader.cpp 47464 2023-04-20 00:19:10Z evgeniev $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Authors:  Andrea Asztalos, Anatoliy Kuznetsov
 *
 * File Description:
 *   
 *
 */
 
#include <ncbi_pch.hpp>
#include <objects/seqloc/Seq_id.hpp>
#include <connect/ncbi_conn_exception.hpp>
#include <util/line_reader.hpp>
#include <util/bitset/ncbi_bitset.hpp>
#include <util/bitset/bmsparsevec_serial.h>
#include <util/bitset/bmdbg.h>
#include <objtools/edit/parse_text_options.hpp>
#include <objtools/readers/line_error.hpp>
#include <objtools/readers/message_listener.hpp>
#include <gui/widgets/loaders/columnar_vcf_ex.hpp>
#include <gui/widgets/loaders/columnar_vcf_reader.hpp>
 
#include <chrono>
#include <numeric>
#include <future>
 
BEGIN_NCBI_SCOPE
USING_SCOPE(objects);
 
const Uint8 kAsyncVarsThreshold = 100;
 
// SVcfFieldData
SVcfFieldData::SVcfFieldData(const string& line)
{
    edit::CParseTextOptions options;
    options.SetStartText("ID=");
    options.SetStopText(",");
    m_Name = options.GetSelectedText(line);
 
    options.SetStartText(",Number=");
    options.SetStopText(",");
    m_Number = options.GetSelectedText(line);
 
    options.SetStartText(",Description=\"");
    options.SetStopText("\"");
    m_Description = options.GetSelectedText(line);
}
 
// CColumnarVCFReader
 
bool CColumnarVCFReader::ReadHeader(CNcbiIstream& in, ICanceled* canceled, ILineErrorListener* listener)
{
    CStreamLineReader reader(in);
    unsigned nr_lines = 0;
 
    x_ResetInfo();
 
   do {
        if (nr_lines % 200 == 0 && (canceled && canceled->IsCanceled())) {
            x_ResetInfo();
            return false;
        }
        
        ++reader;
        CTempString line = *reader;
        if (line.empty()) {
            continue;
        }
 
        if (!NStr::StartsWith(line, "#"))
            break;
 
        if (NStr::StartsWith(line, "##fileformat")) {
            // it is required to be present: https://samtools.github.io/hts-specs/VCFv4.3.pdf
            m_VCFversion = line.substr(CTempString("##fileformat=").length());
        }
        else if (NStr::StartsWith(line, "##reference")) {
            // the reference genome used to generate the VCF file
            m_ReferenceLine = line.substr(CTempString("##reference=").length());
            if (!m_ReferenceLine.empty()) {
                if (m_ReferenceLine.find(":/") == NPOS) {
                    m_Assembly = m_ReferenceLine;
                }
                else {
                    edit::CParseTextOptions options;
                    options.SetStartText("accession=");
                    options.SetStopText(",");
                    m_Assembly = options.GetSelectedText(line);
                    if (m_Assembly.empty()) {
                        options.SetStopText(">");
                        m_Assembly = options.GetSelectedText(line);
                    }
                }
            }
        }
        else if (NStr::StartsWith(line, "##INFO")) {
            CConstRef<SVcfFieldData> field_data(new SVcfFieldData(line));
            auto found_it = find_if(m_InfoFields.begin(), m_InfoFields.end(),
                [&field_data](const CConstRef<SVcfFieldData>& data) { return data->m_Name == field_data->m_Name; });
            if (found_it == m_InfoFields.end()) {
                m_InfoFields.insert(field_data);
            }
        }
        else if (NStr::StartsWith(line, "#CHROM")) {
            x_GatherSampleColNames(line, listener, static_cast<unsigned int>(reader.GetLineNumber()));
        }
   } while (reader.PeekChar() == '#');
 
    if (m_VCFversion.empty()) {
        AutoPtr<CObjReaderLineException> err(
            CObjReaderLineException::Create(
                eDiag_Critical,
                1,
                "Line starting with ##fileformat is missing",
                ILineError::eProblem_GeneralParsingError));
        x_ProcessCriticalError(*err, listener);
    }
    return true;
}
 
void CColumnarVCFReader::x_GatherSampleColNames(const string& header_line, ILineErrorListener* listener, unsigned line_nr)
{
    if (!NStr::StartsWith(header_line, "#CHROM")) {
        return;
    }
 
    m_SampleCols.clear();
    if (header_line.find(" ") != NPOS || header_line.find("\t") == NPOS) {
        AutoPtr<CObjReaderLineException> err(
            CObjReaderLineException::Create(
                eDiag_Critical,
                line_nr,
                "Header line expected to be tab delimited",
                ILineError::eProblem_GeneralParsingError));
        x_ProcessError(*err, listener);
    }
    vector<string> col_names;
    NStr::Split(header_line, "\t", col_names);
 
    bool is_unique = false;
    {
        set<string> unique_strs(col_names.begin(), col_names.end());
        is_unique = (col_names.size() == unique_strs.size());
    }
    // Duplicate Sample IDS are not allowed (https://samtools.github.io/hts-specs/VCFv4.2.pdf)
    if (!is_unique) {
        AutoPtr<CObjReaderLineException> err(
            CObjReaderLineException::Create(
                eDiag_Critical,
                line_nr,
                "Column names are not unique",
                ILineError::eProblem_GeneralParsingError));
        x_ProcessError(*err, listener);
    }
 
    auto it = col_names.begin();
    for (; it != col_names.end(); ++it) {
        if (*it == CVCFVariantsBase::sm_FORMAT) {
            ++it;
            break;
        }
    }
 
    unsigned index = 0;
    for (; it != col_names.end(); ++it, ++index) {
        m_SampleCols.emplace(index, *it);
    }
}
 
// From ReaderBase
void CColumnarVCFReader::x_ProcessWarning(CObjReaderLineException& err, ILineErrorListener* error_cont)
{
    if (!error_cont) {
        LOG_POST(Error << err.GetLine() << ": " << err.SeverityStr() << err.Message());
        return;
    }
    if (!error_cont->PutError(err)) {
        err.Throw();
    }
}
 
// From ReaderBase
void CColumnarVCFReader::x_ProcessError(CObjReaderLineException& err, ILineErrorListener* error_cont)
{
    if (!error_cont) {
        err.Throw();
    }
    if (!error_cont->PutError(err)) {
        AutoPtr<CObjReaderLineException> pErr(
            CObjReaderLineException::Create(
                eDiag_Critical,
                0,
                "Error allowance exceeded",
                ILineError::eProblem_GeneralParsingError));
        pErr->Throw();
    }
}
 
void CColumnarVCFReader::x_ProcessCriticalError(CObjReaderLineException& err, ILineErrorListener* error_cont)
{
    if (!error_cont) {
        err.Throw();
    }
    bool placed = error_cont->PutError(err);
    if (placed) {
        err.Throw();
    } else {
        AutoPtr<CObjReaderLineException> pErr(
            CObjReaderLineException::Create(
                eDiag_Critical,
                0,
                "Error allowance exceeded",
                ILineError::eProblem_GeneralParsingError));
        pErr->Throw();
    }
}
 
bool CColumnarVCFReader::ReadData(CNcbiIstream& in, ICanceled* canceled, ILineErrorListener* listener, TReportProgress prog_func, TOnVCFVariantListReady on_variants_list_ready)
{
    auto start = chrono::steady_clock::now();
    m_ChromosomeMap.clear();
 
    unsigned nr_lines = 0;
    unsigned lines_per_contig = 0;
 
    CVCFVariantList *vars_list{ nullptr };
    string previous_chrom;
    
    vector<future<void>> async_calls;
    auto JoinOptimization = [&async_calls]()
    {
        // Wait for the optimization to complete
        for (auto& task : async_calls) {
            task.get();
        }
    };
 
    auto OptimizeVariantsList = [on_variants_list_ready](CRef<CVCFVariantList> &var_map) {
        auto chr = var_map->GetChrName();
        auto task_start = chrono::steady_clock::now();
        {
            auto opt_start = chrono::steady_clock::now();
            var_map->FinalizeReading();
            auto diff_opt = chrono::steady_clock::now() - opt_start;
            LOG_POST(Info << "Optimization of " << chr << " took " << chrono::duration_cast<chrono::milliseconds>(diff_opt).count() << " ms");
        }
        if (on_variants_list_ready) {
            on_variants_list_ready(*var_map);
            var_map.Reset();
        }
        auto diff_opt = chrono::steady_clock::now() - task_start;
        //LOG_POST(Info << "Processing of " << chr << " took " << chrono::duration_cast<chrono::milliseconds>(diff_opt).count() << " ms");
    };
 
    string line;
    while (in.good() && !in.eof()) {
        if (nr_lines % 1000 == 0 && (canceled && canceled->IsCanceled())) {
            x_InterruptReading();
            return false;
        }
 
        NcbiGetlineEOL(in, line);
        nr_lines++;
 
        if (NStr::StartsWith(line, "#CHROM")) {
            x_ProcessHeaderLine(line, nr_lines, listener);
            continue;
        }
        
        // ignore empty and comment lines
        if (line.empty() || (!line.empty() && line[0] == '#')) {
            continue;
        }
 
        if (line.find("\t") == NPOS) {
            AutoPtr<CObjReaderLineException> err(
                CObjReaderLineException::Create(
                    eDiag_Warning,
                    nr_lines,
                    "Has been skipped as it is not tab delimited:\n" + line,
                    ILineError::eProblem_GeneralParsingError));
            x_ProcessWarning(*err, listener);
            continue;
        }
 
        size_t pos = line.find("\t");
        string chrom = line.substr(0, pos);
        if (chrom != previous_chrom) {
            if (!previous_chrom.empty()) {
                if (lines_per_contig > kAsyncVarsThreshold)
                    async_calls.push_back(async(std::launch::async | std::launch::deferred, OptimizeVariantsList, std::ref(m_ChromosomeMap.at(previous_chrom))));
                else
                    OptimizeVariantsList(m_ChromosomeMap.at(previous_chrom));
            }
            previous_chrom = chrom;
            lines_per_contig = 0;
        
            if (m_ChromosomeMap.find(chrom) == m_ChromosomeMap.end()) {
                auto inserted = m_ChromosomeMap.emplace(chrom,
                    new CVCFVariantList(chrom, m_LoadAllInfo, m_LoadInfoFields, m_SampleCols));
                vars_list = inserted.first->second.GetPointer();
            }
            else {
                AutoPtr<CObjReaderLineException> err(
                    CObjReaderLineException::Create(
                        eDiag_Warning,
                        nr_lines,
                        chrom + " data line found out of its block. All entries for a specific CHROM should form a contiguous block within the VCF file.",
                        ILineError::eProblem_GeneralParsingError));
                x_ProcessError(*err, listener);
                continue;
            }
        }
 
        if (prog_func && lines_per_contig > 0 && lines_per_contig % 500000 == 0) {
            string progress = "Parsed " + NStr::UInt8ToString(lines_per_contig) + " lines";
            prog_func(progress);
        }
 
        try {
            _ASSERT(vars_list);
            vars_list->ParseLine(line);
            lines_per_contig++;
        }
        catch (const CException& e) {
            AutoPtr<CObjReaderLineException> err(
                CObjReaderLineException::Create(
                    eDiag_Warning,
                    nr_lines,
                    e.GetMsg(),
                    ILineError::eProblem_GeneralParsingError));
            x_ProcessWarning(*err, listener);
        }
    }
 
    auto diff_parsing = chrono::steady_clock::now() - start;
    LOG_POST(Info << "Parsed " << nr_lines << " lines from VCF file in "
        << chrono::duration_cast<chrono::milliseconds>(diff_parsing).count() << " ms ");
 
    if (canceled && canceled->IsCanceled()) {
        x_InterruptReading();
        // Wait for the optimization to complete
        JoinOptimization();
        return false;
    }
 
    if (!in.eof() && !in.good()) {
        LOG_POST(Error << "Reading cannot be completed, as input stream is corrupted");
 
        x_InterruptReading();
        // Wait for the optimization to complete
        JoinOptimization();
        NCBI_THROW(CIO_Exception, eUnknown, "Failed to read all variants from file");
    }
 
    if (!previous_chrom.empty() && m_ChromosomeMap.at(previous_chrom)) {
        OptimizeVariantsList(m_ChromosomeMap.at(previous_chrom));
    }
    // Wait for the optimization to complete
    JoinOptimization();
    if (on_variants_list_ready) {
        // Chromosomes were processed in the callback and the list can be released
        m_ChromosomeMap.clear();
    }
 
    return true;
}
 
unsigned CColumnarVCFReader::x_ProcessHeaderLine(const string& header_line, unsigned line_nr, ILineErrorListener* listener)
{
    _ASSERT(NStr::StartsWith(header_line, "#CHROM"));
 
    if (header_line.find(" ") != NPOS || header_line.find("\t") == NPOS) {
        AutoPtr<CObjReaderLineException> err(
            CObjReaderLineException::Create(
                eDiag_Critical,
                line_nr,
                "Header line is expected to be tab delimited",
                ILineError::eProblem_GeneralParsingError));
        x_ProcessCriticalError(*err, listener);
    }
 
    // the number of mandatory columns of a VCF file
    const unsigned kMandatoryCols = 8;
    unsigned nr_tabs = static_cast<unsigned>(count(header_line.begin(), header_line.end(), '\t'));
    if (nr_tabs + 1 < kMandatoryCols) {
        AutoPtr<CObjReaderLineException> err(
            CObjReaderLineException::Create(
                eDiag_Critical,
                line_nr,
                "Header line is expected to have at least 8 columns",
                ILineError::eProblem_GeneralParsingError));
        x_ProcessCriticalError(*err, listener);
    }
 
    x_GetSamplesToLoad(header_line, listener, line_nr);
    return nr_tabs;
}
 
void CColumnarVCFReader::x_InterruptReading()
{
    m_ChromosomeMap.clear();
}
 
void CColumnarVCFReader::x_ResetInfo()
{
    m_VCFversion.resize(0);
    m_ReferenceLine.resize(0);
    m_Assembly.resize(0);
    m_InfoFields.clear();
    m_SampleCols.clear();
}
 
void CColumnarVCFReader::x_GetSamplesToLoad(const string& header_line, ILineErrorListener* listener, unsigned line_nr)
{
    m_SampleCols.clear();
    if (m_LoadAllSamples) {
        if (m_LoadSamples.empty()) {
            x_GatherSampleColNames(header_line, listener, line_nr);
        }
        else {
            m_SampleCols = m_LoadSamples;
        }
    }
    else {
        if (m_LoadSamples.empty()) {
            m_SampleCols.clear();
        }
        else {
            m_SampleCols = m_LoadSamples;
        }
    }
}
 
vector<CColumnarVCFReader::TSeqIdVarsListPair>
CColumnarVCFReader::ReadVariantsForChrs(CNcbiIstream& in, 
    const vector<pair<CConstRef<CSeq_id>, vector<string>>>& chr_list,
    ICanceled* canceled, 
    ILineErrorListener* listener, 
    TReportProgress prog_func,
    TOnVCFVariantListReady on_variants_list_ready)
{
    vector<pair<CConstRef<CSeq_id>, CRef<CVCFVariantList>>> variants_list;
    
    auto start = chrono::steady_clock::now();
 
    unsigned nr_lines = 0;
    unsigned lines_per_contig = 0;
 
    CRef<CVCFVariantList> vcf_vars;
    size_t search_chrs = chr_list.size();
    string prev_chrom;  // chromosome from the previous line
 
    vector<future<void>> async_calls;
    auto JoinOptimization = [&async_calls]()
    {
        // Wait for the optimization to complete
        for (auto& task : async_calls) {
            task.get();
        }
    };
 
    auto OptimizeVariantsList = [on_variants_list_ready](CRef<CVCFVariantList> var_map) {
        auto chr = var_map->GetChrName();
        auto task_start = chrono::steady_clock::now();
        {
            auto opt_start = chrono::steady_clock::now();
            var_map->FinalizeReading();
            auto diff_opt = chrono::steady_clock::now() - opt_start;
            LOG_POST(Info << "Optimization of " << chr << " took " << chrono::duration_cast<chrono::milliseconds>(diff_opt).count() << " ms");
        }
        if (on_variants_list_ready) {
            on_variants_list_ready(*var_map);
            var_map.Reset();
        }
        auto diff_opt = chrono::steady_clock::now() - task_start;
        //LOG_POST(Info << "Processing of " << chr << " took " << chrono::duration_cast<chrono::milliseconds>(diff_opt).count() << " ms");
    };
 
    auto CallOptimizeVarsList = [&]() {
        if (lines_per_contig > kAsyncVarsThreshold)
            async_calls.push_back(async(std::launch::async | std::launch::deferred, OptimizeVariantsList, vcf_vars));
        else
            OptimizeVariantsList(vcf_vars);
    };
 
    string line;
    while (in.good() && !in.eof() && search_chrs > 0) {
        if (nr_lines % 1000 == 0 && (canceled && canceled->IsCanceled())) {
            // Wait for the optimization to complete
            JoinOptimization();
            variants_list.clear();
            return variants_list;
        }
 
        NcbiGetlineEOL(in, line);
        nr_lines++;
 
        if (NStr::StartsWith(line, "#CHROM")) {
            x_ProcessHeaderLine(line, nr_lines, listener);
            continue;
        }
 
        // ignore empty and comment lines
        if (line.empty() || (!line.empty() && line[0] == '#')) {
            continue;
        }
 
        if (line.find("\t") == NPOS) {
            AutoPtr<CObjReaderLineException> err(
                CObjReaderLineException::Create(
                    eDiag_Warning,
                    nr_lines,
                    "Has been skipped as it is not tab delimited:\n" + line,
                    ILineError::eProblem_GeneralParsingError));
            x_ProcessWarning(*err, listener);
            continue;
        }
 
        size_t pos = line.find("\t");
        string chrom = line.substr(0, pos);
        if (!vcf_vars || (vcf_vars && !NStr::EqualCase(vcf_vars->GetChrName(), chrom))) {
            if (prev_chrom == chrom)
                continue;
 
            bool found = false;
            for (const auto& syn_it : chr_list) {
                const auto& seq_id = syn_it.first;
                const auto& synonyms = syn_it.second;
                if (find_if(synonyms.begin(), synonyms.end(),
                    [&chrom](const string& elem) { return NStr::EqualCase(chrom, elem); }) != synonyms.end()) {
 
                    found = true;
                    if (vcf_vars) {
                        CallOptimizeVarsList();
                        lines_per_contig = 0;
                        vcf_vars.Release();
                    }
 
                    if (find_if(variants_list.begin(), variants_list.end(),
                        [&seq_id](const TSeqIdVarsListPair& elem) { return (seq_id->AsFastaString() == elem.first->AsFastaString()); }) == variants_list.end()) {
                        variants_list.emplace_back(seq_id, new CVCFVariantList(chrom, m_LoadAllInfo, m_LoadInfoFields, m_SampleCols));
                        vcf_vars = variants_list.back().second;
                    }
                    else {
                        AutoPtr<CObjReaderLineException> err(
                            CObjReaderLineException::Create(
                                eDiag_Warning,
                                nr_lines,
                                chrom + " data line found out of its block. All entries for a specific CHROM should form a contiguous block within the VCF file.",
                                ILineError::eProblem_GeneralParsingError));
                        x_ProcessError(*err, listener);
                    }
                    
                    break;
                }
            }
            if (!found) {
                if (vcf_vars) {
                    CallOptimizeVarsList();
                    vcf_vars.Release();
                    vcf_vars.Reset(nullptr);
                    search_chrs--;
                }
                prev_chrom = chrom;
                lines_per_contig = 0;
            }
        }
 
        if (vcf_vars) {
            if (prog_func && lines_per_contig > 0 && lines_per_contig % 500000 == 0) {
                string progress = "Parsed " + NStr::UInt8ToString(lines_per_contig) + " lines";
                prog_func(progress);
            }
            try {
                vcf_vars->ParseLine(line);
                lines_per_contig++;
            }
            catch (const CException& e) {
                AutoPtr<CObjReaderLineException> err(
                    CObjReaderLineException::Create(
                        eDiag_Warning,
                        nr_lines,
                        e.GetMsg(),
                        ILineError::eProblem_GeneralParsingError));
                x_ProcessWarning(*err, listener);
            }
            if ((m_VariationsLimit > 0) && (lines_per_contig > m_VariationsLimit)) {
                AutoPtr<CObjReaderLineException> err(
                    CObjReaderLineException::Create(
                        eDiag_Critical,
                        m_VariationsLimit,
                        "The file exceeds the limit of " + NStr::UIntToString(m_VariationsLimit) + " variations per chromosome.",
                        ILineError::eProblem_GeneralParsingError));
                x_ProcessCriticalError(*err, listener);
                break;
            }
        }
    }
        
    auto diff_parsing = chrono::steady_clock::now() - start;
    LOG_POST(Info << "Parsed " << nr_lines << " lines in "
        << chrono::duration_cast<chrono::milliseconds>(diff_parsing).count() << " ms ");
 
    if (canceled && canceled->IsCanceled()) {
        // Wait for the optimization to complete
        JoinOptimization();
        variants_list.clear();
        return variants_list;
    }
 
    if (!in.good() && !in.eof()) {
        LOG_POST(Error << "Reading cannot be completed, as input stream is corrupted");
 
        // Wait for the optimization to complete
        JoinOptimization();
        variants_list.clear();
        NCBI_THROW(CIO_Exception, eUnknown, "Failed to read all variants from file");
    }
 
    if (vcf_vars) {
        OptimizeVariantsList(vcf_vars);
    }
    // Wait for the optimization to complete
    JoinOptimization();
 
    if (chr_list.size() != variants_list.size()) {
        for (const auto& chr_it : chr_list) {
            if (find_if(variants_list.begin(), variants_list.end(), 
                [&chr_it](const pair<CConstRef<CSeq_id>, CRef<CVCFVariantList>>& elem) 
                { return elem.first->Equals(*chr_it.first); }) == variants_list.end()) {
 
                auto id_str = chr_it.first->AsFastaString();
                AutoPtr<CObjReaderLineException> err(
                    CObjReaderLineException::Create(
                        eDiag_Warning,
                        nr_lines,
                        "Chromosome " + id_str + " is not in the file",
                        ILineError::eProblem_GeneralParsingError));
                x_ProcessWarning(*err, listener);
            }
        }
    }
 
    if (!on_variants_list_ready) {
        for (auto& var_it : variants_list) {
            m_ChromosomeMap.emplace(var_it.second->GetChrName(), var_it.second);
        }
    }
 
    return variants_list;
}
 
vector<string> CColumnarVCFReader::GetChromosomeNames() const
{
    vector<string> names;
    for (const auto& it : m_ChromosomeMap) {
        names.push_back(it.first);
    }
    return names;
}
 
CRef<CVCFVariantList> CColumnarVCFReader::GetVariantsForChr(const string& chr_name) const
{
    auto it = m_ChromosomeMap.find(chr_name);
    if (it != m_ChromosomeMap.end()) {
        return it->second;
    }
    return CRef<CVCFVariantList>();
}
 
// CColumnarVCFReaderTest
 
void CColumnarVCFReaderTest::GetStatistics(CNcbiOstream& out)
{
    for (auto& it : m_ChromosomeMap) {
        it.second->GetStatistics(out);
    }
}
 
void CColumnarVCFReaderTest::SerializeToDisk(const string& prefix, CNcbiOstream* out)
{
    for (auto&& it : m_ChromosomeMap) {
        it.second->SerializeVariantData(prefix, out);
    }
}
 
void CColumnarVCFReaderTest::Deserialize(const string& prefix, CNcbiOstream* out)
{
    for (auto&& it : m_ChromosomeMap) {
        it.second->DeserializeAndCheck(prefix, out);
    }
}
 
void CColumnarVCFReaderTest::ListColumns(CNcbiOstream& out, bool only_sv_cols)
{
    for (const auto& it : m_ChromosomeMap) {
        it.second->List(out, only_sv_cols);
    }
}
 
void CColumnarVCFReaderTest::ListIndexVectors(CNcbiOstream& out)
{
    for (auto& it : m_ChromosomeMap) {
        it.second->ListPositionVectors(out);
    }
}
 
 
END_NCBI_SCOPE