/* BaitFisher (version 1.2.7) a program for designing DNA target enrichment baits * Copyright 2013-2016 by Christoph Mayer * * This source file is part of the BaitFisher-package. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with BaitFisher. If not, see . * * * For any enquiries send an Email to Christoph Mayer * c.mayer.zfmk@uni-bonn.de * * When publishing work that is based on the results please cite: * Mayer et al. 2016: BaitFisher: A software package for multi-species target DNA enrichment probe design * */ #ifndef EASYSTRING_H #define EASYSTRING_H #include #include #include // for strchr #include #include // A usefull global function split: //(Code copied from the stringtok.h file on the gnu libstdc++ page. namespace { inline bool isws(char c, const char* wstr="\r\n\t\v\f ") { return (strchr(wstr,c) != NULL); } } namespace { // // Reads through a string. If braces are encountered we do not tokenize inside but try to read them. // inline void skip_until_ws_respect(const std::string &s, std::string::size_type &pos, char const * const ws = "\r\n\t\v\f ") { char c; unsigned count_parent = 0; unsigned count_brace = 0; unsigned count_curly = 0; unsigned count_sq = 0; unsigned count_dq = 0; std::string::size_type size = s.size(); while (pos < size) { c = s[pos]; if (c == '(') { ++count_parent; } else if (c == ')') { --count_parent; } else if (c == '[') { ++count_brace; } else if (c == ']') { --count_brace; } else if (c == '{') { ++count_curly; } else if (c == '}') { --count_curly; } else if (c == '\'') { count_sq = (count_sq+1)%2; } else if (c == '\"') { count_dq = (count_dq+1)%2; } if (isws(c, ws) && count_parent==0 && count_brace==0 && count_curly==0 && count_sq==0 && count_dq==0) return; ++pos; } } } namespace std { /***************************************************************** * Simplistic and quite Standard, but a bit slow. This should be * templatized on basic_string instead, or on a more generic StringT * that just happens to support ::size_type, .substr(), and so on. * I had hoped that "whitespace" would be a trait, but it isn't, so * the user must supply it. Enh, this lets them break up strings on * different things easier than traits would anyhow. */ template int split (Container &l, string const &s, char const * const ws = "\r\n\t\v\f ") { l.clear(); const string::size_type S = s.size(); string::size_type i = 0; while (i < S) { // eat leading whitespace while ((i < S) && (isws(s[i],ws))) ++i; if (i == S) return l.size(); // nothing left but WS // find end of word string::size_type j = i+1; while ((j < S) && (!isws(s[j],ws))) ++j; // add word l.push_back(s.substr(i,j-i)); // set up for next loop i = j+1; } return l.size(); } // // Tokenizer which does not split braces. // template int split_respect (Container &l, string const &s, char const * const ws = "\r\n\t\v\f ") { l.clear(); const string::size_type S = s.size(); string::size_type i = 0; while (i < S) { // eat leading whitespace while ((i < S) && (isws(s[i],ws))) ++i; if (i == S) return l.size(); // nothing left but WS // find end of word string::size_type j = i; // We can't skip the first char which can be a brace. skip_until_ws_respect(s, j, ws); // add word l.push_back(s.substr(i,j-i)); // set up for next loop i = j+1; } return l.size(); } // Multiple successive deliminators result in multiple hits. template int split_strict (Container &l, string const &s, char const * const ws = " \t\n") { l.clear(); const string::size_type S = s.size(); string::size_type i = 0; while (i < S) { // find end of word string::size_type j = i; while ((j < S) && (!isws(s[j],ws))) ++j; // add word l.push_back(s.substr(i,j-i)); // set up for next loop i = j+1; if (i==S) // Only true of last string is empty since otherwise i==S+1 { l.push_back(""); } } return l.size(); } class easystring: public string { public: // Default constructor: easystring():string(){}; // Copy constructor: easystring(const string& s):string(s){} easystring(const string& s, size_type pos, size_type n):string(s,pos,n){} // Other constructors: easystring(const char* s, size_type n):string(s,n){} easystring(size_type n, char c):string(n,c){} template easystring(InputIterator first, InputIterator last):string(first, last){} // Type conversion constructors: easystring(const char* s):string(s){} easystring(const char c):string(1,c){} easystring(const int i):string() { // std::cout << "Hallo" << std::endl; char tmp[21]; // Sufficient for 64 bit numbers + sign sprintf(tmp, "%d", i); append(tmp); } easystring(const long i):string() { // std::cout << "Hallo" << std::endl; char tmp[21]; // Sufficient for 64 bit numbers + sign sprintf(tmp, "%ld", i); append(tmp); } easystring(const unsigned i):string() { // std::cout << "Hallo" << std::endl; char tmp[21]; // Sufficient for 64 bit numbers sprintf(tmp, "%u", i); append(tmp); } easystring(const unsigned long i):string() { // std::cout << "Hallo" << std::endl; char tmp[21]; // Sufficient for 64 bit numbers sprintf(tmp, "%lu", i); append(tmp); } easystring(const double x, int pres):string() { // std::cout << "Hallo" << std::endl; char tmp[25]; // Sufficient for 64 bit numbers sprintf(tmp, "%.*f", pres, x); append(tmp); } void removeSpacesFront(const char* delims="\r\n\t\v\f ") { string::size_type i; const string::size_type n = size(); for (i=0; i < n && isws((*this)[i], delims); ++i); erase(0,i); } void removeSpacesBack(const char* delims="\r\n\t\v\f ") { unsigned i; unsigned n = size(); if (n > 0) { for (i=n-1; i != 0 && isws((*this)[i], delims); --i); if (i == 0 && isws((*this)[0], delims)) erase(); else erase(i+1); } } void ToUpper() { iterator it, it_end; it = begin(); it_end = end(); while (it != it_end) { *it = toupper(*it); ++it; } } void ToLower() { string::iterator it, it_end; it = begin(); it_end = end(); while (it != it_end) { *it = tolower(*it); ++it; } } // Convert to unsigned long unsigned ToUnsigned() const { char *end; return strtoul(c_str(), &end, 0); } // Convert to unsigned long unsigned long ToUnsignedLong() const { char *end; return strtoul(c_str(), &end, 0); } // Convert to int int ToInt() const { char *end; return strtol(c_str(), &end, 0); } // Convert to long long ToLong() const { char *end; return strtol(c_str(), &end, 0); } long ToLong(string::size_type beg_pos, string::size_type& end_pos) const { const char *beg = c_str()+beg_pos; char *end; long result; result = strtol(beg, &end, 0); end_pos = end-c_str(); return result; } unsigned ToUnsigned(string::size_type beg_pos, string::size_type& end_pos) const { const char *beg = c_str()+beg_pos; char *end; long result; result = strtoul(beg, &end, 0); end_pos = end-c_str(); return result; } // Convert to double double ToDouble() const { char *end; return strtod(c_str(), &end); } double ToDouble(string::size_type beg_pos, string::size_type& end_pos) const { const char *beg = c_str()+beg_pos; char *end; double result; result = strtod(beg, &end); end_pos = end-c_str(); return result; } // not tested unsigned countChar(char c) { unsigned n = 0; string::iterator b = begin(); string::iterator e = end(); while (berase(begin()); this->erase(end()-1); } else if (*begin() == '\'' && *(end()-1) == '\'' ) { this->erase(begin()); this->erase(end()-1); } } // not tested void unquote(char s, char e) { removeSpacesBack(); removeSpacesFront(); if (*begin() == s && *(end()-1) == e ) { this->erase(begin()); this->erase(end()-1); } } // get the next token and remove it from the called object. easystring& get_next_token(easystring &str, const char * ws = "\r\n\t\v\f ") { const string::size_type n = size(); string::size_type i = 0; str.clear(); // eat leading whitespace/deliminators -- this sould be more efficient than // calling removeSpacesFront since we only need to erase in the front of the string once. while ( (i < n) && ( isws( (*this)[i], ws)) ) ++i; if (i == n) // nothing left so re remove alle spaces and the string will be empty { erase(); } else { // find end of word string::size_type j = i+1; while ( (j < n) && (!isws( (*this)[j], ws)) ) ++j; str = string(*this, i, j); // the next token erase(0, j); // remove token from called object } return *this; } // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx // Be careful with keywords containing punctuations since they do not // count as upper case chars. The upper case loop stops there. // Possible bug: I think "I" abbreviates "INPUT" which is not OK. // Use !isalpha() to as equivalent to "isupper() so we prolong the upper region. bool is_CAPITALIZED_abbreviation_of(const easystring &keyword) { unsigned i = 0; unsigned max = size(); // max cannot be greater than keyword.size() if ( max > keyword.size() ) return false; // We start comparrison in upper case region. Lets see how far we can go. while (i < max && toupper( (*this)[i] ) == keyword[i] ) { ++i; } // First we check whether both strings have the same length and we matched all chars. // This means that we matched exactly the upper case region of keyword, which is the // complete keyword. if ( i == max && max == keyword.size() ) return true; // If we get here, i must be smaller than keyword.size() since we can only have // * i == max and i == keyword.size(): Not possible after previous if // * i < max and i == keyword.size(): Not possible since max <= keyword.size() // * i == max and i < keyword.size(): // * i < max and i < keyword.size(): // Thus, keyword[i] is valid and we use it to check whether we are in the upper case region // (were all !alpha() should also be considered as upper case chars in this context!!). // We simply check whether we are in the !islower() region. if ( !islower( keyword[i]) ) // We are still in non-lower case region return false; // If we get here, we are in the in the lower-case region // There are two possibilities: // - i == max, if (i==max) return true; // - our string is longer than the upper case region, so we have to continue // our comparison. // Let us move through lower case region while (i < max && ((*this)[i] == keyword[i] || tolower((*this)[i]) == keyword[i]) ) ++i; // Could we match all letters in str? if (i==max) return true; else return false; } }; } #endif