vcf_file.h

/* An vcf  */

#ifndef _VCF_FILE_H_
#define _VCF_FILE_H_

#include <iostream>
#include <cfloat>
#include <iomanip>
#include <vector>

#ifndef NOHTS
#include <htslib/hts.h>
#include <htslib/vcf.h>

#ifndef NOLZ4
#include "state.h"
#endif

#include "external-file.h"
#include "external-data.h"

#include "typedef.h"
#include "datatypes.h"
#include "raw.h"
#include "stream_tools.h"


class Info {
public:
    enum Key {
        AA,
        BQ,
        CIGAR,
        DB,
        DP,
        END,
        H2,
        H3,
        MQ,
        MQ0,
        NS,
        SB,
        SOMATIC,
        VALIDATED,
        G
    };

};

class Vcf_data : public External_data {
private:

//  bcf_init
//  bcf_destroy
//  bcf_read(htsFile *fp, const bcf_hdr_t *h, bcf1_t *v)
//  bcf_write(htsFile *fp, const bcf_hdr_t *h, bcf1_t *v)


public:
    Vcf_data ();

    //These should all be private, make vcf_file freind?
    bcf1_t *record_;
    bcf_hdr_t *header_;
    size_t sample_size_;

    void set_header(const File_index &, const std::vector <std::string> &);

    void put (const Data *, ...);
    void get (Data *, ...) const;

    void put (const File_index &, const Allele &, const Population &);
    id1_t get (const File_index &, Population &) const;

#ifndef NOLZ4
    id1_t get (State &) const;
#endif 
    std::vector<std::string> get_sample_names (void) const;
    File_index get_index (void) const;

    //The mandatory fields.
    std::string id;
    Base ref;
    std::vector <std::string> alt;
    float_t qual;
    bool filter;
    std::vector <std::string> info;

        Base AA;

    std::vector <count_t> AC;

    //  use this when estimated from primary data, not called genotypes
    std::vector <float_t> AF;

        count_t AN;

        float_t BQ;

    //cigar CIGAR;

    bool DB;

        count_t DP;

    id1_t END;

    bool H2;

    float_t MQ;

    count_t MQ0;

    count_t NS;

    float_t SB;

        bool SOMATIC;

        bool VALIDATED; 
};


class Vcf_file : public External_file <Vcf_data> {
private:
    using Base_file::in_;
    using Base_file::out_;
    using Base_file::open_;
    using Base_file::open_no_extention;
    htsFile *file_;
public:
    void open(const std::ios_base::openmode &);
    void open(const char *, const std::ios_base::openmode &);
    void close(void);
    void read (Vcf_data &);
    void write (const Vcf_data &);
    void write_header (const Vcf_data &);
    Vcf_data read_header();
};

/*
typedef struct {
    int32_t n[3];           // n:the size of the dictionary block in use, (allocated size, m, is below to preserve ABI) 
    bcf_idpair_t *id[3];
    void *dict[3];          // ID dictionary, contig dict and sample dict
    char **samples;     // Presumably sample names.
    bcf_hrec_t **hrec;      // Jesus fucking crist.
    int nhrec, dirty;       // 
    int ntransl, *transl[2];    // for bcf_translate()
    int nsamples_ori;           // for bcf_hdr_set_samples()
    uint8_t *keep_samples;
    kstring_t mem;
    int32_t m[3];          // m: allocated size of the dictionary block in use (see n above)
} bcf_hdr_t;
*/

#endif
#endif