tstring.h

Go to the documentation of this file.

 
#ifndef TSTRING_H
#define TSTRING_H
 
#include <sstream>
#include <string>
#include <vector>
#include "output.h"
 
using namespace std;
 
class tstring {
 
private:
  tstring(){}
  
public:
  // ----------------------------------------------------------------------------------------
  // str2uint
  // ----------------------------------------------------------------------------------------
  static unsigned int str2uint (const string& str)
  {
    istringstream IN(str);
    unsigned int i;
    IN >> i;
    return i;
  }
  // ----------------------------------------------------------------------------------------
  // str2uint
  // ----------------------------------------------------------------------------------------
  static unsigned long str2ulong (const string& str)
  {
    istringstream IN(str);
    unsigned long i;
    IN >> i;
    return i;
  }
  // ----------------------------------------------------------------------------------------
  // str2int
  // ----------------------------------------------------------------------------------------  
  static int str2int (const string& str)
  {
    istringstream IN(str);
    int i;
    IN >> i;
    return i;
  }
  // ----------------------------------------------------------------------------------------
  // str2dble
  // ----------------------------------------------------------------------------------------  
  static double str2dble (const string& str) 
  {
    istringstream IN(str);
    double d;
    IN >> d;
    return d;
  }
  // ----------------------------------------------------------------------------------------
  // int2str
  // ----------------------------------------------------------------------------------------  
  static string int2str (const int i)
  {
    ostringstream OUT;
    OUT << i;
    return OUT.str();
  }
  // ----------------------------------------------------------------------------------------
  // ulong2str
  // ----------------------------------------------------------------------------------------  
  static string ulong2str (const unsigned long i)
  {
    ostringstream OUT;
    OUT << i;
    return OUT.str();
  }  
  // ----------------------------------------------------------------------------------------
  // dble2str
  // ----------------------------------------------------------------------------------------  
  static string dble2str (const double d) 
  {
    ostringstream OUT;
    OUT << d;
    return OUT.str();
  }  
  // ----------------------------------------------------------------------------------------
  // split
  // ----------------------------------------------------------------------------------------  
  static vector<string> split(const string& str, const char delim, bool splitOnce = false)
  {
    vector<string> tokens;
    string out(str);
    size_t pos = 0;
    
    while(out.find(delim) != string::npos) {
      pos = out.find_first_of(delim);
      tokens.push_back( removeEnclosingChar(out.substr(0, pos), ' ', ' ', true)  );
      out = out.substr(pos+1);
      if(splitOnce) break;
    }
    
    tokens.push_back( removeEnclosingChar(out, ' ', ' ', true) );
    
    return tokens;
  }
  // ----------------------------------------------------------------------------------------
  // splitExcludeEnclosedDelimiters
  // ----------------------------------------------------------------------------------------  
  static vector<string> splitExcludeEnclosedDelimiters (const string& str, const char delim = ',',
                                                        const string& encloser = "([{\"")
  {
    if(str.find_first_of(encloser) == string::npos) return split(str, delim);
    
    string::size_type open, delim_pos, next_index = 0;
    string pair, block, tail(str);
    vector<string> tokens;
    
    while (tail.find(delim) != string::npos) {
 
      delim_pos = tail.find_first_of(delim);
      
      //check if delim is within any enclosed block
      open = tail.find_first_of(encloser);
      
      //read and remove blocks
      while (open < delim_pos) {   
        
        block = getBlock(tail.substr(open, string::npos), tail.at(open));
        
        next_index = open + block.size();
        
        pair += tail.substr(0, next_index);
                
        tail = tail.substr(next_index);
                
        delim_pos = tail.find_first_of(delim);
        
        open = tail.find_first_of(encloser);        
      }
      
      pair += tail.substr(0, delim_pos);
      
      pair = removeEnclosingChar(pair, ' ', ' ', true);
      
      tokens.push_back(pair);
      pair.clear();
      
      if(delim_pos != string::npos) tail = tail.substr(delim_pos + 1);
      else break;
    }
 
    if(tail.size() != 0) {  //check for trailing space characters before adding relevant characters
      if(removeEnclosingChar(tail, ' ', ' ', true).size() != 0)
        tokens.push_back( removeEnclosingChar(tail, ' ', ' ', true) );
    }
 
 
    return tokens;
  }
  
  
  //----------------------------------------------------------------------------------------
  // getBlock
  //----------------------------------------------------------------------------------------
  static string getBlock(const string& str, const char start_c, const char end_c = '\0', 
                        bool includeEnclosing = true)
  {
    string out;
    char c, end = 0;
    bool closed = false;
    
    istringstream IN( removeEnclosingChar(str, ' ', ' ', true) );
    
    IN.get(c);
    
    if(end_c == 0) {
      switch (c) {
        case '(':
          end = ')';
          break;
        case '{':
          end = '}';
          break;
        case '[':
          end = ']';
          break;
        case '"':
          end = '"';
          break;
        default:
          error("tstring::getBlock: unknown start of block \'%c\'\n", c);
          break;
      }
    } else end = end_c;
    
    out += c;
 
    while (IN.get(c) && IN.good() && !IN.eof() ) {
      
      if(c == end) {
        
        out += c;
        closed = true;
        break;
        
      } else if(c == start_c) {//nested blocks
        
        out += __get_block(IN, start_c, end);
        
      } else out += c;
      
    } //__end_while__
 
    
    if(!closed) fatal("missing closing character '%c' in %s.\n", end, str.c_str());
    
    return out;
  } 
  //----------------------------------------------------------------------------------------
  // getBlock
  //----------------------------------------------------------------------------------------
  static string __get_block(istringstream& IN, const char start_c, const char end_c)
  {
    string out;
    char c;
    bool closed = false;
        
    out += start_c;
//    cout << "start block : "<<start_c<<endl;
    while (IN.get(c) && IN.good() && !IN.eof() ) {
      
      if(c == end_c) {
        
        out += c;
        closed = true;
        break;
        
      } else if(c == start_c) {//nested blocks
        
        out += __get_block(IN, start_c, end_c);
        
      } else out += c;
      
    } //__end_while__
//    cout<<out<<endl;
    
    if(!closed) fatal("missing closing character '%c' in %s.\n", end_c, IN.str().c_str());
    
    //    cout << "close block : "<< c << endl;
    
    return out;
  }    
  // ----------------------------------------------------------------------------------------
  // removeChar
  // ---------------------------------------------------------------------------------------- 
  static string removeChar(const string& str, const char c)
  {
    string s(str);
    
    for (unsigned int i = 0; i < s.size(); i++) {
      if (s[i] == c) {
        s.erase(s.begin() + i);
        i--;
      }
    }
    
    return s;
  }
  // ----------------------------------------------------------------------------------------
  // removeFirstCharOf
  // ----------------------------------------------------------------------------------------  
  static string removeFirstCharOf(const string& str, const char c)
  {
    string out(str);
    size_t pos;
    
    if( (pos = out.find_first_of(c)) != string::npos )
        out.erase(out.begin() + pos);
    
    return out;
  }
  // ----------------------------------------------------------------------------------------
  // removeLastCharOf
  // ----------------------------------------------------------------------------------------  
  static string removeLastCharOf(const string& str, const char c)
  {
    string out(str);
    size_t pos;
    
    if( (pos = out.find_last_of(c)) != string::npos )
      out.erase(out.begin() + pos);
    
    return out;
  }
  // ----------------------------------------------------------------------------------------
  // removeEnclosingChar
  // ----------------------------------------------------------------------------------------    
  static string removeEnclosingChar (const string& str, const char o, const char c, bool allowMissing = false)
  {
    string s(str);
    size_t first, last;
    
    first = s.find_first_of(o, 0);
    if(first != 0) {
      if(!allowMissing) {
        error("tstring::removeEnclosingChar:: string \"%s\" not starting with \"%c\"\n.", s.c_str(), o);
        return s;
      }
    } else 
      s.erase(s.begin());
    
    last = s.find_last_of(c);
    if(last != s.length()-1 || last == string::npos) {
      if(!allowMissing) {
        error("tstring::removeEnclosingChar:: string \"%s\" not ending with \"%c\"\n.", s.c_str(), c);
        return s;
      }
    } else
      s.erase(s.end()-1);
    
    return s;
  }
  // ----------------------------------------------------------------------------------------
  // removeLeadingWhiteSpace
  // ----------------------------------------------------------------------------------------
  static string removeLeadingWhiteSpace (const string& str)
  {
    string out(str);
 
    while(isspace(out[0]))
      out.erase(out.begin());
 
    return out;
  }
 
  static string replaceChar (const string& str, const char target, const char replacement)
  {
    string out(str);
    size_t pos = out.find_first_of(target, 0);
 
    while(pos != string::npos) {
      out[pos] = replacement;
      pos = out.find_first_of(target, pos);
    }
 
    return out;
  }
  // ----------------------------------------------------------------------------------------
  // isanumber
  // ----------------------------------------------------------------------------------------
  static bool isanumber(const string& str)
  {
    unsigned int i = 0;
    
    while(i < str.size()) {
      if(!isdigit(str[i]))
        if(str[i] != '.' && str[i] != 'e' && str[i] != '-'  && str[i] != '+')
          return false;
      i++;
    }
    
    return true;
  }
  
 
   static bool isNA(const string& str)
   {
     if("NA" == str) return true;
 
     if("na" == str) return true;
 
     if("NaN" == str) return true;
 
     if("NAN" == str) return true;
 
     if("nan" == str) return true;
 
     return false;
   }
};
 
 
 
#endif