locus.h

#ifndef LOCUS_H_
#define LOCUS_H_

#include <iostream>
#include <vector>

#include "quartet.h"
#include "base.h"
#include "stream_tools.h"
#include "data.h"
#include "file_index.h"

/* This is the record stored in a pro file*/
class Locus : virtual public Indexed_data{
private:
    //NOT READ READ/WRITE!!
    std::vector <std::string> sample_names_;        

    //READ READ/WRITE!!
    using Indexed_data::abs_pos_;

    static const Registration registered;
    static Data * create(const std::vector <std::string> & Columns){
        return new Locus(Columns);
    }
    void write (std::ostream& out) const;
    void read (std::istream& in);
public:
    void write_binary (std::ostream& out) const;
    void read_binary (std::istream& in);
    /* BEGIN DATA BLOCK */
    /* these need to be changed to private */
    gt_t sorted_[5];                
    std::vector <quartet_t> sample;         
    Base ref;
    /* END DATA BLOCK */

    static const gt_t default_order[5];
//public:

    Locus (const count_t &);
    Locus ();
    Locus (const std::vector<std::string> &); 

    /*BASIC OPERATORS*/
    Locus & operator=(const Locus&);    
    Locus & operator+=(const Locus&);   
    const Locus operator+(const Locus&) const;  
    const count_t getindex(count_t) const;      

    count_t getcoverage(count_t) const;     
    count_t getcoverage(void) const;        

    count_t getcount(count_t) const;        
    count_t getcount(count_t, count_t) const;   

    void swap(count_t, count_t);            
    void sort(count_t);             
    void sort(void);                

    /* \defgroup QUARTET Quartet
     * The set of functions dealing with quartets
     * @{
     */
    void set_quartet(const quartet_t &, const count_t &);   
    const quartet_t & get_quartet(const count_t &) const;   
    quartet_t & get_quartet(const count_t &);       

    /* \defgroup MASKING Masking 
     * Functions which set or unset the masked flag, quartets which are 
     * masked are ignored by calculations, and are printed as 0's. 
     * @{
     */
    count_t maskedcount(void) const;        
    void maskall(void);             
    void unmaskall(void);               
    void mask(const std::vector <size_t> &);    
    void unmask(const std::vector <size_t> &);  
    void mask_low_cov(const count_t &dp);   

    /* \defgroup DEPRICATED depricated 
     * Functions that were once used, but are no longer usful.
     * @{
     */
        char getname( const count_t &) const;           
        char getname_gt( const count_t &) const;        
        count_t get_extraid(const size_t &) const;      
        void set_extraid(const count_t &, const size_t &);  
    /* this will definetly by dropped */
    using Indexed_data::get_abs_pos;        
    using Indexed_data::set_abs_pos;        

    void resize(const size_t &);            

    /* \defgroup iterators Iterators
     * Locus can return the iterators foir the quartets.
     * @{
     */
    inline std::vector <quartet_t>::iterator begin(void) {return sample.begin();};      

    inline std::vector <quartet_t>::iterator 
    end(void) {
        return sample.end();
    };

    inline std::vector <quartet_t>::const_iterator 
    cbegin(void) const {
        return sample.cbegin();
    };      

    inline std::vector <quartet_t>::const_iterator 
    cend(void) const {
        return sample.cend();
    };      
    inline std::vector <std::string> 
    get_sample_names(void) const 
    {
        return sample_names_;
    };

    inline void 
    set_sample_names(const std::vector <std::string>& sample_names) 
    {
        sample_names_=sample_names;
        if (sample_names_.size()!=sample.size() ) sample.assign(sample_names_.size(), quartet() );
    };      

    /* \defgroup LOCUS_DATA Inherited members
     * These members are inherited from Data
     * @{
     */
    std::string header(void) const;
    size_t size(void) const;

    static const std::string file_name;
    static const std::string table_name;
    static const bool binary;

    const std::string get_file_name(void) const;
    const std::string get_table_name(void) const;
    const bool get_binary(void) const;

    const std::string sql_header(void) const;               
    const std::string sql_column_names(void) const;             
    const std::string sql_values(void) const;               

    void sql_read(std::istream &) override;
    friend std::istream& mpileup (std::istream& in, Locus& x, const int &, const int &);
    friend void scan(const Locus & site, const std::string &str, quartet_t &q);
};


#endif