utilities.h

Go to the documentation of this file.

 
#ifndef _UTILITIES_H
#define _UTILITIES_H
 
#include <fstream>
#include <iostream>
#include <vector>
#include <deque>
#include <map>
#include <unordered_map>
#include <string>
#include <sstream>
#include <iomanip>
#include <cfloat>
#include <cmath>
#include <QString>
#include <QByteArray>
#include <QMetaType>
#include <QAbstractItemModel>
#include <QModelIndex>
#include <boost/regex.hpp>
 
class cBrick;
 
 
#define WIN 0   // Windows
#define UNX 1   // Linux/UNIX
#define OSX 2   // Mac OS X
 
 
#ifdef LINUX
    #define OS_TYPE UNX
    #define sscanf_s sscanf
    #define sprintf_s sprintf
#else
    #ifdef MACOSX
        #define OS_TYPE OSX
        #define sscanf_s sscanf
        #define sprintf_s sprintf
    #else
        #define OS_TYPE WIN
    #endif
#endif
 
 
using namespace std;
using namespace boost;
 
 
const double pi = 3.141592653589793;
 
 
const double econst = 2.718281828459045;
 
 
const int defaultwinsizex = 1350;
 
 
const int defaultwinsizey = 875;
 
 
enum eVendorType {
    unknownvendor = 0,
    bruker = 1,
    waters = 2
};
 
 
enum eModeType {
    denovoengine = 0,
    singlecomparison = 1,
    databasesearch = 2,
    dereplication = 3,
    compoundsearch = 4
};
 
 
enum ePeptideType {
    linear = 0,
    cyclic = 1,
    branched = 2,
    branchcyclic = 3,
    linearpolyketide = 4,
    cyclicpolyketide = 5,
    other = 6
};
 
 
extern QString appname;
 
 
extern QString appversion;
 
 
extern QString lastcompatibleappversion;
 
 
extern QString installdir;
 
 
void storeIntVector(vector<int>& v, ofstream& os);
 
 
void loadIntVector(vector<int>& v, ifstream& is);
 
 
void storeDoubleVector(vector<double>& v, ofstream& os);
 
 
void loadDoubleVector(vector<double>& v, ifstream& is);
 
 
void storeString(string& s, ofstream& os);
 
 
void loadString(string& s, ifstream& is);
 
 
void storeStringVector(vector<string>& v, ofstream& os);
 
 
void loadStringVector(vector<string>& v, ifstream& is);
 
 
void storeStringIntMap(map<string, int>& map, ofstream& os);
 
 
void loadStringIntMap(map<string, int>& map, ifstream& is);
 
 
void storeStringIntMapVector(vector< map<string, int> >& vector, ofstream& os);
 
 
void loadStringIntMapVector(vector< map<string, int> >& vector, ifstream& is);
 
 
void storeIntStringMap(map<int, string>& map, ofstream& os);
 
 
void loadIntStringMap(map<int, string>& map, ifstream& is);
 
 
void convertStringIntUnorderedMapToStringVector(unordered_map<string, int>& map, vector<string>& vector);
 
 
bool isWhiteSpace(char c);
 
 
bool isWhiteSpaceExceptSpace(char c);
 
 
string& removeWhiteSpacesExceptSpaces(string& s);
 
 
bool checkRegex(ePeptideType peptidetype, string& sequence, string& errormessage);
 
 
bool checkFile(string filename);
 
 
bool compareDoubles(double& first, double& second, double epsilon = 0.0000001f);
 
 
bool compareStringVectors(vector<string>& first, vector<string>& second);
 
 
bool compareMapsIntDouble(map<int, double>& first, map<int, double>& second, double epsilon = 0.0000001f);
 
 
void parseBranch(ePeptideType peptidetype, string& composition, vector<string>& vectorcomposition, int& branchstart, int& branchend);
 
 
ePeptideType getPeptideTypeFromString(string& s);
 
 
string getStringFromPeptideType(ePeptideType peptidetype);
 
 
double cropPrecisionToSixDecimals(double value);
 
 
QByteArray cropDecimalsByteArray(double value);
 
 
QByteArray cropPrecisionToSixDecimalsByteArray(double value);
 
 
string getShortFileName(string filename);
 
 
struct cCoordinateInfo {
 
    int id;
 
 
    int x;
 
 
    int y;
 
 
    double relativeintensity;
 
 
    double absoluteintensity;
 
 
    string description;
 
 
    cCoordinateInfo() {
        id = 0;
        x = 0;
        y = 0;
        relativeintensity = 0;
        absoluteintensity = 0;
        description = "";
    }
 
};
 
 
Q_DECLARE_METATYPE(vector<cCoordinateInfo>);
 
 
double fact(int value);
 
 
double median(vector<double>& vector);
 
 
string stripHTML(string& htmlstring);
 
 
void stripIsomers(string& peptidesequence);
 
 
void stripIsomersFromStringVector(vector<string>& acronyms);
 
 
struct compareStringBySize {
 
    bool operator()(const std::string& first, const std::string& second) {
        size_t size1 = first.size();
        size_t size2 = second.size();
        if (first.size() < second.size()) {
            return true;
        }
        if (first.size() > second.size()) {
            return false;
        }
        return first.compare(second) < 0;
    }
 
};
 
 
bool proxyModelCheckInt(QAbstractItemModel* model, int index, int row, int column, QString str, const QModelIndex& parent);
 
 
bool proxyModelCheckDouble(QAbstractItemModel* model, int index, int row, int column, QString str, const QModelIndex& parent);
 
 
bool proxyModelCheckString(QAbstractItemModel* model, int index, int row, int column, QString& itemstr, QString str, const QModelIndex& parent, bool wholeword, Qt::CaseSensitivity casesensitive);
 
 
bool isCompatibleVersion(int fileversionpart1, int fileversionpart2, int fileversionpart3, int lastcompatiblepart1, int lastcompatiblepart2, int lastcompatiblepart3);
 
 
string fixLabelCharge(string& str, int sourcecharge, int targetcharge);
 
 
#endif