vcf_record.hpp

Go to the documentation of this file.

#ifndef GENESIS_POPULATION_FORMATS_VCF_RECORD_H_
#define GENESIS_POPULATION_FORMATS_VCF_RECORD_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2021 Lucas Czech
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lczech@carnegiescience.edu>
    Department of Plant Biology, Carnegie Institution For Science
    260 Panama Street, Stanford, CA 94305, USA
*/
 
#ifdef GENESIS_HTSLIB
 
#include "genesis/population/formats/vcf_common.hpp"
#include "genesis/population/formats/vcf_format_iterator.hpp"
#include "genesis/population/formats/vcf_header.hpp"
#include "genesis/utils/containers/range.hpp"
 
#include <cstdint>
#include <string>
#include <vector>
 
extern "C" {
    // #include <htslib/hts.h>
    // #include <htslib/vcf.h>
 
    struct bcf1_t;
}
 
// =================================================================================================
//     Forward Declarations
// =================================================================================================
 
namespace genesis {
namespace population {
 
class HtsFile;
class VcfHeader;
 
// =================================================================================================
//     VCF/BCF Record
// =================================================================================================
 
class VcfRecord
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Enums
    // -------------------------------------------------------------------------
 
    enum class VariantType : int {
        kRef      =  0,
        kSnp      =  1,
        kMnp      =  2,
        kIndel    =  4,
        kOther    =  8,
        kBreakend = 16, // Breakend
        kOverlap  = 32, // Overlapping deletion, ALT=*
    };
 
    friend bool operator& ( VcfRecord::VariantType a, VcfRecord::VariantType b )
    {
        return ( static_cast<int>(a) & static_cast<int>(b) );
    }
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    VcfRecord();
 
    explicit VcfRecord( VcfHeader& header );
 
    VcfRecord( VcfHeader& header, ::bcf1_t* bcf1 );
 
    ~VcfRecord();
 
    VcfRecord( VcfRecord const& ) = delete;
    VcfRecord( VcfRecord&& );
 
    VcfRecord& operator= ( VcfRecord const& ) = delete;
    VcfRecord& operator= ( VcfRecord&& );
 
    void swap( VcfRecord& other );
 
    // -------------------------------------------------------------------------
    //     Accessors
    // -------------------------------------------------------------------------
 
    ::bcf1_t* data()
    {
        return record_;
    }
 
    ::bcf1_t const* data() const
    {
        return record_;
    }
 
    VcfHeader& header()
    {
        return *header_;
    }
 
    VcfHeader const& header() const
    {
        return *header_;
    }
 
    void unpack() const;
 
    // -------------------------------------------------------------------------
    //     Simple Fixed Columns
    // -------------------------------------------------------------------------
 
    std::string get_chromosome() const;
 
    size_t get_position() const;
 
    std::string get_id() const;
 
    std::string at() const;
 
    std::string get_reference() const;
 
    std::vector<std::string> get_alternatives() const;
 
    std::string get_alternative( size_t index ) const;
 
    size_t get_alternatives_count() const;
 
    std::vector<std::string> get_variants() const;
 
    std::string get_variant( size_t index ) const;
 
    size_t get_variant_count() const;
 
    VariantType get_variant_types() const;
 
    VariantType get_variant_type( size_t alt_index ) const;
 
    bool is_snp() const;
 
    double get_quality() const;
 
    // -------------------------------------------------------------------------
    //     Filter Column
    // -------------------------------------------------------------------------
 
    std::vector<std::string> get_filter_ids() const;
 
    bool has_filter( std::string const& filter ) const;
 
    bool pass_filter() const;
 
    // -------------------------------------------------------------------------
    //     Info Column
    // -------------------------------------------------------------------------
 
    std::vector<std::string> get_info_ids() const;
 
    bool has_info( std::string const& id ) const;
 
    bool has_info( char const* id ) const;
 
    void assert_info( std::string const& id ) const;
 
    void assert_info( char const* ) const;
 
    std::string get_info_string( std::string const& id ) const;
 
    void get_info_string( std::string const& id, std::string& destination ) const;
 
    std::vector<double> get_info_float( std::string const& id ) const;
 
    void get_info_float( std::string const& id, std::vector<double>& destination ) const;
 
    std::vector<int32_t> get_info_int( std::string const& id ) const;
 
    void get_info_int( std::string const& id, std::vector<int32_t>& destination ) const;
 
    bool get_info_flag( std::string const& id ) const;
 
    // -------------------------------------------------------------------------
    //     Format Column
    // -------------------------------------------------------------------------
 
    std::vector<std::string> get_format_ids() const;
 
    bool has_format( std::string const& id ) const;
 
    bool has_format( char const* id ) const;
 
    void assert_format( std::string const& id ) const;
 
    void assert_format( char const* id ) const;
 
    // -------------------------------------------------------------------------
    //     Sample Columns
    // -------------------------------------------------------------------------
 
    VcfFormatIteratorGenotype begin_format_genotype() const;
 
    VcfFormatIteratorGenotype end_format_genotype() const;
 
    genesis::utils::Range<VcfFormatIteratorGenotype> get_format_genotype() const;
 
    VcfFormatIteratorString begin_format_string( std::string const& id ) const;
 
    VcfFormatIteratorString end_format_string() const;
 
    genesis::utils::Range<VcfFormatIteratorString> get_format_string( std::string const& id ) const;
 
    VcfFormatIteratorInt begin_format_int( std::string const& id ) const;
 
    VcfFormatIteratorInt end_format_int() const;
 
    genesis::utils::Range<VcfFormatIteratorInt> get_format_int( std::string const& id ) const;
 
    VcfFormatIteratorFloat begin_format_float( std::string const& id ) const;
 
    VcfFormatIteratorFloat end_format_float() const;
 
    genesis::utils::Range<VcfFormatIteratorFloat> get_format_float( std::string const& id ) const;
 
    // -------------------------------------------------------------------------
    //     Modifiers
    // -------------------------------------------------------------------------
 
    bool read_next( HtsFile& source );
 
    // -------------------------------------------------------------------------
    //     Internal Members
    // -------------------------------------------------------------------------
 
private:
 
    int get_info_ptr_( std::string const& id, int ht_type, void** dest, int* ndest ) const;
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    // Here, we only manage the record_ pointer instance. The header takes care of itself,
    // and is only pointed to from here, but not managed.
    VcfHeader* header_ = nullptr;
    mutable ::bcf1_t* record_ = nullptr;
 
    // htslib wants to copy values all the time, so we reserve buffers to avoid reallocations.
    mutable char*    info_dest_string_  = nullptr;
    mutable float*   info_dest_float_   = nullptr;
    mutable int32_t* info_dest_int_     = nullptr;
    mutable int      info_ndest_string_ = 0;
    mutable int      info_ndest_float_  = 0;
    mutable int      info_ndest_int_    = 0;
};
 
} // namespace population
} // namespace genesis
 
#endif // htslib guard
#endif // include guard