ftPropsClass.h

#ifndef PROPERTIESCLASS_H
#define PROPERTIESCLASS_H
 
#include <climits>
#include <set>
#include <bitset>
#include <iostream>
#include <fstream>
#include <chrono>
#include <map>
#include <experimental/filesystem>
#include <QSettings>
#include <LogClass.h>
 
 
namespace ft {
 
namespace fs = std::experimental::filesystem;
 
enum Orientation {FWD = 1, REV}; 
 
typedef std::string     SearchType;             
const   std::string     CENTERED = "CENTERED";  
const   std::string     SLIDING  = "SLIDING";   
 
enum QueryType {REF = 1, ALT, CRO};
const   std::string QUERYTYPE_REF  = "REF";
const   std::string QUERYTYPE_ALT  = "ALT";
const   std::string QUERYTYPE_CRO  = "CRO";
 
typedef std::pair<int, QueryType>  QIdT; // int is the query ID
 
typedef std::pair<int, int> ReadID; // pair (id, pair 1 or pair 2)
 
typedef std::tuple<uint, std::string, std::string, std::string>  Query;
 
enum FlagType { ABK = 0x0001, OCK = 0x0002, NUK = 0x0003, MUL = 0x0004};
 
class FTProp
{
public:
    FTProp();
 
    virtual ~FTProp();
 
    struct CmdLineArg {
        std::string outputFile;
        std::string iniFile;
        uint kmerSize;
        uint stride;
        uint maxOccurences;
        bool unique;
        bool verbose = false;
    };
 
    void init(const fs::path& pathToQueryFile       ,
              uint kmerSize                         ,
              uint readLength                       ,
              const fs::path& indexPropsFile        ,
              const fs::path& outputFolder          ,
              const fs::path& outputFile            ,
              bool refOnly                          ,
              bool revCompSearch                    ,
              SearchType searchType                 ,
              bool multithread              = false ,
              uint overlap                  = 0     ,
              bool returnMatchesOnly        = false ,
              uint stride                   = 10    ,
              uint maxOccurences            = 200   ,
              uint numOfThreads             = 1     ,
              bool outputNonUniqueKmers       = false ,
              bool outputOverCountedKmers     = false ,
              bool ignoreNonUniqueKmers     = true  ,
              bool ignoreOverCountedKmers   = true  ,
              bool countAsPairs             = false ,
              bool crossover                = false ,
              bool uniqueReads              = false ,
              uint maxKmers                 = UINT_MAX,
              uint totalKmers               = UINT_MAX,
              bool printInputs              = false,
              bool matchingReads            = false);
 
    void initFromQSettings(FTProp::CmdLineArg& arg);
 
    void setVerbose(bool verbose);
    void printToStdOut(const std::string outputString) const;
 
    void loadIndexProps(const fs::path& _indexPropsFile, bool printInputs);
    void initIndexProps( const bool pairedReads,
                         const bool revComp,
                         fs::path buildDir,
                         fs::path indexDir,
                         std::string indexFileName,
                         std::string readSetName,
                         fs::path inputFastQ,
                         uint numOfReads,
                         uint numOfIndexes,
                         bool printInputs = false);
 
 
    std::map<fs::path, uint> _indexSet; 
 
    SearchType getSearchType() const;
 
    std::string getReadSetName()const ;
    std::string getIndexFileName()const ;
 
    uint getKmerSize() const;
    uint getOverlap() const;
    uint getStride() const;
    uint getReadLength() const;
    uint getMaxOcc() const;
    uint getMaxThreads() const;
    uint getMaxKmersPerQuery() const;
    uint getMaxTotalKmers() const;
    uint getNumOfIndexes() const;
    uint getNumOfReads() const;
 
    const std::bitset<8>& getFlagsToOutput() const;
    const std::bitset<8>& getFlagsToNotCount() const;
    bool countFlag(ft::FlagType flag) const;
    bool outputFlag(ft::FlagType flag) const;
    void setFlagToOutput(ft::FlagType flag);
    void setFlagToNotCount(ft::FlagType flag);
    void resetFlagToOutput(ft::FlagType flag);
    void resetFlagToNotCount(ft::FlagType flag);
 
    bool getMultithreadFlag() const;
    bool getRefOnlyFlag() const;
    bool getMatchesOnlyFlag() const;
    bool getCrossoverFlag() const;
    bool getPairedReadFlag() const;
    bool getCountAsPairsFlag() const;
    bool getRevCompSearchFlag() const;
    bool getIndexRevCompFlag() const;
    bool getMatchingReadsFlag() const;
    bool getUniqueReadsFlag() const;
    bool isVerbose() const;
 
    const fs::path& getPathToQueryFile() const;
    const fs::path& getIndexDir() const;
    const fs::path& getOutputFolder() const;
    const fs::path& getMatchingReadFQ() const;
    const fs::path& getInputFastQ() const;
    const fs::path& getOutputFile() const;
    const std::map<fs::path, uint>& getIndexSet() const;
    const fs::path& getBuildDir() const;
    const fs::path& getR1() const;
    const fs::path& getR2() const;
 
    void addToIndexSet(const fs::path& index, u_int offset);
 
    void setTestProps(const uint numOfReads, const uint readLength, bool _revComp, bool countAsPairs = false);
    void setOutputFolder(const fs::path& outputFolder);
 
private:
    SearchType _searchType;
    std::string _readSetName;
    std::string _indexFileName;
 
    uint _numOfReads; 
    uint _numOfIndexes;
 
    fs::path _pathToQueryFile;
 
    fs::path _buildDir;
    fs::path _indexDir;
 
    fs::path _R1;
    fs::path _R2;
    fs::path _inputFastQ;
 
    fs::path _outputFolder;
    fs::path _outputFile;
 
    uint _kmerSize;
    uint _overlap;
    uint _stride;
    uint _readLength;
    uint _maxOccurences ;
    uint _maxThreads;
    uint _maxKmersPerQuery;
    uint _maxTotalKmers;
 
    std::bitset<8> _flagsToOutput;
    std::bitset<8> _flagsToNotCount;
 
    bool _multithread; 
    bool _refOnly; 
    bool _matchesOnly; //?< only output positive hits
    bool _crossover; //search for crossover counts
    bool _pairedReads; 
    bool _countAsPairs; 
    bool _revCompSearch; 
    bool _indexRevComp; 
    bool _matchingReads; 
    bool _verbose; 
    bool _uniqueReads; 
 
};
 
}
 
#endif // PROPERTIESCLASS_H