vcf_header.hpp

Go to the documentation of this file.

#ifndef GENESIS_POPULATION_FORMAT_VCF_HEADER_H_
#define GENESIS_POPULATION_FORMAT_VCF_HEADER_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2024 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/format/hts_file.hpp"
#include "genesis/population/format/vcf_common.hpp"
 
#include <string>
#include <unordered_map>
#include <vector>
 
extern "C" {
    // #include <htslib/hts.h>
    // #include <htslib/vcf.h>
 
    struct bcf_hdr_t;
}
 
namespace genesis {
namespace population {
 
// =================================================================================================
//     Forward Declarations
// =================================================================================================
 
class VcfRecord;
 
template< typename S, typename T >
class VcfFormatIterator;
 
// =================================================================================================
//     VCF/BCF Header
// =================================================================================================
 
class VcfHeader
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Enums
    // -------------------------------------------------------------------------
 
    // VcfRecord and VcfFormatIterator both need access to some htslib functions/definitions
    // for which we'd have to include htslib headers in our headers, which we want to avoid.
    // So instead, we wrap htslib internal functions here.
    // We could make those free functions, but it seems too specialzied for general usage,
    // so let's keep it in private scope for now, and make the classes friends instead.
 
    friend class VcfRecord;
 
    template< typename S, typename T >
    friend class VcfFormatIterator;
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    VcfHeader() = default;
 
    // /* *
    //  * @brief Create an instance that reads from an input file name.
    //  *
    //  * The header is read from the file, which is subsequently closed again. Hence, this
    //  * cannot be used to further operate on that file. It is merely meant for cases where
    //  * quick access to the VCF header information is needed, without parsing its body.
    //  */
    // explicit VcfHeader( std::string const& file_name );
 
    explicit VcfHeader( std::string const& mode );
 
    explicit VcfHeader( HtsFile& hts_file );
 
    explicit VcfHeader( ::bcf_hdr_t* bcf_hdr );
 
    ~VcfHeader();
 
    VcfHeader( VcfHeader const& ) = delete;
    VcfHeader( VcfHeader&& other );
 
    VcfHeader& operator= ( VcfHeader const& ) = delete;
    VcfHeader& operator= ( VcfHeader&& other );
 
    // -------------------------------------------------------------------------
    //     General Accessors
    // -------------------------------------------------------------------------
 
    ::bcf_hdr_t* data()
    {
        return header_;
    }
 
    ::bcf_hdr_t const* data() const
    {
        return header_;
    }
 
    std::string version() const;
 
    // -------------------------------------------------------------------------
    //     Chromosomes / Contigs / Sequences
    // -------------------------------------------------------------------------
 
    std::vector<std::string> get_chromosomes() const;
 
    size_t get_chromosome_length( std::string const& chrom_name ) const;
 
    std::unordered_map<std::string, std::string> get_chromosome_values( std::string const& chrom_name ) const;
 
    // -------------------------------------------------------------------------
    //     Filter
    // -------------------------------------------------------------------------
 
    std::vector<std::string> get_filter_ids() const;
 
    std::unordered_map<std::string, std::string> get_filter_values( std::string const& id ) const;
 
    void assert_filter( std::string const& id ) const;
 
    bool has_filter( std::string const& id ) const;
 
    // -------------------------------------------------------------------------
    //     Info
    // -------------------------------------------------------------------------
 
    std::vector<std::string> get_info_ids() const;
 
    VcfSpecification get_info_specification( std::string const& id ) const;
 
    std::unordered_map<std::string, std::string> get_info_values( std::string const& id ) const;
 
    void assert_info( std::string const& id ) const;
 
    void assert_info( std::string const& id, VcfValueType type ) const;
 
    void assert_info( std::string const& id, VcfValueType type, VcfValueSpecial special ) const;
 
    void assert_info( std::string const& id, VcfValueType type, size_t number ) const;
 
    bool has_info( std::string const& id ) const;
 
    bool has_info( std::string const& id, VcfValueType type ) const;
 
    bool has_info( std::string const& id, VcfValueType type, VcfValueSpecial special ) const;
 
    bool has_info( std::string const& id, VcfValueType type, size_t number ) const;
 
    // -------------------------------------------------------------------------
    //     Format
    // -------------------------------------------------------------------------
 
    std::vector<std::string> get_format_ids() const;
 
    VcfSpecification get_format_specification( std::string const& id ) const;
 
    std::unordered_map<std::string, std::string> get_format_values( std::string const& id ) const;
 
    void assert_format( std::string const& id ) const;
 
    void assert_format( std::string const& id, VcfValueType type ) const;
 
    void assert_format( std::string const& id, VcfValueType type, VcfValueSpecial special ) const;
 
    void assert_format( std::string const& id, VcfValueType type, size_t number ) const;
 
    bool has_format( std::string const& id ) const;
 
    bool has_format( std::string const& id, VcfValueType type ) const;
 
    bool has_format( std::string const& id, VcfValueType type, VcfValueSpecial special ) const;
 
    bool has_format( std::string const& id, VcfValueType type, size_t number ) const;
 
    // -------------------------------------------------------------------------
    //     Samples
    // -------------------------------------------------------------------------
 
    size_t get_sample_count() const;
 
    std::string get_sample_name( size_t index ) const;
 
    size_t get_sample_index( std::string const& name ) const;
 
    std::vector<std::string> get_sample_names() const;
 
    void set_samples(
        std::vector<std::string> const& sample_names,
        bool inverse_sample_names = false
    );
 
    // -------------------------------------------------------------------------
    //     Internal Helpers
    // -------------------------------------------------------------------------
 
private:
 
    std::vector<std::string> get_hrec_ids_( int hl_type ) const;
 
    std::unordered_map<std::string, std::string> get_hrec_values_(
        int hl_type, std::string const& id
    ) const;
 
    VcfSpecification get_specification_( int hl_type, std::string const& id) const;
 
    bool test_hl_entry_(
        bool throwing,
        int hl_type, std::string const& id,
        bool with_type, VcfValueType type,
        bool with_special, VcfValueSpecial special,
        bool with_number, size_t number
    ) const;
 
    static void check_value_return_code_(
        ::bcf_hdr_t* header, std::string const& id, int ht_type, int hl_type, int return_value
    );
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    ::bcf_hdr_t* header_ = nullptr;
};
 
} // namespace population
} // namespace genesis
 
#endif // htslib guard
#endif // include guard