GGSStringUtils Namespace Reference

A namespace with some utility methods for strings. More...

Functions
Tokens	Tokenize (const std::string &str, char delimiter= ' ')
	Extracts words from a string. More...
std::string	Trim (const std::string &str)
	Trims a string. More...
bool	IsInteger (const std::string &str)
	Checks if a string is an a integer. More...
bool	IsReal (const std::string &str)
	Checks if a string is a real number. More...
bool	IsGlobExpression (const std::string &str)
	Check if the given string is a glob expression. More...
std::string	RegexFromGlob (const std::string &str)
	Build a regex starting from a glob expression. More...

Detailed Description

A namespace with some utility methods for strings.

Function Documentation

bool GGSStringUtils::IsGlobExpression

(

const std::string &

str

)

Check if the given string is a glob expression.

A glob expression is recognized by looking at '*' or '?' characters in the string. Other glob wildcards are ignored.

Parameters

str	The string to be checked.

Returns

true if the string is a glob expression.

Definition at line 128 of file GGSStringUtils.cpp.

                                                          {
  if (str.find('*') != std::string::npos || str.find('?') != std::string::npos) {
    return true;
  }
  else {
    return false;
  }
}

bool GGSStringUtils::IsInteger

(

const std::string &

str

)

Checks if a string is an a integer.

Checks if the trimmed input string represents an integer value, possibly with sign.

Parameters

str	The input string.

Returns

true if the input string represents an integer value.

Definition at line 82 of file GGSStringUtils.cpp.

                                                   {
  std::string trimmedStr = Trim(str);
  if (trimmedStr.empty() || ((!isdigit(trimmedStr[0])) && (trimmedStr[0] != '-') && (trimmedStr[0] != '+')))
    return false;
  for (unsigned int iChar = 1; iChar < trimmedStr.size(); iChar++) {
    if (!isdigit(trimmedStr[iChar])) {
      return false;
    }
  }
  return true;
}

bool GGSStringUtils::IsReal

(

const std::string &

str

)

Checks if a string is a real number.

Checks if the trimmed input string represents a real value, possibly with sign, in the standard notation (e.g. 10.2, not 1.02e1). Note that integer numbers e.g. 10 are real numbers so they are recognized as real by this function.

Parameters

str	The input string.

Returns

true if the input string represents a real number in standard notation.

Definition at line 94 of file GGSStringUtils.cpp.

                                                {
  std::string trimmedStr = Trim(str);
  if (trimmedStr.empty() || ((!isdigit(trimmedStr[0])) && (trimmedStr[0] != '-') && (trimmedStr[0] != '+')))
    return false;
  bool hasPoint = false;
  bool hase = false;
  for (unsigned int iChar = 1; iChar < trimmedStr.size(); iChar++) {
    if (!isdigit(trimmedStr[iChar])) {
      if (trimmedStr[iChar] == '.') {
        if (hasPoint) {
          return false;
        }
        hasPoint = true;
      }
      else if (trimmedStr[iChar] == 'e') {
        if (hase) {
          return false;
        }
        hase = true;
        // After 'e' there must be a digit or a sign
        ++iChar;
        if (iChar >= trimmedStr.size()
            || (!isdigit(trimmedStr[iChar]) && (trimmedStr[iChar] != '-') && (trimmedStr[iChar] != '+'))) {
          return false;
        }
      }
      else {
        return false;
      }
    }
  }
  return true;
}

std::string GGSStringUtils::RegexFromGlob

(

const std::string &

str

)

Build a regex starting from a glob expression.

This function manages only the '*' and '?' glob wildcards.

Parameters

str	The glob expression.

Returns

The regex string corresponding to the given glob expression.

Definition at line 137 of file GGSStringUtils.cpp.

                                                            {
  static std::string regexStr;
  regexStr = str;
  std::string::size_type n = 0;
  while ((n = regexStr.find(".", n)) != std::string::npos) {
    regexStr.replace(n, 1, "\\.");
    n += 2;
  }
  n = 0;
  while ((n = regexStr.find("*", n)) != std::string::npos) {
    regexStr.replace(n, 1, ".*");
    n += 2;
  }
  std::replace(regexStr.begin(), regexStr.end(), '?', '.');
  return regexStr;
}

Tokens GGSStringUtils::Tokenize	(	const std::string &	str,
		char	delimiter = ' '
	)

Extracts words from a string.

The string must be a sequence of words separated by a given delimiter. A string portion enclosed within double quotation marks will be treated as a single word (the quotation marks will be removed). If the closing double quotation is missing then a std::runtime_error is thrown.

Parameters

str	The string to tokenize.
delimiter	A vector used to return the words in the string.

Returns

A collection of tokens (i.e. strings) in which the input string has been broken into.

Exceptions

std::runtime_error

if a non-terminated double-quotation-enclosed sequence is found.

Definition at line 13 of file GGSStringUtils.cpp.

                                                                    {
  Tokens tokens;

  size_t iChar = 0;
  char endliteralDelimiter = '\0';
  // Discard trailing spaces and tabs
  while (str[iChar] == ' ' || str[iChar] == '\t')
    iChar++;

  // Tokenize the string
  std::string token;
  tokens.clear();
  while (iChar < str.size()) {

    size_t iLast = 0;
    bool quotedText = false;
    if (str[iChar] == '\"') {
      quotedText = true;
      endliteralDelimiter = '\"';
      iChar++;
      iLast = str.find_first_of('\"', iChar);
    }
    else if (str[iChar] == '{') {
      quotedText = true;
      endliteralDelimiter = '}';
      iChar++;
      iLast = str.find_first_of('}', iChar);
    }
    else {
      iLast = str.find_first_of(delimiter, iChar + 1);
    }
    if (iLast != std::string::npos) {
      // Delimiter character found
      token = str.substr(iChar, iLast - iChar);
      if (str[iLast] == endliteralDelimiter) {
        iLast++;
        quotedText = false;
      }
    }
    else {
      // Delimiter character not found.
      if (quotedText) {
        // Missing closing double quotation.
        throw std::runtime_error(std::string("[GGSStringUtils::Tokenize] Missing closing ") + endliteralDelimiter);
      }
      else {
        // Take all the characters up to the end of the string
        token = str.substr(iChar);
      }
    }
    tokens.push_back(token);

    iChar = str.find_first_not_of(delimiter, iLast);
  }

  return tokens;
}

std::string GGSStringUtils::Trim

(

const std::string &

str

)

Trims a string.

Removes all leading and trailing invisible characters (spaces, tabs etc.).

Parameters

str	The input string.

Returns

a new string containing the trimmed input string.

Definition at line 71 of file GGSStringUtils.cpp.

                                                   {
  std::string retStr = str;
  retStr.erase(retStr.begin(), std::find_if(retStr.begin(), retStr.end(), [](int ch) {
    return !(std::isblank(static_cast<unsigned int>(ch)));
  }));
  retStr.erase(std::find_if(retStr.rbegin(), retStr.rend(), [](int ch) {
    return !(std::isblank(static_cast<unsigned int>(ch)));
  }).base(), retStr.end());
  return retStr;
}