PStringUtils.cpp

Go to the documentation of this file.

/***************************************************************************
 
  PStringUtils.cpp
 
  Author: Andreas Suter
  e-mail: andreas.suter@psi.ch
 
***************************************************************************/
 
/***************************************************************************
 *   Copyright (C) 2007-2026 by Andreas Suter                              *
 *   andreas.suter@psi.ch                                                  *
 *                                                                         *
 *   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 2 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 this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#include <cctype>
#include <cerrno>
#include <charconv>
#include <cstdlib>
 
#include "PStringUtils.h"
 
//--------------------------------------------------------------------------
// Split (static)
//--------------------------------------------------------------------------
std::vector<std::string> PStringUtils::Split(const std::string &str, const std::string &delimiters)
{
  std::vector<std::string> tokens;
  std::string::size_type start = str.find_first_not_of(delimiters);
  while (start != std::string::npos) {
    std::string::size_type end = str.find_first_of(delimiters, start);
    if (end == std::string::npos) {
      tokens.push_back(str.substr(start));
      break;
    }
    tokens.push_back(str.substr(start, end - start));
    start = str.find_first_not_of(delimiters, end);
  }
  return tokens;
}
 
//--------------------------------------------------------------------------
// IsInt (static)
//--------------------------------------------------------------------------
bool PStringUtils::IsInt(const std::string &str)
{
  // all characters must be digits or whitespace, with an optional single
  // leading sign (+/-) preceding the digits, and there must be at least one
  // digit (surrounding/embedded whitespace is tolerated, e.g. for tokens
  // split on ',' or ';' only).
  bool hasDigit = false;
  bool hasSign  = false;
  for (char c : str) {
    if (std::isdigit(static_cast<unsigned char>(c))) {
      hasDigit = true;
    } else if (c == '+' || c == '-') {
      // a sign is only valid before any digit and may appear at most once
      if (hasDigit || hasSign)
        return false;
      hasSign = true;
    } else if (!std::isspace(static_cast<unsigned char>(c))) {
      return false;
    }
  }
  return hasDigit;
}
 
//--------------------------------------------------------------------------
// IsFloat (static)
//--------------------------------------------------------------------------
bool PStringUtils::IsFloat(const std::string &str)
{
  // mirror TString::IsFloat(): surrounding whitespace is ignored (e.g. for
  // tokens split on ',' or ';' only), then a complete number is required.
  const std::string ws(" \t\n\r\f\v");
  std::string::size_type b = str.find_first_not_of(ws);
  if (b == std::string::npos)
    return false;
  std::string::size_type e = str.find_last_not_of(ws);
  const std::string t = str.substr(b, e - b + 1);
 
  std::string::size_type i = 0;
  if (t[i] == '+' || t[i] == '-')
    ++i;
  // reject things like "inf"/"nan" which strtod would otherwise accept
  if (i >= t.size() || !(std::isdigit(static_cast<unsigned char>(t[i])) || t[i] == '.'))
    return false;
  const char *begin = t.c_str();
  char *end = nullptr;
  std::strtod(begin, &end);
  return end == begin + t.size();
}
 
//--------------------------------------------------------------------------
// ToInt (static)
//--------------------------------------------------------------------------
int PStringUtils::ToInt(const std::string &str, bool *ok)
{
  // mirror TString::Atoi(): skip leading whitespace, then parse the leading
  // integer (a possible sign followed by decimal digits).
  const char *begin = str.c_str();
  const char *end = begin + str.size();
  while (begin != end && std::isspace(static_cast<unsigned char>(*begin)))
    ++begin;
 
  int value = 0;
  const std::from_chars_result res = std::from_chars(begin, end, value);
  if (ok != nullptr)
    *ok = (res.ec == std::errc{});
 
  return value;
}
 
//--------------------------------------------------------------------------
// ToDouble (static)
//--------------------------------------------------------------------------
double PStringUtils::ToDouble(const std::string &str, bool *ok)
{
  const char *begin = str.c_str();
  char *end = nullptr;
  errno = 0;
  const double value = std::strtod(begin, &end);
  if (ok != nullptr)
    *ok = (end != begin) && (errno != ERANGE);
 
  return value;
}
 
//--------------------------------------------------------------------------
// IsEqualNoCase (static)
//--------------------------------------------------------------------------
bool PStringUtils::IsEqualNoCase(const std::string &a, const std::string &b)
{
  if (a.size() != b.size())
    return false;
  for (std::string::size_type i = 0; i < a.size(); ++i) {
    if (std::tolower(static_cast<unsigned char>(a[i])) !=
        std::tolower(static_cast<unsigned char>(b[i])))
      return false;
  }
  return true;
}
 
//--------------------------------------------------------------------------
// ContainsNoCase (static)
//--------------------------------------------------------------------------
bool PStringUtils::ContainsNoCase(const std::string &haystack, const std::string &needle)
{
  if (needle.empty())
    return true;
  if (needle.size() > haystack.size())
    return false;
  auto toLower = [](unsigned char c) { return std::tolower(c); };
  for (std::string::size_type i = 0; i + needle.size() <= haystack.size(); ++i) {
    std::string::size_type j = 0;
    for (; j < needle.size(); ++j) {
      if (toLower(haystack[i+j]) != toLower(needle[j]))
        break;
    }
    if (j == needle.size())
      return true;
  }
  return false;
}
 
//--------------------------------------------------------------------------
// BeginsWithNoCase (static)
//--------------------------------------------------------------------------
bool PStringUtils::BeginsWithNoCase(const std::string &str, const std::string &prefix)
{
  if (prefix.size() > str.size())
    return false;
  for (std::string::size_type i = 0; i < prefix.size(); ++i) {
    if (std::tolower(static_cast<unsigned char>(str[i])) !=
        std::tolower(static_cast<unsigned char>(prefix[i])))
      return false;
  }
  return true;
}