tstring Class Reference

A global class to handle string conversions and operations. More...

#include <tstring.h>

Static Public Member Functions
static unsigned int	str2uint (const string &str)
	Converts a string into an unsigned integer. More...
static unsigned long	str2ulong (const string &str)
	Converts a string into an unsigned integer. More...
static int	str2int (const string &str)
	Converts a string into an integer. More...
static double	str2dble (const string &str)
	Converts a string into a double. More...
static string	int2str (const int i)
	Writes an integer value into a string. More...
static string	ulong2str (const unsigned long i)
	Writes an integer value into a string. More...
static string	dble2str (const double d)
	Writes a floating-point value into a string. More...
static vector< string >	split (const string &str, const char delim, bool splitOnce=false)
	splits a string into substrings (tokens) delimited by a single character. More...
static vector< string >	splitExcludeEnclosedDelimiters (const string &str, const char delim=',', const string &encloser="([{\"")
	Splits a string into substrings (tokens) delimited by a single character. More...
static string	getBlock (const string &str, const char start_c, const char end_c='\0', bool includeEnclosing=true)
	Reads a substring delimited by two enclosing character from a string. More...
static string	__get_block (istringstream &IN, const char start_c, const char end_c)
	Internal function used by getBlock to recursively read nested blocks. More...
static string	removeChar (const string &str, const char c)
	Removes a given character from a string. More...
static string	removeFirstCharOf (const string &str, const char c)
	Removes the first of a character found in a string. More...
static string	removeLastCharOf (const string &str, const char c)
	Removes the last of a character found in a string. More...
static string	removeEnclosingChar (const string &str, const char o, const char c, bool allowMissing=false)
	Removes characters enclosing a string. More...
static string	removeLeadingWhiteSpace (const string &str)
static string	replaceChar (const string &str, const char target, const char replacement)
static bool	isanumber (const string &str)
	Check whether the string is a number. More...
static bool	isNA (const string &str)
	Check whether the string is NA | NaN. More...

Private Member Functions
	tstring ()

Detailed Description

A global class to handle string conversions and operations.

Allows to parse the parameters argument strings into various tokens and to remove encolsing characters from a string.

Constructor & Destructor Documentation

tstring()

tstring::tstring ( )

inlineprivate

{}

Member Function Documentation

__get_block()

static string tstring::__get_block ( istringstream &  IN, const char  start_c, const char  end_c  )

inlinestatic

Internal function used by getBlock to recursively read nested blocks.

  {
    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;
  }    

References fatal().

dble2str()

static string tstring::dble2str ( const double  d )

inlinestatic

Writes a floating-point value into a string.

  {
    ostringstream OUT;
    OUT << d;
    return OUT.str();
  }  

Referenced by TTQFreqExtractor::FHwrite(), TTProtoWithMap::recordRandomMap(), ParamsParser::rexp(), ParamsParser::rgamma(), ParamsParser::rlognorm(), ParamsParser::rnorm(), ParamsParser::rpoiss(), ParamsParser::runif(), ParamsParser::seq(), and TTProtoWithMap::setRecombinationMapRandom().

getBlock()

static string tstring::getBlock ( const string &  str, const char  start_c, const char  end_c = '\0', bool  includeEnclosing = true  )

inlinestatic

Reads a substring delimited by two enclosing character from a string.

May or may not retain the enclosing characters.

  {
    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;
  } 

References error(), and fatal().

int2str()

static string tstring::int2str ( const int  i )

inlinestatic

Writes an integer value into a string.

  {
    ostringstream OUT;
    OUT << i;
    return OUT.str();
  }

Referenced by TTQuantiSH::addAvgPerPatch(), TTQuantiSH::addCovarPerPatch(), TTDispersalSH::addDispPerPatch(), TTQuantiSH::addEffectStats(), TTQuantiSH::addEigen(), TTQuantiSH::addEigenPerPatch(), TTQuantiSH::addEigenValues(), TTQuantiSH::addEigenValuesPerPatch(), TTQuantiSH::addEigenVect1(), TTQuantiSH::addEigenVect1PerPatch(), TTQuantiSH::addGenotPerPatch(), MPStatHandler::addIndNumPerPatch(), LCE_SelectionSH::addMeanPerPatch(), TTQuantiSH::addQuanti(), TTQuantiSH::addSkewPerPatch(), LCE_SelectionSH::addVarPerPatch(), TTQuantiSH::addVarPerPatch(), LCE_Resize::execute(), BinaryDataLoader::extractPop(), LCE_SelectionFH::FHwrite(), TTQFreqExtractor::FHwrite(), Metapop::loadPopFromBinarySource(), ParamsParser::rbernoul(), SimRunner::runPostExecReplicateWise(), TTNeutralGenesSH::setDxyRecorders(), TTNeutralGenesSH::setFreqRecorders(), and TTNeutralGenesSH::setNeiGeneticDistanceRecorders().

isanumber()

static bool tstring::isanumber ( const string &  str )

inlinestatic

Check whether the string is a number.

  {
    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;
  }

Referenced by FHPedigreeReader::FHread(), ParamsParser::getMacroSepParamChar(), ParamsParser::rbernoul(), ParamsParser::rep(), ParamsParser::rexp(), ParamsParser::rgamma(), ParamsParser::rlognorm(), ParamsParser::rnorm(), ParamsParser::rpoiss(), ParamsParser::runif(), ParamsParser::seq(), Param::set(), and ParamsParser::sym_matrix().

isNA()

static bool tstring::isNA ( const string &  str )

inlinestatic

Check whether the string is NA | NaN.

   {
     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;
   }

Referenced by FHPedigreeReader::FHread().

removeChar()

static string tstring::removeChar ( const string &  str, const char  c  )

inlinestatic

Removes a given character from a string.

  {
    string s(str);
    
    for (unsigned int i = 0; i < s.size(); i++) {
      if (s[i] == c) {
        s.erase(s.begin() + i);
        i--;
      }
    }
    
    return s;
  }

removeEnclosingChar()

static string tstring::removeEnclosingChar ( const string &  str, const char  o, const char  c, bool  allowMissing = false  )

inlinestatic

Removes characters enclosing a string.

Can be used to remove parenthesis/brackets or trailing whitespace characters.

Parameters

str	the string
o	the opening (front) character
c	the closing (back) character
allowMissing	if trus, allows to ignore a missing enclosing character

  {
    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;
  }

References error().

Referenced by ParamsParser::concat(), ParamsParser::diag_matrix(), ParamsParser::getMacroSepParamChar(), ParamsParser::matrix(), Param::parseArgument(), ParamsParser::rep(), LCE_BreedAssortativeMating::setParameters(), ParamsParser::sym_matrix(), and ParamsParser::tempseq().

removeFirstCharOf()

static string tstring::removeFirstCharOf ( const string &  str, const char  c  )

inlinestatic

Removes the first of a character found in a string.

  {
    string out(str);
    size_t pos;
    
    if( (pos = out.find_first_of(c)) != string::npos )
        out.erase(out.begin() + pos);
    
    return out;
  }

Referenced by Param::getArgumentFromFile(), and Param::parseTemporalArgument().

removeLastCharOf()

static string tstring::removeLastCharOf ( const string &  str, const char  c  )

inlinestatic

Removes the last of a character found in a string.

  {
    string out(str);
    size_t pos;
    
    if( (pos = out.find_last_of(c)) != string::npos )
      out.erase(out.begin() + pos);
    
    return out;
  }

Referenced by ParamsParser::rep().

removeLeadingWhiteSpace()

static string tstring::removeLeadingWhiteSpace ( const string &  str )

inlinestatic

  {
    string out(str);
 
    while(isspace(out[0]))
      out.erase(out.begin());
 
    return out;
  }

Referenced by Param::parseArgument(), and Param::parseTemporalArgument().

replaceChar()

static string tstring::replaceChar ( const string &  str, const char  target, const char  replacement  )

inlinestatic

  {
    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;
  }

Referenced by Param::parseArgument().

split()

static vector<string> tstring::split ( const string &  str, const char  delim, bool  splitOnce = false  )

inlinestatic

splits a string into substrings (tokens) delimited by a single character.

Parameters

str	the input string
delim	the token delimiter
splitOnce	if true, return the first token only

  {
    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;
  }

Referenced by ParamsParser::diag_matrix(), ParamsParser::matrix(), Param::parseTemporalArgument(), ParamsParser::rep(), ParamsParser::sym_matrix(), and ParamsParser::tempseq().

splitExcludeEnclosedDelimiters()

static vector<string> tstring::splitExcludeEnclosedDelimiters ( const string &  str, const char  delim = ',', const string &  encloser = "([{\""  )

inlinestatic

Splits a string into substrings (tokens) delimited by a single character.

The tokens may contain the delimiter character if it is enclosed. For instance: ‘(@g0 {{0,1,0,10}}, @g10 {{1,0,2,2}})’ --> [0] = ‘@g0 {{0,1,0,10}}’ and [1] = ‘@g10 {{1,0,2,2}}’

Parameters

str	the input string
delim	the token delimiter, is a comma by default
encloser	the character that starts an enclosed string

                                                                                    {\"")
  {
    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;
  }

Referenced by ParamsParser::getMacroArgs(), ParamsParser::getMacroParamValue(), ParamsParser::getMacroSepParamChar(), Param::parseArgument(), ParamsParser::rbernoul(), ParamsParser::rexp(), ParamsParser::rgamma(), ParamsParser::rlognorm(), ParamsParser::rnorm(), ParamsParser::rpoiss(), and ParamsParser::runif().

str2dble()

static double tstring::str2dble ( const string &  str )

inlinestatic

Converts a string into a double.

  {
    istringstream IN(str);
    double d;
    IN >> d;
    return d;
  }

Referenced by ParamsParser::rbernoul(), ParamsParser::rexp(), ParamsParser::rgamma(), ParamsParser::rlognorm(), ParamsParser::rnorm(), ParamsParser::rpoiss(), ParamsParser::runif(), ParamsParser::seq(), Param::set(), and ParamsParser::sym_matrix().

str2int()

static int tstring::str2int ( const string &  str )

inlinestatic

Converts a string into an integer.

  {
    istringstream IN(str);
    int i;
    IN >> i;
    return i;
  }

Referenced by ParamsParser::rep(), Param::set(), LCE_StatServiceNotifier::setOccurence(), LCE_Cross::setParameters(), and ParamsParser::sym_matrix().

str2uint()

static unsigned int tstring::str2uint ( const string &  str )

inlinestatic

Converts a string into an unsigned integer.

  {
    istringstream IN(str);
    unsigned int i;
    IN >> i;
    return i;
  }

Referenced by ParamsParser::diag_matrix(), ParamsParser::matrix(), Param::parseTemporalArgument(), ParamsParser::rbernoul(), ParamsParser::rexp(), ParamsParser::rgamma(), ParamsParser::rlognorm(), ParamsParser::rnorm(), ParamsParser::rpoiss(), and ParamsParser::runif().

str2ulong()

static unsigned long tstring::str2ulong ( const string &  str )

inlinestatic

Converts a string into an unsigned integer.

  {
    istringstream IN(str);
    unsigned long i;
    IN >> i;
    return i;
  }

Referenced by FHPedigreeReader::FHread().

ulong2str()

static string tstring::ulong2str ( const unsigned long  i )

inlinestatic

Writes an integer value into a string.

  {
    ostringstream OUT;
    OUT << i;
    return OUT.str();
  }  

Referenced by SimRunner::run().

---

The documentation for this class was generated from the following file:

• tstring.h