varfiles.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Anthony J. Greenberg
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 
#ifndef varfiles_hpp
#define varfiles_hpp
 
#include <fstream>
#include <string>
#include <vector>
#include <unordered_map>
#include <cstdint>
#include <limits>
 
#include "populations.hpp"
 
using std::fstream;
using std::string;
using std::vector;
using std::unordered_map;
using std::numeric_limits;
 
namespace sampFiles {
    // Forward declarations
    class VarFile;
    class GbinFile;
    class GbinFileI;
    class GbinFileO;
    class BedFile;
    class BedFileI;
    class BedFileO;
    class GtxtFile;
    class GtxtFileI;
    class GtxtFileO;
    class TpedFile;
    class TpedFileI;
    class TpedFileO;
    class VcfFile;
    class VcfFileI;
    class VcfFileO;
    class HmpFile;
    class HmpFileI;
    class HmpFileO;
 
    static const size_t BUF_SIZE = 10485760;
    const double EPS = numeric_limits<double>::epsilon();
    const double PI = 3.14159265358979323846264338328;
    
    class VarFile {
    protected:
        fstream _varFile;
        
        VarFile() {_varFile.exceptions(fstream::badbit); };
        
    public:
        VarFile(const VarFile &in) = default;
        VarFile &operator=(const VarFile &in) = default;
        VarFile(VarFile &&in) = default;
        VarFile &operator=(VarFile &&in) = default;
        ~VarFile(){if (_varFile.is_open()) _varFile.close(); };
        
        virtual void open() = 0;
        virtual void close() = 0;
    };
    
    class GbinFile : public VarFile {
    protected:
        string _fileName;
        size_t _nCols;
        size_t _elemSize;
        
    public:
        GbinFile() : VarFile(), _nCols{0}, _elemSize{sizeof(char)} {};
        GbinFile(const string &fileName, const size_t &nCols, const size_t &elemSize) : VarFile(), _fileName{fileName}, _nCols{nCols}, _elemSize{elemSize} {};
        
        GbinFile(const GbinFile &in) = default;
        GbinFile &operator=(const GbinFile &in) = default;
        GbinFile(GbinFile &&in) = default;
        GbinFile &operator=(GbinFile &&in) = default;
        ~GbinFile(){};
        
        virtual void open() {};
        virtual void close();
        
    };
    
    class GbinFileI : GbinFile {
    protected:
        virtual uint64_t _numLines();
 
    public:
        GbinFileI() : GbinFile() {};
        GbinFileI(const string &fileName, const size_t &nCols, const size_t &elemSize) : GbinFile(fileName, nCols, elemSize) {};
        GbinFileI(const GbinFileI &in) = default;
        GbinFileI &operator=(const GbinFileI &in) = default;
        GbinFileI(GbinFileI &&in) = default;
        GbinFileI &operator=(GbinFileI &&in) = default;
        ~GbinFileI(){};
        
        void open();
        
        void sample(GbinFileO &out, const uint64_t &n);
        uint64_t nlines() { return _numLines(); };
        
    };
    
    class GbinFileO : public GbinFile {
        friend class GbinFileI;
    protected:
        
    public:
        GbinFileO() : GbinFile() {};
        GbinFileO(const string &fileName, const size_t &nCols, const size_t &elemSize) : GbinFile(fileName, nCols, elemSize) {};
        GbinFileO(const GbinFileO &in) = default;
        GbinFileO &operator=(const GbinFileO &in) = default;
        GbinFileO(GbinFileO &&in) = default;
        GbinFileO &operator=(GbinFileO &&in) = default;
        ~GbinFileO(){};
        
        void open();
        
    };
    class BedFile : public GbinFile {
    protected:
        
        fstream _famFile;
        fstream _bimFile;
        string _fileStub;
        static const vector<char> _masks;
        static const unordered_map<char, string> _tests;
 
        
    public:
        BedFile();
        BedFile(const string &stubName);
        BedFile(const BedFile &in) = default;
        BedFile &operator=(const BedFile &in) = default;
        BedFile(BedFile &&in) = default;
        BedFile &operator=(BedFile &&in) = default;
        ~BedFile();
        
        virtual void open() {};
        void close();
        
    };
 
    class BedFileI : public BedFile {
    protected:
        
        uint64_t _numLines();
        uint64_t _famLines();
        uint64_t _famLines(fstream &fam);
 
        void _ld(const char *snp1, const char *snp2, const size_t &N, const unsigned short &pad, double &rSq, double &Dprime, double &dcnt1, double &dcnt2);
        void _ld(const char *snp1, const char *snp2, const PopIndex &popID, vector<double> &rSq, vector<double> &Dprime, vector<double> &dcnt1, vector<double> &dcnt2);
    public:
        BedFileI() : BedFile() {};
        BedFileI(const string &stubName) : BedFile(stubName) {};
        BedFileI(const BedFileI &in) = default;
        BedFileI &operator=(const BedFileI &in) = default;
        BedFileI(BedFileI &&in) = default;
        BedFileI &operator=(BedFileI &&in) = default;
        ~BedFileI(){};
        
        void open();
        
        void sample(BedFileO &out, const uint64_t &n);
        
        void sampleLD(const uint64_t &n);
        void sampleLD(const PopIndex &popID, const uint64_t &n);
        uint64_t nsnp() { return _numLines(); };
        uint64_t nindiv() { return _famLines(); };
        
    };
    
    class BedFileO : public BedFile {
        friend class BedFileI;
    protected:
        
    public:
        BedFileO() : BedFile() {};
        BedFileO(const string &stubName) : BedFile(stubName) {};
        BedFileO(const BedFileO &in) = default;
        BedFileO &operator=(const BedFileO &in) = default;
        BedFileO(BedFileO &&in) = default;
        BedFileO &operator=(BedFileO &&in) = default;
        ~BedFileO(){};
        
        void open();
        
    };
    class GtxtFile : public VarFile {
    protected:
        string _fileName;
        bool _head;
        
    public:
        GtxtFile() : VarFile(), _head{false} {};
        GtxtFile(const string &fileName) : VarFile(), _fileName{fileName}, _head{false} {};
        GtxtFile(const string &fileName, const bool &head) : VarFile(), _fileName{fileName}, _head{head} {};
        
        GtxtFile(const GtxtFile &in) = default;
        GtxtFile &operator=(const GtxtFile &in) = default;
        GtxtFile(GtxtFile &&in) = default;
        GtxtFile &operator=(GtxtFile &&in) = default;
        ~GtxtFile(){};
        
        virtual void open() {};
        virtual void close();
        
    };
    
    class GtxtFileI : GtxtFile {
    protected:
        virtual uint64_t _numLines();
 
    public:
        GtxtFileI() : GtxtFile() {};
        GtxtFileI(const string &fileName) : GtxtFile(fileName) {};
        GtxtFileI(const string &fileName, const bool &head) : GtxtFile(fileName, head) {};
        GtxtFileI(const GtxtFileI &in) = default;
        GtxtFileI &operator=(const GtxtFileI &in) = default;
        GtxtFileI(GtxtFileI &&in) = default;
        GtxtFileI &operator=(GtxtFileI &&in) = default;
        ~GtxtFileI(){};
        
        void open();
        
        void sample(GtxtFileO &out, const uint64_t &n, const bool &headSkip);
        void sample(const uint64_t &n, const bool &headSkip, const char &delim, vector<string> &out);
        uint64_t nlines() { return _numLines(); };
        
    };
    
    class GtxtFileO : public GtxtFile {
        friend class GtxtFileI;
    protected:
        
    public:
        GtxtFileO() : GtxtFile() {};
        GtxtFileO(const string &fileName) : GtxtFile(fileName) {};
        GtxtFileO(const string &fileName, const bool &head) : GtxtFile(fileName, head) {};
        GtxtFileO(const GtxtFileO &in) = default;
        GtxtFileO &operator=(const GtxtFileO &in) = default;
        GtxtFileO(GtxtFileO &&in) = default;
        GtxtFileO &operator=(GtxtFileO &&in) = default;
        ~GtxtFileO(){};
        
        void open();
        
    };
    
 
    class TpedFile : public GtxtFile {
    protected:
        fstream _tfamFile;
        string  _fileStub;
        
    public:
        TpedFile() : GtxtFile() {_tfamFile.exceptions(fstream::badbit); };
        TpedFile(const string &stubName) : GtxtFile(stubName + ".tped"), _fileStub{stubName} {_tfamFile.exceptions(fstream::badbit); }; // no headers in .tped
        TpedFile(const TpedFile &in) = default;
        TpedFile &operator=(const TpedFile &in) = default;
        TpedFile(TpedFile &&in) = default;
        TpedFile &operator=(TpedFile &&in) = default;
        ~TpedFile();
        
        virtual void open() {};
        void close();
        
    };
    
    class TpedFileI : public TpedFile {
    protected:
        uint64_t _famLines();
        uint64_t _famLines(fstream &fam);
        void _famCopy(fstream &fam);
        uint64_t _numLines();
 
    public:
        TpedFileI() : TpedFile() {};
        TpedFileI(const string &stubName) : TpedFile(stubName) {};
        TpedFileI(const TpedFileI &in) = default;
        TpedFileI &operator=(const TpedFileI &in) = default;
        TpedFileI(TpedFileI &&in) = default;
        TpedFileI &operator=(TpedFileI &&in) = default;
        ~TpedFileI(){};
        
        void open();
        
        void sample(TpedFileO &out, const uint64_t &n);
        uint64_t nsnp() { return _numLines(); };
        uint64_t nindiv() { return _famLines(); };
        
    };
    
    class TpedFileO : TpedFile {
        friend class TpedFileI;
    protected:
        
    public:
        TpedFileO() : TpedFile() {};
        TpedFileO(const string &stubName) : TpedFile(stubName) {};
        TpedFileO(const TpedFileO &in) = default;
        TpedFileO &operator=(const TpedFileO &in) = default;
        TpedFileO(TpedFileO &&in) = default;
        TpedFileO &operator=(TpedFileO &&in) = default;
        ~TpedFileO(){};
        
        void open();
    };
    
    class VcfFile : public GtxtFile {
    protected:
    
    public:
        VcfFile() : GtxtFile() {};
        VcfFile(const string &fileName) : GtxtFile(fileName) {};
        
        VcfFile(const VcfFile &in) = default;
        VcfFile &operator=(const VcfFile &in) = default;
        VcfFile(VcfFile &&in) = default;
        VcfFile &operator=(VcfFile &&in) = default;
        ~VcfFile(){};
        
        void open() {};
        void close();
    };
    
    class VcfFileI : public VcfFile {
    protected:
        uint64_t _numLines();
 
    public:
        VcfFileI() : VcfFile() {};
        VcfFileI(const string &fileName) : VcfFile(fileName) {};
        VcfFileI(const VcfFileI &in) = default;
        VcfFileI &operator=(const VcfFileI &in) = default;
        VcfFileI(VcfFileI &&in) = default;
        VcfFileI &operator=(VcfFileI &&in) = default;
        ~VcfFileI(){};
        
        void open();
        
        void sample(VcfFileO &out, const uint64_t &n);
        uint64_t nsnp() { return _numLines(); };
        
    };
    
    class VcfFileO : public VcfFile {
        friend class VcfFileI;
    protected:
        
    public:
        VcfFileO() : VcfFile() {};
        VcfFileO(const string &fileName) : VcfFile(fileName) {};
        VcfFileO(const VcfFileO &in) = default;
        VcfFileO &operator=(const VcfFileO &in) = default;
        VcfFileO(VcfFileO &&in) = default;
        VcfFileO &operator=(VcfFileO &&in) = default;
        ~VcfFileO(){};
        
        void open();
        
    };
    
    class HmpFile : public GtxtFile {
    protected:
        
    public:
        HmpFile() : GtxtFile() {};
        HmpFile(const string &fileName) : GtxtFile(fileName) {};
        
        HmpFile(const HmpFile &in) = default;
        HmpFile &operator=(const HmpFile &in) = default;
        HmpFile(HmpFile &&in) = default;
        HmpFile &operator=(HmpFile &&in) = default;
        ~HmpFile(){};
        
        virtual void open() {};
        virtual void close();
        
    };
    
    class HmpFileI : HmpFile {
    protected:
        uint64_t _numLines();
 
    public:
        HmpFileI() : HmpFile() {};
        HmpFileI(const string &fileName);
        HmpFileI(const HmpFileI &in) = default;
        HmpFileI &operator=(const HmpFileI &in) = default;
        HmpFileI(HmpFileI &&in) = default;
        HmpFileI &operator=(HmpFileI &&in) = default;
        ~HmpFileI(){};
        
        void open();
        
        void sample(HmpFileO &out, const uint64_t &n);
        uint64_t nsnp() { return _numLines(); };
        
    };
    
    class HmpFileO : public HmpFile {
        friend class HmpFileI;
    protected:
        
    public:
        HmpFileO() : HmpFile() {};
        HmpFileO(const string &fileName) : HmpFile(fileName) {};
        HmpFileO(const HmpFileO &in) = default;
        HmpFileO &operator=(const HmpFileO &in) = default;
        HmpFileO(HmpFileO &&in) = default;
        HmpFileO &operator=(HmpFileO &&in) = default;
        ~HmpFileO(){};
        
        void open();
        
    };
    
 
}
 
#endif /* varfiles_hpp */